bound

Horismos Protocol

Define epistemic boundaries per decision through AI-guided classification. Type: (BoundaryUndefined, AI, DEFINE, TaskScope) → DefinedBoundary.

Definition

Horismos (ὁρισμός): A dialogical act of proactively defining epistemic boundaries per decision, where AI probes for boundary-undefined domains, dispatches the boundary kind up-front (a KindRouteMap of recognition seeds — direction/priority, scope, type/concept, ownership — plus an emergent/naming path) through a fail-closed deficit-fit certificate, collects contextual evidence to enrich classification quality, and presents each domain for user classification by a uniform settlement disposition (user-supplies / AI-proposes / AI-autonomous / dismiss) into a BoundaryMap consumed by all downstream protocols. The disposition coproduct is the same for every kind — the captured kind sets WHAT boundary is being settled, the disposition sets HOW that boundary value is settled downstream. Ownership is one kind among the seeds (who decides), and it is the degenerate case where the boundary value being settled is itself the disposition — so for ownership, content and disposition coincide; for every other kind they separate cleanly.

── FLOW ──
Horismos(T, B_prior?) → Probe(T) → Bᵢ? →
  |Bᵢ| = 0: Qc(zero_signal_finding) → Stop → [Confirm: deactivate | Reopen(d): Bᵢ := {d}, proceed]      -- zero-signal gate (Rule 12)
  |Bᵢ| > 0: Phase 0b sync_kind_route(T) → KindRouteMap →                                            -- up-front KIND dispatch (dispatch-first: kind settles before downstream consumers read it)
    [single_dominant_kind(KindRouteMap, T, context): relay(captured_kind + basis) (extension) → proceed (kind committed)   -- entropy→0 fast-path (option-set relay test): one kind dominates, foils route away → NO turn yield
     | else: Stop → captured_kind (constitution)]                                                   -- ≥2 viable hypotheses ∨ undecidable foil ∨ emergent gesture naming no single kind ∨ live ground leaves the emergent question undetermined → mandatory Constitution gate
    bind_kind(captured_kind) → KindBinding                                                           -- {label, positive_predicate, evidence, origin ∈ {seed, emergent}, atomicity}; non-atomic → split/route, re-sync before continuing
    certify(KindBinding, local_claims) → DeficitFitCertificate                                         -- fail-closed: status ≠ pass BLOCKS value-space binding (split / route claim / narrow-disambiguation first)
      status = route:      → route_away(routed_deficit) → deactivate (a local route claim holds the kind; no DefinedBoundary)
      status = ambiguous ∨ non-atomic: → re-sync Phase 0b (split / route / narrow-disambiguation) → re-certify
      status = pass:       → bind_value_space → BoundaryClassification                                  -- the uniform settlement-disposition coproduct, generated ONLY after certificate passes (same codomain for every kind; captured kind sets each option's content, not the coproduct)
    init_loop_state: cycle_n=1, BoundaryEssence="", B = seed_if_kind_match(B_prior, captured_kind), B_seed = Bᵢ (seed only when kind(B_prior) = captured_kind; kind-mismatched prior map → advisory, NOT seeded — see seed_if_kind_match; B_seed carries the Phase 0 domain signal — incl. the zero-signal Reopen(d) seed {d} — as unclassified cycle-1 anchor candidates (non-anchored remainder residualizes per Phase 1 step 5), never unioned into the classified map B), default=AIAutonomous (Extension-default initial, every kind), EssenceTrend=MixedTrend (kind-general — the per-cycle disposition-trend machinery runs for every kind), loop:
    Phase 1 Ctx(T, cycle_n) [per-cycle re-scan] → (Sub-D[cycle_n], auto_resolved?) →
      Sub-D empty ∧ residual ≠ ∅: → Phase 4 (substrate exhausted, residual remains)
      Sub-D empty ∧ residual = ∅: → TERMINAL CARRIERS (Phase 1 row) → DefinedBoundary → converge (substrate exhausted, all surfaced domains classified — no empty Phase 4 gate)
      auto_resolved: → Phase 3 (skip Phase 2 for this cycle; no user A — the substrate-settled classification is carried into Phase 3)
      else:          → Phase 2
    Phase 2 Qc(Sub-D[cycle_n], kind, BoundaryClassification, BoundaryEssence, cycle_n, B_snapshot, default) → Stop → A
    Phase 3 (user-response: conservative parse(A) → (typed_A?, termination?, override?) — a commitment is recognized only when the whole response's decision-relevant meaning supports that reading; otherwise Phase 2 re-presents from A with the map unmutated; auto-resolved: typed_A = substrate-settled classification, no termination/override) →
      integrate(typed_A?, B, BoundaryEssence) → (B', Δessence)                                      -- total current-cycle fold: classification updates the anchor; termination-only residualizes it and returns B' = B with the empty delta
      crystallize(Δessence, BoundaryEssence) → BoundaryEssence'                                      -- sole producer of the accumulated essence; the empty delta is the identity
      refresh B'-snapshot with the current default_for_residual                                       -- BEFORE the branch below, on EVERY fold including a terminating one: a just-residualized anchor gets its provisional entry here, so every route below reads a complete map
      ImplicitTermination: → TERMINAL CARRIERS (Phase 3 row) → DefinedBoundary → converge
                            -- "default" is Λ.default_for_residual at entry to Phase 3 (the value Phase 2 surfaced); NOT re-derived
      ExplicitTermination: → Phase 4
      else:                → derive(EssenceTrend, history') → default' for NEXT cycle (kind-general; count-only over the uniform disposition) → re-snapshot with default' → cycle_n += 1, loop
  Phase 4 (optional path) Qf(residual, FinalGateDisposition) → Stop → TERMINAL CARRIERS (Phase 4 row) → DefinedBoundary

── MORPHISM ──
TaskScope, B_prior?
  → probe(task, context)                                           -- detect boundary-undefined domains
  → sync_kind_route(task, context) → KindRouteMap                  -- up-front dispatch: one hypothesis for every recognition seed (direction/priority, scope, type/concept, ownership) + emergent/naming path; each seed hypothesis carries positive_predicate, evidence, differential_future, route_away conditions
  → [single_dominant_kind: relay(captured_kind) (extension) | else: present(KindRouteMap) (constitution)]  -- option-set relay test over the kind hypotheses AND the live ground: one dominant kind (entropy→0) relays without a turn yield — either a seed (positive_predicate satisfied, foils' route_away hold, no emergent indicated) or an emergent kind the user's own wording already names unambiguously; ≥2 viable ∨ undecidable foil ∨ an emergent gesture naming no single kind ∨ an emergent question the live ground leaves undetermined gates. BOTH branches feed bind_kind → certify → bind_value_space (certificate fail-closed on both)
  → bind_kind(captured_kind) → KindBinding                         -- {label, positive_predicate, evidence, seed|emergent, atomicity}; non-atomic kind → split or route before continuing
  → certify(KindBinding, local_claims) → DeficitFitCertificate         -- {own_claim, route_claims[], claimed_by, evidence, status}; fail-closed — status ≠ pass BLOCKS bind_value_space; fits the captured kind's positive_predicate against the own claim and the route claims inscribed in THIS SKILL.md
  → bind_value_space → BoundaryClassification                     -- the uniform settlement disposition {UserSupplies, AIPropose, AIAutonomous, Dismiss}, generated ONLY after certificate passes; same codomain for every kind (kind sets each option's content); relay / dead-signal test applied; frozen for the activation
  → seed(B_prior, B)                                               -- hermeneutic carry-over at Phase 0b step 4 (AFTER bind_value_space + B init): optional prior BoundaryMap seeds the freshly-initialized B ONLY when kind(B_prior) = captured_kind (same-kind — its dispositions were settled over the SAME boundary question). Values are always type-compatible now (every kind shares BoundaryClassification), so the guard is SEMANTIC: a kind-mismatched prior answers a DIFFERENT boundary question (e.g. an ownership prior's "AIAutonomous" decided who-owns, not how-wide a scope is) and is surfaced as advisory context, NOT seeded. Seeded domains enter `context_resolved` partition with "prior classification" basis (entries mutable in subsequent cycles). Phase 0 only DETECTS B_prior (binds Λ.B_prior together with its kind); it does not seed B, which does not exist until loop-state init
  → enrich(domains, codebase, cycle_n)                             -- per-cycle context collection (re-scan)
  → classify(domain, as_inquiry) → typed_A ∈ BoundaryClassification               -- per-cycle object_ref(kind) classification by the uniform settlement disposition (the captured kind sets the content of each disposition option; the 4-value coproduct itself is kind-invariant)
  → integrate(typed_A?, B, BoundaryEssence) → (B', Δessence)       -- total current-cycle fold; does NOT update default_for_residual
  → crystallize(Δessence, BoundaryEssence) → BoundaryEssence'      -- sole producer of the accumulated essence; the empty delta is the identity
  → snapshot(B', residual, default_for_residual) → B_complete'     -- refreshed after EVERY fold, termination included, and BEFORE any terminal route below: this is what gives a just-residualized anchor its provisional entry — classified entries ∪ (residual ↦ default_for_residual), at the value Phase 2 surfaced
  → derive(EssenceTrend, history') → default'                      -- count-based EssenceTrend → DefaultClassification for NEXT cycle's residual (runs on loop continuation ONLY; count-only over the uniform disposition, so the derivation is kind-general — it reads disposition counts, never kind-specific content)
  → snapshot(B', residual, default') → B_complete''                -- continuation only: supersedes B_complete' for the cycle about to open
  → [finalize | bulk_classify | identity] → Λ.boundary_map         -- terminal operation selected by the reachable convergence path; source, write, and final value are defined once in TERMINAL CARRIERS
  → DefinedBoundary
requires: boundary_undefined(T)            -- runtime checkpoint (Phase 0); sole activation precondition. (certificate.status = pass is the Phase-0b value-space-BINDING gate, NOT an activation precondition — it lives in the certificate-before-binding invariant below and the Phase 0b → Phase 1 transition; route/ambiguous status routes/re-syncs inside Phase 0b rather than blocking activation.)
deficit:  BoundaryUndefined                -- activation precondition (Layer 1/2); the certificate's own_claim deficit for in-scope kinds
preserves: task_identity(T)                -- task scope invariant; BoundaryMap and BoundaryEssence mutated; B_prior seed entries are mutable across cycles
invariant: Definition over Assumption
invariant: certificate-before-binding      -- DeficitFitCertificate.status = pass strictly precedes bind_value_space (shared meta-backbone order)

── TYPES ──
T              = TaskScope (task/project requiring boundary definition)
B_prior        = Optional(SeededPrior)                        -- optional invocation seed for hermeneutic carry-over (prior BoundaryMap detected in session context). Seeded into B at Phase 0b step 4 ONLY when the prior map's kind matches the captured kind (same-kind — same boundary question). The guard is SEMANTIC, not type-based: every kind shares BoundaryClassification, so a mismatched prior's values are type-valid but answer a DIFFERENT boundary question, so a kind-mismatched prior map is surfaced as advisory context, NOT seeded as a structural entry. Seed entries are mutable across cycles
SeededPrior    = { map: BoundaryMap, kind: Kind }             -- the prior BoundaryMap together with the boundary kind it was produced over (Phase 0 step 3 detection binds both). The carried kind is the typed carrier the same-kind guard tests: kind(B_prior) ≡ B_prior.kind
seed_if_kind_match : (Optional(SeededPrior), Kind) → BoundaryMap  -- seeds the prior map ONLY when B_prior.kind = captured_kind (returns B_prior.map); a kind-mismatched prior (B_prior.kind ≠ captured_kind) or B_prior = ⊥ returns ∅ (a mismatched prior is surfaced as advisory, not seeded)
Probe          = T → Set(Domain)                              -- boundary-undefined domain detection (Phase 0; existence check, not exhaustive enumeration)
Domain         = { name: String, description: String, evidence: Set(Evidence) }
Evidence       = { source: String, content: String }
Bᵢ             = Set(Domain) from Probe(T)                    -- initial boundary-undefined domain signal (cycle 1 seed: formally carried into Phase 0b loop-state init as Λ.B_seed = Bᵢ, kept separate from the classified map B until classification — on zero-signal Reopen(d), Bᵢ = {d} is the one entry the Phase 1 re-scan cannot be assumed to re-derive)
ZeroSignalConfirmation = user's answer to a zero-signal finding ∈ {Confirm, Reopen(Domain)}  -- Confirm accepts no boundary-undefined signal (Rule 12); Reopen names a domain Probe(T) missed, seeding it into Bᵢ and proceeding

-- Shared meta-backbone (KIND dispatch). One canonical schema; bound-local instantiation ONLY for object_ref, local_value_space, the label field's type (Kind), the own claim, and the local route claims.
KindRouteMap   = sync_kind_route : (T, context) → { hypotheses: List<KindHypothesis>, emergent: NamingPath }
                                                              -- up-front dispatch sync surfaced at Phase 0b; hypotheses contains one carrier for every recognition seed (direction/priority, scope, type/concept, ownership), while the emergent/naming path keeps the kind open beyond those priors
KindHypothesis = { label: Kind, positive_predicate: String, evidence: Set(Evidence), differential_future: String, route_away_if: String }
                                                              -- each named kind is a PRIOR (recognition seed), NOT a closed coproduct member (Rule 5: no fixed taxonomy)
NamingPath     = free-response affordance for a kind not among the seeds (emergent capture; user names the kind, or extends/replaces a seed)
single_dominant_kind : (KindRouteMap, T, context) → Bool      -- option-set relay test (entropy→0 predicate): true iff the live ground determines EXACTLY ONE kind, by either route — (a) SEED: exactly one hypothesis has its positive_predicate unambiguously satisfied by the framing, every other hypothesis' route_away_if holds, and (T, context) indicates no emergent capture; or (b) EMERGENT: (T, context) names exactly one emergent kind unambiguously, which IS the capture — the naming already happened in the user's own words, so gating it would ask for a value the live ground has settled. The seed conjuncts read KindRouteMap, which carries every recognition seed; the emergent conjunct turns on what the framing DENOTES, so it resolves against (T, context) — the user's own wording and the accumulated context — and the seed summary never stands in for it, because a summary cannot carry a branch whose decision rests on an unresolved denotation. An undecidable route_away_if, an emergent gesture resolving to no single naming, OR an emergent question (T, context) leaves undetermined makes the predicate false. true ⟹ the dispatch sync RELAYS the captured kind without a turn yield (Phase 0b sync_kind_route_relay, extension), citing its basis in the user's own wording — verbatim on route (b), where that wording IS the capture and a paraphrase would substitute the AI's reading for it; false ⟹ the mandatory Constitution gate fires (≥2 viable kind hypotheses, an undecidable foil, an emergent gesture naming no single kind, or an emergent question the live ground leaves undetermined). The captured kind still flows through bind_kind → fail-closed certify → bind_value_space on BOTH branches — the relay collapses only the kind-capture turn yield, NEVER the certificate (a non-pass certificate gets the full gated treatment — route → route_away/deactivate, ambiguous → re-sync the gate)
Kind           = captured boundary kind (seed ∈ {direction/priority, scope, type/concept, ownership} | emergent)
                 -- seeds ordered by recognition salience (a design prior, not an empirical usage claim): direction/priority (most salient), scope, type/concept, ownership (trailing seed). membership is NOT a first-class kind.
                 -- object_ref(kind) : the anchor the loop classifies (= Domain for bound, every kind; bound-local instantiation point — the kind sets WHAT the Domain's boundary is about, not the anchor type)
KindBinding    = { label: Kind, positive_predicate: String, evidence: Set(Evidence), origin ∈ {seed, emergent}, atomicity ∈ {atomic, non-atomic} }
                 -- captures the kind; if atomicity = non-atomic → split or route BEFORE certify (no value-space binding on a compound kind)
Deficit        = a deficit label a kind may be claimed by — bound's own BoundaryUndefined, or one of the sibling deficits named in the route claims below. Every label this certificate can assign is inscribed in THIS SKILL.md; nothing outside this file supplies one
OwnClaim       = { deficit: BoundaryUndefined, resolution: DefinedBoundary, in_scope_if: String }
                 -- the claim bound makes, stated as the WHOLE local morphism: the deficit it takes AND the resolution it produces. A kind is claimed here when its positive_predicate instantiates BoundaryUndefined AND the local value-space can carry it to DefinedBoundary — the bare deficit label is a name, the morphism is the predicate
DeficitFitCertificate = { own_claim: OwnClaim, route_claims: List<RouteClaim>, claimed_by: Set(Deficit), evidence: Set(Evidence), status ∈ {pass, route, ambiguous} }
                 -- fail-closed: status ≠ pass BLOCKS bind_value_space. Generated by fitting KindBinding.positive_predicate against own_claim and every route_claim inscribed below — the certificate reads nothing outside this SKILL.md
                 -- claimed_by collects every claim the evidence supports; a SET, so "no claim holds" is the value ∅ rather than a hole in the type
                 -- status = pass: claimed_by = {BoundaryUndefined} — the own claim holds alone → bind_value_space
                 -- status = route: claimed_by = {d} for a single route_claim's routed_deficit d → emit d as the typed handoff, deactivate (kind is out-of-scope for bound)
                 -- status = ambiguous: |claimed_by| ≠ 1 — several claims hold, or none holds on the evidence at hand → split, route, or one-turn narrow disambiguation BEFORE binding values (never silently bind under ambiguity). Which of the three resolves it is read at that turn from the session's own context and the user's wording, never fixed here
                 -- what a pass certifies is LOCAL ADMISSIBILITY: bound's own gate governing bound's own activation, not the absence of a claim anywhere in the wider protocol set. Where two protocols' scopes both reach a situation, each protocol's own gate governs
RouteClaim     = (route_if_predicate: String, routed_deficit: Deficit)
                 -- bound-local route claims — the sibling deficits a boundary-misfit kind is handed to. routed_deficit is the BINDING field; the command in parentheses is a non-binding hint for the user, not the relation this guard composes on:
                 --   missing pre-execution fact            → ContextInsufficient       (hint: /inquire)
                 --   unnoticed decision gap (not a boundary-kind settlement) → GapUnnoticed             (hint: /gap)
                 --   framework absent for the decision      → FrameworkAbsent           (hint: /frame)
                 --   cross-domain mapping uncertain         → MappingUncertain          (hint: /ground)
                 --   direction candidates' futures unrecognizable from description → DirectionUnrecognizable  (hint: /preview)
V              = bind_value_space : Kind → ValueSpace         -- the kind is the DOMAIN (it selects each option's content), but the codomain is CONSTANT — bind_value_space returns the same coproduct for every kind; generated ONLY after certificate.status = pass; frozen for the activation (relay / dead-signal test applied)
ValueSpace     = BoundaryClassification                       -- the uniform settlement disposition (local_value_space; bound-local instantiation point); the same coproduct for every boundary kind — see BoundaryClassification below
cycle_n        = Nat                                          -- current cycle counter (visible at Phase 2)
                                                              -- bound index `k` ranges over `Λ.D_history` (the cycles that produced a Sub-D) in the convergence trace — NOT [1, cycle_n], since a substrate-exhaustion terminal scan increments cycle_n without producing a Sub-D
Ctx            = (T, cycle_n) → Sub-D                         -- per-cycle context collection (re-scan)
Sub-D          = { domain: Domain, scan_summary: String, evidence: Set(Evidence) }  -- per-cycle dimension projection (one anchor domain per cycle)
                                                              -- Sub-D[k] = D_history[k] (k-th historical entry); current cycle = Sub-D[cycle_n]
Δessence       = String                                       -- per-cycle boundary-essence delta; produced by `integrate` at Phase 3 step 2 (integrate(typed_A?, B, BoundaryEssence) → (B', Δessence)); the termination-only fold produces the empty delta
BoundaryEssence = String                                      -- accumulated boundary essence (crystallized form of the responsibility boundary space); initialized "" at Phase 0; updated as BoundaryEssence' = BoundaryEssence ⊕ Δessence at Phase 3 by `crystallize` (crystallize(Δessence, BoundaryEssence) → BoundaryEssence'), the sole producer of BoundaryEssence'
EssenceTrend   ∈ {ExtensionTrend, ConstitutionTrend, MixedTrend}
                                                              -- kind-general: the disposition trend reads only the COUNT distribution of classified dispositions across Λ.history — never kind-specific content — so it runs identically for every captured kind
                                                              -- count-based ONLY; no textual-lean interpretation — keeps derivation deterministic and relay-eligible
                                                              -- ExtensionTrend: count(AIPropose ∪ AIAutonomous) strictly dominant
                                                              -- ConstitutionTrend: count(UserSupplies) strictly dominant
                                                              -- MixedTrend: no strict dominance OR cycle_n < 2 (explicit single-cycle initialization rule — insufficient classification history to commit a non-fallback trend)
default_for   : Kind → BoundaryClassification member          -- INITIAL default selector, applied once at Phase 0b loop-state init; → AIAutonomous (Extension-default initial) for every kind (a constant selector). Distinct from DefaultClassification, which re-derives the default per cycle from EssenceTrend.
DefaultClassification : EssenceTrend → {AIAutonomous, UserSupplies} ⊆ BoundaryClassification
                                                              -- kind-general per-cycle default re-derivation (reads disposition counts, kind-independent)
                                                              -- codomain restricted to the 2-value reachable subset (AIPropose and Dismiss are unreachable from this function)
                                                              -- ExtensionTrend → AIAutonomous; ConstitutionTrend → UserSupplies; MixedTrend → AIAutonomous (Extension-default fallback)
Qc             = Per-cycle boundary classification interaction [Tool: Constitution interaction]
A              = the Phase 2 user response — an OPEN utterance, never a classification.
                 -- parse(A) → (typed_A?, termination?, override?) is conservative whole-utterance recognition. A commitment may be returned only when every decision-relevant part of A is coherent with and represented by that reading. If any part reframes the anchor, names an emergent concern, shifts the axis, or undercuts the apparent commitment, parse returns no commitment and Phase 2 re-presents with that material drawn directly from A in the conversation record. No separate framing carrier is needed, and no decision-relevant material can disappear down a terminal path.
                 -- Recognizing NO commitment (neither typed_A nor termination) is legitimate, not malformed: no map commitment exists yet. The map remains unchanged and the deliberative self-edge may stutter without an exhaustion bound; committing a disposition would exercise authority the user did not delegate.
typed_A        = the cycle's classification ∈ BoundaryClassification         -- recognized within the user's response on a Phase 2 cycle, or read from the substrate assignment on an auto-resolved cycle (Phase 1 step 4); its origin is recoverable from which MODE STATE partition the anchor landed in (Λ.user_responded / Λ.dismissed vs Λ.context_resolved), so the convergence trace can cite it. Drawn from the uniform settlement disposition; the presented option set is exactly this 4-value coproduct, intact per gate integrity invariant (a termination-only response carries no typed_A and is NOT an option-set extension — Rule 14)
                 -- typed_A ∈ {UserSupplies(boundary), AIPropose(boundary), AIAutonomous(boundary), Dismiss} — the 4-value coproduct is kind-invariant; the captured kind sets what `boundary` refers to (who-decides for ownership, which-way for direction/priority, how-wide for scope, which-category for type/concept)
                 -- termination_intent surfaces via free-response affordance, NOT as an extra option in BoundaryClassification
TerminationIntent = parsed natural-language signal of user satisfaction
                  ∈ {ImplicitTermination(default_override?), ExplicitTermination}
                                                              -- ImplicitTermination: residual ↦ default_at_surfacing (the Λ.default_for_residual value visible in the just-completed Phase 2 surfacing; NOT re-derived in Phase 3) OR user-stated override; terminal provenance is defined in TERMINAL CARRIERS
                                                              -- ExplicitTermination: enter Phase 4 for bulk residual classification
                                                              -- default_override : BoundaryClassification — optional user-named alternative default (a member of the uniform settlement disposition) overriding the surfaced default
B              = BoundaryMap: Map(object_ref(kind), BoundaryClassification)
                 -- value type is the uniform settlement disposition BoundaryClassification — the SAME value type for every kind (the BoundaryMap value does NOT follow the kind; the kind sets only what content each entry's disposition is about)
                 -- object_ref(kind) = Domain for bound, every kind (bound-local instantiation)
                 -- Always-complete after each Phase 2 round: classified entries (per-cycle answers + auto-resolved) ∪ residual entries provisionally mapped to current default_for_residual
                 -- Snapshot completeness makes ImplicitTermination AVAILABLE at any cycle; snapshots are recognition surfaces, while TERMINAL CARRIERS exclusively defines what convergence emits.
BoundaryClassification = {UserSupplies(boundary), AIPropose(boundary), AIAutonomous(boundary), Dismiss}
                 -- the UNIFORM settlement disposition (local_value_space): HOW the captured kind's boundary value is settled downstream — the SAME 4-value coproduct for every kind, used across Phase 2 (per-cycle) and Phase 4 (residual bulk)
                 -- the OWNERSHIP kind is the degenerate case: there the boundary value being settled (who decides) IS the disposition, so disposition and content coincide — which is why this coproduct historically read as ownership-specific. For every other kind the disposition says HOW the boundary value gets settled while the kind says WHAT that value is about (direction/priority, scope, type/concept)
                 -- UserSupplies semantic (kind-general): user retains settlement authority for this boundary; downstream gates present open questions; user supplies the boundary value (or invokes other protocols) at decision-point activation
                 -- Dismiss is a COMMITTED no-boundary signal (proceed with the stated default), an on-axis disposition — not a skip; its differential future is "residual settled by default," distinct from the three active-settlement members
Qf             = Final gate bulk classification interaction [Tool: Constitution interaction]
FinalGateDisposition = {UserSupplies, AIAutonomous} ⊆ BoundaryClassification    -- the uniform residual-disposition subset surfaced at Phase 4, the same for every kind (the two settlement dispositions a bulk residual can take)
FinalGateAnswer = FinalGateDisposition                                                                          -- Phase 4 surfacing subset (the uniform residual-disposition subset of BoundaryClassification)
                 -- Phase 4 UserSupplies (kind-general): bulk-classify residual domains as user-retained (each residual domain becomes its own boundary; lazy-binding — values or protocol invocation deferred to downstream activation)
                 -- Phase 4 AIAutonomous (kind-general): bulk-classify residual as AI-settled (semantically equivalent to per-cycle AIAutonomous(boundary))
DefinedBoundary = { map: Λ.boundary_map, kind: Λ.captured_kind } where one TERMINAL CARRIERS row completed ∧ BoundaryEssence finalized
                 -- TERMINAL CARRIERS is the exclusive provenance definition for the result map. The kind pairing makes the map's boundary question recoverable by a later /bound seed guard and by downstream advisory consumers because object_ref(kind) = Domain does not encode the kind.
Phase          ∈ {0, 0b, 1, 2, 3, 4}

── PHASE TRANSITIONS ──
Phase 0: T, B_prior? → Probe(T) → scan_B_prior(T) → Λ.B_prior → Bᵢ?                                           -- boundary existence checkpoint + optional hermeneutic-seed DETECTION (silent); detection binds Λ.B_prior but does NOT seed B — B does not exist yet (loop state, incl. boundary_map, is initialized at Phase 0b step 4 after the kind is captured and the certificate passes, since binding is gated on a passing certificate)
       [Bᵢ = ∅] Qc(zero_signal_finding) → Stop → ZeroSignalConfirmation   -- zero-signal (Rule 12): Confirm → deactivate (Horismos not activated) | Reopen(d) → Bᵢ := {d}, proceed to Phase 0b [Tool]
Phase 0b: T → sync_kind_route(T) → KindRouteMap → [single_dominant_kind: relay(captured_kind + basis) → proceed (extension, kind committed, NO Stop) | else: Stop → captured_kind (constitution)]
       → bind_kind(captured_kind) → KindBinding
       → certify(KindBinding, local_claims) → DeficitFitCertificate
       → (status = pass) bind_value_space → BoundaryClassification → init_loop_state(default_for(kind), B = seed_if_kind_match(Λ.B_prior, captured_kind), B_seed = Bᵢ)
                                                                                                              -- up-front KIND dispatch + fail-closed certificate + uniform value-space, THEN loop-state init (cycle_n, BoundaryEssence, default_for_residual = default_for(kind) = AIAutonomous, and the B_prior seed into B) — the seed folds into Phase 0b step 4, AFTER B is initialized, never before; seeded ONLY when kind(Λ.B_prior) = captured_kind (same boundary question), kind-mismatched prior map surfaced as advisory not seeded; Λ.B_seed := Bᵢ carries the domain signal as unclassified cycle-1 anchor candidates (non-anchored remainder residualizes per Phase 1 step 5), separate from the classified map B (partition invariant preserved) — the formal carrier of the zero-signal Reopen(d) seed {d}, which the Phase 1 re-scan cannot be assumed to re-derive [Tool: Constitution gate | Extension relay (single-dominant-kind)]
Phase 1: T, cycle_n → Ctx(T, cycle_n) → candidates[cycle_n] → (cycle_n = 1: candidates[1] := candidates[1] ∪ (Λ.B_seed \ Λ.domains_touched)) → (Sub-D[cycle_n], auto_resolved?)   -- per-cycle context collection; cycle-1 anchor selection runs over candidates[1] = newly-surfaced ∪ (Λ.B_seed \ Λ.domains_touched) (seed joins BEFORE Sub-D binds — step 2; a Reopen(d) seed stays an anchor candidate even when the re-scan misses it; an already-touched seed domain — e.g. B_prior-seeded into context_resolved — is excluded here and re-enters ONLY via step 1's stale-seed re-surface, preserving the pairwise-disjoint partition), then auto-resolve check [Tool]
       → (cycle_n = 1) non-anchored B_seed remainder (deduped set) → Λ.residual ∪ Λ.domains_touched; Λ.B_seed := ∅   -- cycle-1 B_seed consumption (track): non-anchored remainder of the deduped seed residualizes (step 5), cleared after consumption (consumed once)
Phase 2: Sub-D[cycle_n], kind, BoundaryClassification, BoundaryEssence, cycle_n, B_snapshot, default
       → Qc(Sub-D[cycle_n], kind, BoundaryClassification, BoundaryEssence, cycle_n, B_snapshot, default) → Stop → A          -- per-cycle classification over BoundaryClassification with complete B_snapshot + default visibility [Tool]
Phase 3: (user-response: A → conservative parse(A) → (typed_A?, termination?, override?)) | (auto-resolved: typed_A = substrate-settled classification from Phase 1 step 4, no termination/override)
       → integrate(typed_A?, B, BoundaryEssence) → (B', Δessence)                                             -- total cycle fold: a classification updates the anchor; a termination-only reading residualizes it and returns B' = B with the empty delta
       → crystallize(Δessence, BoundaryEssence) → BoundaryEssence'                                            -- sole producer of the accumulated essence; the empty delta is the identity
       → snapshot(B', Λ.residual, default_for_residual) → B_complete'                                         -- ALWAYS, termination folds included, and BEFORE any route: the round-local completeness invariant holds after EVERY fold, so a just-residualized anchor carries its provisional entry before any terminal write reads it
       → (only on loop continuation) derive(EssenceTrend, history') → default' → snapshot(B', Λ.residual, default') → B_complete''
                                                                                                              -- next-cycle default (track + sense), then the snapshot that supersedes B_complete' for the cycle about to open; EssenceTrend re-derivation is kind-general (count-only over the uniform disposition)
Phase 4 (optional): residual, BoundaryEssence → Qf(residual, FinalGateDisposition) → Stop → Λ.final_gate_answers
                                                                                                              -- final gate [Tool], reached via ExplicitTermination or Phase 1 substrate exhaustion; FinalGateDisposition = {UserSupplies, AIAutonomous}, every kind

Phase 0 → Phase 0b: boundary_undefined(T) = true ∨ ZeroSignalConfirmation = Reopen(d)       -- domain signal present (probe-detected, or user-reopened seeding Bᵢ := {d}) → dispatch the kind before the loop
Phase 0 → deactivate: boundary_undefined(T) = false ∧ ZeroSignalConfirmation = Confirm      -- no undefined boundary signal, zero-signal finding confirmed (Rule 12)
Phase 0b sync_kind_route relay branch: single_dominant_kind(KindRouteMap, T, context) = true → relay captured_kind + basis, proceed (extension, NO turn yield) → continue to bind_kind   -- entropy→0 (option-set relay test): one kind dominates, foils route away; the captured kind is committed for the activation (a rare mis-relay is corrected by re-invoking /bound, not an in-loop redirect); certify stays fail-closed
Phase 0b sync_kind_route gated branch: single_dominant_kind(KindRouteMap, T, context) = false → Stop → captured_kind (constitution)                                                                      -- ≥2 viable hypotheses ∨ undecidable foil ∨ emergent gesture naming no single kind ∨ live ground leaves the emergent question undetermined → mandatory Constitution gate
Phase 0b → Phase 1: certificate.status = pass ∧ BoundaryClassification bound                               -- kind captured (via relay or gate), fit certified, value-space frozen → enter the per-cycle loop
Phase 0b → deactivate (route): certificate.status = route                                   -- a local route claim holds the kind → route_away(RouteClaim.routed_deficit), residual untreated (kind out-of-scope for bound)
Phase 0b → Phase 0b (re-sync): certificate.status = ambiguous ∨ KindBinding.atomicity = non-atomic
                                                                                            -- |claimed_by| ≠ 1 (several claims hold, or none does) OR compound kind → split / route / one-turn narrow disambiguation, then re-certify BEFORE binding values (fail-closed; never bind under ambiguity)
Phase 1 → Phase 2:  Sub-D[cycle_n] non-empty ∧ ¬auto_resolved                               -- per-cycle anchor domain surfaced, requires user judgment
Phase 1 → Phase 3:  Sub-D[cycle_n] non-empty ∧ auto_resolved                                -- definitive assignment found in substrate, skip Phase 2
Phase 1 → Phase 4:  Sub-D[cycle_n] empty ∧ Λ.residual ≠ ∅                                   -- substrate-exhaustion path to explicit bulk classify (residual remains)
Phase 1 → converge: Sub-D[cycle_n] empty ∧ Λ.residual = ∅ → substrate-exhaustion terminal carrier             -- every surfaced domain already classified; no empty Phase 4 gate
Phase 2 → Phase 3:  A received ∧ commitment recognized (typed_A ∨ termination)               -- parse recognized a commitment in the response: typed classification, termination signal, or both
Phase 2 → Phase 2:  A received ∧ no commitment recognized                                    -- re-present from A with every decision-relevant reframing made visible; the map is unchanged. This deliberative self-edge carries no monotone progress claim and no exhaustion bound: it may stutter until the user constitutes a commitment [Tool]
Phase 3 → Phase 3 (confirm): parse leaves ≥2 J routing branches viable → Qc(candidate readings) → Stop → confirmed_intent ∈ J   -- Rule 20; routing resumes at J with the confirmed branch, which is a TerminationIntent member on the terminating branches and the absence of one on `next` [Tool]
Phase 3 → Phase 1:  ¬termination_intent → derive default' → cycle_n += 1             -- continue loop with next-cycle default
Phase 3 → converge (implicit): TerminationIntent = ImplicitTermination → implicit terminal carrier             -- Phase 2-surfaced default committed (NOT re-derived)
Phase 3 → Phase 4:  TerminationIntent = ExplicitTermination                                 -- user-judged satisfaction with explicit residual classification request
Phase 4 → converge: Λ.final_gate_answers covers Λ.residual → Phase 4 terminal carrier                              -- BoundaryMap + BoundaryEssence finalized

── TERMINAL CARRIERS ──
The table below is the sole definition of DefinedBoundary map provenance. Every graceful path starts from an initialized map source, completes its terminal write, and emits only the resulting Λ.boundary_map paired with Λ.captured_kind.

Path                              | Initialized source                                                   | Terminal write                                                                                                  | Final value
Phase 3 ImplicitTermination       | B' from the current cycle fold, which has ALREADY placed the anchor per the parse — a response carrying typed_A leaves the anchor classified in B', a termination-only response residualizes it; Λ.residual is read as the fold left it and is NEVER assumed to hold the anchor, so a classification the user just stated is never overwritten by the residual disposition; residual_disposition = user override when stated, otherwise default_at_surfacing | finalize(B', Λ.residual, residual_disposition) → B_final; Λ.boundary_map := B_final | { map: Λ.boundary_map, kind: Λ.captured_kind }
Phase 4 completed                 | Λ.boundary_map at Phase 4 entry + Λ.residual + Λ.final_gate_answers | bulk_classify overwrites every residual provisional entry, moves those domains to final_gate_classified, empties Λ.residual, and writes Λ.boundary_map | { map: Λ.boundary_map, kind: Λ.captured_kind }
Phase 1 substrate exhaustion      | Λ.boundary_map at the guarded edge where Λ.residual = ∅             | identity; Λ.boundary_map is unchanged                                                                           | { map: Λ.boundary_map, kind: Λ.captured_kind }

B_snapshot and B_complete' are recognition surfaces only. Neither is a result carrier, and pairing either with a kind does not constitute DefinedBoundary.

── LOOP ──
Pre-loop dispatch (Phase 0b, one-shot — runs once before the per-cycle loop opens):
  sync_kind_route(T) surfaces the KindRouteMap (every recognition seed + emergent/naming path); the user captures the kind (recognize a seed, name an emergent, or extend/replace a seed).
  Extension fast-path (single-dominant-kind relay): when single_dominant_kind(KindRouteMap, T, context) holds (per the single_dominant_kind predicate (TYPES) and Rule 24) — present the captured kind + its basis as relay text and proceed (the captured kind is committed for the activation), recording Λ.captured_kind with ZERO turn yields. The basis is the dominating predicate + the foils' route-away on the seed route, and the user's own naming quoted verbatim on the emergent route. The mandatory Constitution gate fires when single_dominant_kind is false — the default when in doubt; relay is the NARROW exception (Rule 24).
  bind_kind → certify (fail-closed) → bind_value_space. The captured kind FIXES BoundaryClassification for the whole activation; the per-cycle loop classifies object_ref(kind) over the frozen BoundaryClassification. BOTH branches (relay and gate) feed this same pipeline — the relay collapses only the kind-capture turn yield; a non-pass certificate still gets the full gated treatment. Re-sync on ambiguous/non-atomic; route_away (deactivate) when a local route claim holds the kind.

J = {next, terminate_implicit, terminate_explicit}
  (every value read below is the CONFIRMED one — a parse leaving ≥2 routing branches viable is resolved to a single branch via Rule 20's one-turn confirmation gate at Phase 3 step 1 BEFORE J is evaluated, and a confirmed `next` is the absence of a TerminationIntent rather than a member of it; routing here is immediate only for an unambiguous parse)
  next:               ¬termination_intent → next-cycle default' (re-derive count-based from EssenceTrend, kind-general) → cycle_n += 1, Phase 3 → Phase 1 (per-cycle re-scan)
  terminate_implicit: TerminationIntent = ImplicitTermination (parsed from Phase 2 free response) → Phase 3 → converge with residual filled by default_at_surfacing (the Λ.default_for_residual value Phase 2 surfaced — NOT re-derived) or user-stated override; a termination-only response (no typed selection) first residualizes the current anchor (Phase 3 step 2), so it is included in that fill
  terminate_explicit: TerminationIntent = ExplicitTermination (parsed from Phase 2 free response) → Phase 3 → Phase 4 (final gate)

Per-cycle re-scan: Phase 1 substrate scan (artifact read/artifact search) re-executes each cycle; `Λ.domains_touched` (anchored ⊔ non-anchored ⊔ resolved/dismissed) is the dedup source — no domain surfaced twice.
Cycle 1 ordering: AI Impact ordering selects highest-impact domain.
Cycle k≥2 ordering: previous cycle's typed_A[cycle_n-1] or free-response routes next cycle's domain selection frame; AI re-applies Impact ordering within the routed frame.

Answer types (members of the uniform disposition BoundaryClassification: UserSupplies/AIPropose/AIAutonomous/Dismiss) determine BoundaryMap entry, not loop path.
FinalGateAnswer (the uniform subset {UserSupplies, AIAutonomous} ⊆ BoundaryClassification, every kind) determines residual BoundaryMap entries at Phase 4.

Round-local BoundaryMap invariant: after each Phase 3 integrate — termination folds included, since the snapshot refresh is NOT conditioned on loop continuation — `Λ.boundary_map` snapshot is always complete: classified entries ∪ (residual ↦ default_for_residual). Snapshot completeness makes ImplicitTermination available AND gives every residual domain the provisional entry the Phase 4 bulk_classify overwrite reads, so no domain reaches a terminal write without an entry; TERMINAL CARRIERS governs every emitted result.

Convergence evidence: At convergence (Phase 3 ImplicitTermination ∨ Phase 4 completed ∨ substrate-exhaustion empty-residual), present transformation trace — per-cycle (Sub-D[k], Δessence[k], disposition[k]) for each anchored cycle k (k ranges over Λ.D_history — the cycles that produced a Sub-D; a substrate-exhaustion terminal scan produces no Sub-D and contributes no entry; disposition[k] ∈ BoundaryClassification is READ FROM the finalized Λ.boundary_map entry for Sub-D[k].domain, never re-declared per terminal path — the trace evidences the emitted map, so it carries the map's own value for that domain whichever path assigned it; Δessence[k] is the delta integrate produced for cycle k, or the empty delta when the cycle produced no classification), plus residual disposition:
Cover: the parts together range over the domains of the EMITTED Λ.boundary_map, each domain reported exactly once. "non-anchored d" means d ∉ { s.domain | s ∈ Λ.D_history } — compared on DOMAIN IDENTITY, since D_history holds Sub-D projections while the partition sets hold Domains, and a raw membership test across the two types would fail to exclude an auto-resolved anchor. Anchored membership takes precedence, so a domain anchored in some cycle is reported only as a per-cycle entry even when it also sits in context_resolved (auto-resolved), residual (the termination-only anchor), or final_gate_classified. Every other map domain — a kind-matched B_prior seed left unchanged in context_resolved, a non-anchored domain accumulated into residual, a bulk-classified domain — is reported by the matching part below. A map domain in neither part is a gap in the evidence, not an omission the trace may make.
  • ImplicitTermination: ∀ non-anchored d ∈ residual: (d, default_at_surfacing_or_override) — basis follows which value committed: the EssenceTrend / count-distribution derivation when the surfaced default committed (kind-general), the user's stated override when one did
  • Phase 4 completion: ∀ non-anchored d ∈ final_gate_classified: (d, FinalGateAnswer(d))   -- the partition bulk_classify moved them into; Λ.residual is empty by then
  • Seeded-and-unchanged: ∀ non-anchored d ∈ context_resolved: (d, disposition(d)) — cites the substrate assignment or the prior-classification seed basis; these never anchored a cycle, so nothing else reports them
  • substrate-exhaustion empty-residual: residual = ∅ — no residual disposition (every surfaced domain classified per-cycle)
BoundaryEssence is presented as separate session text artifact. Convergence is demonstrated, not asserted.

── CONVERGENCE ──
converge iff (Phase 3 ImplicitTermination ∨ Phase 4 completed ∨ substrate_exhaustion_empty_residual) ∧ certificate.status = pass
  certificate gate:            convergence presupposes a passing DeficitFitCertificate (Phase 0b); a route/ambiguous certificate never reaches the loop, so DefinedBoundary is unreachable without an in-scope, fit-certified kind. The pass certifies LOCAL admissibility — bound's own gate over bound's own activation — not the absence of a claim anywhere in the wider protocol set
  kind_dispatch_branch:        the captured kind reaches the loop via EITHER branch of Phase 0b sync_kind_route — the single_dominant_kind relay (extension, no turn yield) or the mandatory Constitution gate — and both flow through the fail-closed certificate, so convergence is branch-invariant: a relay-captured kind whose certificate is route (routes away/deactivates) or ambiguous (re-syncs the gate) never reaches the loop, exactly as the gated branch does
  Phase 3 ImplicitTermination: the Phase 3 ImplicitTermination row in TERMINAL CARRIERS completed
  Phase 4 completed:           the Phase 4 row in TERMINAL CARRIERS completed — reachable via Phase 3 ExplicitTermination OR Phase 1 substrate exhaustion with residual remaining
  substrate_exhaustion_empty_residual: the substrate-exhaustion row in TERMINAL CARRIERS completed under Sub-D empty ∧ Λ.residual = ∅
  route_deactivate:            Phase 0b certificate.status = route → route_away(RouteClaim.routed_deficit), non-convergent exit (kind out-of-scope for bound; no DefinedBoundary emitted)

── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 Probe (sense)        → Internal analysis (silent — no user output; heuristic boundary-undefined detection + session-context scan for a prior BoundaryMap as Λ.B_prior (DETECTION only — Phase 0 seeds nothing; a kind-matched prior is seeded at Phase 0b step 4, a kind-mismatched prior stays advisory-only); notice visibility deferred to Phase 2 cycle 1 surfacing)
Phase 0 ZeroSignalConfirm (constitution) → present (conditional: Bᵢ = ∅; zero-signal finding + reasoning; Confirm/Reopen(Domain) — Rule 12)
Phase 0b sync_kind_route (constitution) → present (GATED branch — fires when single_dominant_kind = false: ≥2 seeds stay viable under the framing, a seed's route-away is undecidable from the framing, an emergent gesture resolves to no single naming, OR the live ground (T, context) leaves the emergent question undetermined; up-front KindRouteMap — one hypothesis for every recognition seed, each with positive_predicate + evidence + differential_future + route-away conditions, plus an emergent/naming free-response path; named kinds are PRIORS not a closed set; user captures the kind by recognizing a seed, naming an emergent, or extending/replacing a seed)
Phase 0b sync_kind_route_relay (extension) → TextPresent+Proceed (RELAY branch — fires when single_dominant_kind = true, per the single_dominant_kind predicate (TYPES) and Rule 24. Present the captured kind + its basis as relay text — the basis quotes the user's own wording rather than paraphrasing it wherever the emergent conjunct carried the decision, and quotes it VERBATIM when the relay fires because the user already named the emergent kind, since there that wording IS the capture — and proceed, recording Λ.captured_kind WITHOUT a turn yield; the captured kind is committed for the activation (like the gated branch) — a rare mis-relay is corrected by re-invoking /bound, not an in-loop redirect transition. The fail-closed certify STILL runs on this branch — a non-pass DeficitFitCertificate gets the full gated treatment (route → route_away/deactivate, ambiguous → re-sync), so the relay never bypasses deficit-fit)
Phase 0b certify (sense)     → Internal analysis (extension — fail-closed DeficitFitCertificate; deterministic check of KindBinding.positive_predicate against the own claim and the route claims inscribed in this SKILL.md, reading nothing outside this file: claimed_by = {BoundaryUndefined} when the own claim holds alone; status = pass | route | ambiguous; basis = the cited claim fit, shown at Phase 2 cycle 1's first surfacing)
Phase 0b bind_value_space (track) → Internal state update (extension — generate the uniform settlement disposition {UserSupplies, AIPropose, AIAutonomous, Dismiss} ONLY after certificate.status = pass; same coproduct for every kind; relay / dead-signal test applied; freeze BoundaryClassification for the activation. On status = route → route_away(routed_deficit), deactivate; on status = ambiguous ∨ non-atomic → re-sync Phase 0b before binding)
Phase 1 Ctx   (observe)      → artifact read, artifact search (per-cycle re-scan: CLAUDE.md, project rule files, prior session context)
Phase 1       (track)        → Internal state update (cycle 1 only: Λ.B_seed candidates (minus Λ.domains_touched) enter anchor selection alongside newly-surfaced domains; non-anchored remainder of the deduped seed → Λ.residual ∪ Λ.domains_touched — partition invariant preserved; Λ.B_seed := ∅, consumed once)
Phase 2 Qc    (constitution) → present (mandatory; per-cycle classification over BoundaryClassification + captured-kind label + essence-refinement preview (NOT the committed Δessence, which integrate produces at Phase 3 step 2) + cycle_n + current B_snapshot + current default_for_residual with count-distribution basis cite + cycle-1 certificate-fit basis + cycle-1 notice when Λ.B_prior non-empty (seed notice when kind-matched, advisory-only notice when kind-mismatched) + free-response termination affordance with implicit/explicit sub-signals)
Phase 3 parse  (sense)       → Internal analysis (conservative whole-utterance recognition with no Λ mutation: return typed_A? + TerminationIntent only when the reading accounts for all decision-relevant meaning in A; otherwise return no commitment and let Phase 2 re-present directly from A)
Phase 3 confirm_intent (constitution) → present (conditional: a parse leaving ≥2 J routing branches viable — present the candidate readings that parse actually left open (ImplicitTermination committing residual at default_at_surfacing | next continuing to the following cycle | ExplicitTermination proceeding to Phase 4), each with its differential future, and Stop; the user's confirmation or correction routes the loop at J — Rule 20)
Phase 3       (track)        → Internal state update (integrate(typed_A?, B, BoundaryEssence) → B', Δessence as the total current-cycle fold; a termination-only commitment returns B' = B, residualizes the anchor, and supplies the empty delta; crystallize applies to every delta with the empty delta as identity; ImplicitTermination executes the Phase 3 TERMINAL CARRIERS write; on loop continuation only — derive(EssenceTrend, history') → default' (kind-general, count-only); the B-snapshot refresh runs on EVERY fold, termination included, taking default' on continuation and the current default_for_residual on termination, so the completeness invariant leaves no gap for a terminal write to read)
Phase 4 Qf    (constitution) → present (residual bulk classification over FinalGateDisposition = {UserSupplies, AIAutonomous}, every kind; reached via ExplicitTermination or substrate exhaustion)
Phase 4       (track)        → Internal state update (bind the complete final_gate_answers map, then execute the Phase 4 TERMINAL CARRIERS write)
converge      (extension)    → TextPresent+Proceed (captured-kind + DeficitFitCertificate basis + per-cycle trace + residual disposition trace + BoundaryEssence artifact; proceed with defined boundary)
Seam transition to declared next protocol (extension) → TextPresent+Proceed (fires at deactivation/handoff: a user-declared chain naming the next protocol settles the next move — proceed directly to it, citing that settling source. This protocol declares no wired outbound continuation edge: a route claim fires when certificate.status = route, a pre-loop out-of-scope route-away that deactivates before any DefinedBoundary, not a post-convergence handoff, so the second trigger is vacuously absent. Every Constitution gate inside this protocol and inside the next protocol fires unchanged)

── MODE STATE ──
Λ = { phase: Phase, T: TaskScope,
      kind_route_map: Optional(KindRouteMap),          -- Phase 0b dispatch sync (every recognition seed + emergent path)
      captured_kind: Optional(Kind),                   -- the kind the dispatch settled on (recognize-seed | name-emergent | extend/replace-seed); set via the single_dominant_kind relay (extension, no turn yield) OR the mandatory Constitution gate
      kind_binding: Optional(KindBinding),             -- fields: label, positive_predicate, evidence, origin, atomicity
      certificate: Optional(DeficitFitCertificate),    -- fields: own_claim, route_claims[], claimed_by, evidence, status; fail-closed gate — status must = pass before value_space binds
      value_space: Optional(ValueSpace),               -- the uniform settlement disposition; frozen for the activation once certificate.status = pass (UserSupplies / AIPropose / AIAutonomous / Dismiss, same for every kind)
      B_prior: Optional(SeededPrior),                  -- hermeneutic seed detected at Phase 0 (a SeededPrior — prior BoundaryMap plus the kind it was produced over); the carried kind (B_prior.kind) is what Phase 0b step 4 tests to gate seeding to same-kind only (kind-mismatched prior map → advisory, not seeded)
      B_seed: Set(Domain),                             -- = Bᵢ, the Phase 0 domain-signal seed (the singleton d on zero-signal Reopen(d)); carried across the Phase 0 → 0b transition (both Stops sit between production and consumption); kept separate from the classified map B — B_seed is a Set(Domain), B a Map — and consumed at Phase 1 cycle-1 anchor selection as unclassified candidates; the non-anchored remainder residualizes per step 5 (→ Λ.residual ∪ Λ.domains_touched) and B_seed clears after cycle 1
      cycle_n: Nat,
      domains_touched: Set(Domain),                    -- accumulated across cycles (Phase 1 surfacing union)
      D_history: List<Sub-D>,                          -- per-cycle dimension projections
      essence_history: List<Δessence>,                 -- per-cycle delta accumulation
      boundary_essence: BoundaryEssence,               -- accumulated essence text
      essence_trend: EssenceTrend,                     -- ExtensionTrend | ConstitutionTrend | MixedTrend; updated each Phase 3, kind-general (count-only over the uniform disposition)
      default_for_residual: BoundaryClassification member,            -- provisional residual disposition surfaced each Phase 2 (a member of the uniform disposition); DefaultClassification re-derived from essence_trend each cycle, every kind
      context_resolved: Set(Domain),                   -- Phase 1 auto-resolved (Bᵣ-equivalent, per-cycle) ∪ B_prior-seeded domains (Phase 0b step 4 init; basis: "prior classification" — entries mutable across cycles, may be re-surfaced by Phase 1 if a stale-prior signal is detected)
      user_responded: Set(Domain),                     -- Phase 2 BoundaryClassification classification completed (the uniform 4-value disposition)
      final_gate_classified: Set(Domain),              -- Phase 4 bulk classification completed
      dismissed: Set(Domain),
      residual: Set(Domain),                           -- unclassified subset of domains_touched (implicit-delegation candidates; provisionally mapped to default_for_residual in boundary_map snapshot)
      boundary_map: BoundaryMap,                       -- always-complete after each Phase 3: classified entries ∪ (residual ↦ default_for_residual)
      final_gate_answers: Map(Domain, FinalGateAnswer),
      history: List<(Domain, BoundaryClassification)>,
      active: Bool, cause_tag: String }
-- Invariant: domains_touched = context_resolved ∪ user_responded ∪ final_gate_classified ∪ dismissed ∪ residual (pairwise disjoint)
--   Scope: holds at every cycle boundary — after each Phase 3 and at every Phase 1 entry. The one transient exception is the cycle's own anchor between Phase 1 step 6 (which commits it to domains_touched) and Phase 3 step 2 (which files it into a partition member): across the Phase 2 Stop the anchor is in domains_touched and in no member, by construction, since the member it belongs to is what Phase 2 is asking. Every path out of Phase 2 — typed answer or termination-only — reaches a step that files it.
-- Invariant: boundary_map = classified_entries(context_resolved ∪ user_responded ∪ dismissed ∪ final_gate_classified) ∪ (residual ↦ default_for_residual) — round-local completeness

── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). Dimension resolution emergent via session context.
Dispatch-first rationale: BoundaryMap is a multi-consumer router. The captured kind must settle BEFORE the per-cycle loop opens — hence bound carries the up-front Phase 0b sync rather than emerging the kind cycle-by-cycle: downstream consumers reading a stable kind cannot tolerate a kind that shifts mid-loop. The DeficitFitCertificate (checked against the own claim and the route claims inscribed in this SKILL.md) keeps a misfit kind from entering the shared map — a kind a local route claim holds is routed away (deactivate) instead of polluting the multi-consumer signal. What a pass certifies is LOCAL admissibility, bound's own gate governing bound's own activation, not the absence of a claim anywhere in the wider protocol set: where two protocols' scopes both reach a situation, each protocol's own gate governs.
Hermeneutic carry-over (kind-aware): an optional B_prior input (prior BoundaryMap detected in session context, together with the kind it was produced over) seeds the new invocation ONLY when its kind matches the captured kind (same-kind — same boundary question). Every kind shares the uniform disposition, so a mismatched prior's values are type-compatible; the guard is SEMANTIC: a kind-mismatched prior answers a DIFFERENT boundary question, so it is surfaced as advisory context, NOT seeded into boundary_map (seeding it would commit a wrong-question disposition into the multi-consumer signal). Seed entries are mutable in subsequent cycles and BoundaryEssence is re-crystallized from the current task scope. The seed enables a feedback loop where a downstream observation refines a prior BoundaryMap through re-invocation.
Round-local BoundaryMap composition: each Phase 2 cycle produces a complete BoundaryMap (classified entries ∪ residual ↦ default_for_residual). The complete snapshot is citable as scope text for a realization-layer turn-condition primitive — the AIAutonomous and AIPropose entries delineate an Extension-progression scope whose exhaustion is a natural completion condition orthogonal to the in-protocol satisfaction signal that emits DefinedBoundary.

Core Principle

Definition over Assumption: When a decision's boundary — who decides, which way it should go, how wide it reaches, or which category frames it — is unsettled, explicitly define it rather than assuming a default. Each decision point deserves its own boundary definition. The purpose of boundary probing is to produce a shared BoundaryMap — a Transactive Memory directory that makes explicit who knows what, how each boundary is settled, and where calibration is needed.

Stigmergy signal principle: BoundaryMap is a signal (TMS directory pointer), not a payload. It carries a settlement disposition per boundary — the signal exists in session context via Session Text Composition, and downstream behavior emerges from LLM reading the disposition in conversation context. The disposition records HOW each boundary value gets settled downstream (not who authored this /bound answer — Phase 2 is always user-classified), and its behavioral signal is the SAME for every boundary kind: User-supplies signals standard context collection (downstream gates present open questions); AI-proposes signals ENRICH-AND-PRESENT (expanded context collection with candidate generation); AI-autonomous signals RESOLVE-OR-PRESENT (expanded context collection with resolution attempt); Dismiss signals settle-by-default (proceed with the stated default — a committed disposition, not a skip). The BoundaryMap (paired with its captured kind, per the DefinedBoundary = { map, kind } contract) and BoundaryEssence are output as separate session text artifacts; no structured data channel is required. No explicit receiver implementation is needed in downstream protocol definitions — the session context is the environment, and behavioral adjustment is the emergent response.

Multi-consumer architectural independence: BoundaryMap is consumed by multiple downstream advisory consumers, each narrowing which moves are in-scope for its own operation. This shared consumption is why Horismos requires independent protocol status rather than absorption into any single consumer; the boundary is a multi-consumer signal, not a private operation of a specific downstream. Independent invocation preserves the symmetric advisory relationship across all its consumers.

Mode Activation

Activation

Two activation layers: Layer 1 (User-invocable) — /bound slash command or description-matching input, always available; Layer 2 (AI-guided) — boundary-undefined domains detected before execution via in-protocol heuristics; probing/detection is silent (Phase 0). The boundary kind is then dispatched up-front (Phase 0b) — relayed as Extension when one kind hypothesis dominates (entropy→0, the single-dominant-kind fast-path), otherwise settled via Cognitive Partnership Move (Constitution) — through a fail-closed deficit-fit certificate that runs on both branches; per-domain classification by the uniform settlement disposition requires user interaction (Phase 2) unless the domain is auto-resolved from substrate — a definitive boundary assignment found in Phase 1 records the classification and skips Phase 2 for that cycle.

Boundary undefined = the task scope contains decision domains whose boundary kind (direction/priority, scope, type/concept, ownership, or an emergent kind) is unsettled between user and AI. Ownership is one kind among the recognition seeds, not the whole space.

Gate predicate:

boundary_undefined(T) ≡ ∃ domain(d, T) : unsettled(d, kind) ∧ ¬trivially_defaultable(d)
  unsettled(d, kind) ≡ the domain's boundary value along SOME boundary kind — direction/priority,
                       scope, type/concept, ownership, or an emergent kind — is not yet fixed between
                       user and AI. ¬assigned(d, owner) is the ownership-kind instantiation of unsettled,
                       not the whole predicate: a domain whose ownership is clear but whose direction,
                       scope, or type is unsettled still satisfies the gate.

Priority

Supersedes: Direct execution patterns in loaded instructions (A decision's boundary must be settled before execution proceeds)

Retained: Safety boundaries, tool restrictions, user explicit instructions

Action: At Phase 0b, settle the boundary kind — relay the captured kind as Extension when single_dominant_kind holds (per TYPES and Rule 24), otherwise present the KindRouteMap gate via Cognitive Partnership Move (Constitution); the fail-closed deficit-fit certificate runs before value-space binding on either branch. At Phase 2, present highest-impact boundary-undefined domain for user classification by the uniform settlement disposition via Cognitive Partnership Move (Constitution).

• Horismos completes before execution proceeds
• Loaded instructions resume after all domains are bounded or dismissed

Trigger Signals

Heuristic signals for boundary-undefined domain detection (not hard gates): Multiple decision domains — task scope involves distinct areas without a settled boundary (ownership, direction/priority, scope, or type/concept); Delegation uncertainty — user expresses uncertainty about who decides ("should I decide this or you?"); Prior protocol reference — preceding protocol output references boundary-undefined domains; Stale BoundaryMap — prior invocation's BoundaryMap may not apply (task scope changed).

Skip: the boundary is fully specified (ownership, direction/priority, scope, type/concept) in current message or project rules; user explicitly requests proceeding without boundary settlement; same (domain, description) pair was dismissed in current session (session immunity); Phase 1 context collection resolves all identified domains; single-domain task with an obvious boundary (no ambiguity).

Mode Deactivation

Each terminal condition is typed in CONVERGENCE above. Graceful convergence — complete exactly one TERMINAL CARRIERS row: Phase 3 implicit termination, Phase 4 completion (entered by explicit termination or substrate exhaustion with residual remaining), or Phase 1 substrate exhaustion with no residual. BoundaryEssence is finalized at the current cycle in every graceful path. Route-away exit — Phase 0b certificate status = route: a local route claim holds the captured kind; emit that claim's routed_deficit (ContextInsufficient, GapUnnoticed, FrameworkAbsent, MappingUncertain, or DirectionUnrecognizable) together with its command hint (/inquire, /gap, /frame, /ground, /preview), no DefinedBoundary; the loop never opens.

Domain Identification

Domains are identified dynamically per task — taxonomy emerges from the task context. Each domain is characterized by name (the decision area where the boundary is unsettled along some kind — direction/priority, scope, type/concept, ownership, or emergent), description (what specifically requires boundary definition), and evidence (contextual evidence collected during Phase 1 that enriches classification quality).

Impact Ordering

Impact reflects how much defining this domain's boundary would narrow the remaining boundary-undefined space and affect downstream protocol operation: High (multiple downstream protocols depend on this boundary) → anchor first cycle; Medium (one downstream protocol affected or moderate scope impact) → anchor subsequent cycle; Low (localized scope, minimal downstream effect) → defer to final gate (Phase 4) bulk classification.

Impact is relational, not intrinsic: the same domain may be High in one task scope and Low in another, depending on what other domains exist and which protocols are expected to activate downstream. Per-cycle anchor selection (cycle 1 highest-impact; cycle k≥2 routed by the previous answer or free-response, with Impact re-applied within the routed frame) and the one-anchor-per-cycle cardinality with residual accumulation toward Phase 4 are specified in LOOP, Phase 1 steps 2 and 5 (detailed per-answer-type heuristics), and Rules 7-8.

Protocol

Phase 0: Boundary Existence Checkpoint (Silent)

Verify task scope contains boundary-undefined signal and optionally seed a prior BoundaryMap. This phase is silent — no user interaction and no user-visible output, except the conditional zero-signal confirmation gate (Rule 12) when no undefined boundary is detected. Any user-facing notice about the seed is deferred to Phase 2 cycle 1.

1. Probe task scope T for boundary-undefined signal: architecture choices, configuration preferences, quality standards, delegation scope, convention decisions, risk tolerance
2. Check boundary-kind signal: assess whether ANY boundary-kind signal is unsettled (unsettled(d, kind)) — direction/priority, scope, type/concept, ownership, or an emergent kind. Ownership is one kind among the seeds, not the whole check (existence check, not exhaustive enumeration — Phase 0 records the existence signal only; the full domain set is cycle-emergent via Phase 1 per-cycle re-scan, enabling user-judged termination at any cycle as the loop progresses)
3. Scan for B_prior seed (scoped detection, kind-aware): inspect current session context for a prior BoundaryMap emitted by an earlier /bound invocation in this same session. The detection target is structurally a Horismos DefinedBoundary artifact (BoundaryMap structure: object_ref(kind) → BoundaryClassification entries with cited basis — always domain → disposition) emitted at a previous /bound convergence — NOT a /recollect recall artifact and NOT a hypomnesis store (prior-session recall indices) entry. /recollect-recalled classifications stay in the "Cross-session enrichment" advisory channel; they do not populate Λ.B_prior. If a /bound emit is detected AND the current task scope is a refinement or feedback iteration of the prior scope, bind Λ.B_prior to that BoundaryMap together with the prior map's KIND (the boundary kind it was produced over); otherwise leave Λ.B_prior = ⊥.
4. If no boundary-undefined signal: present finding with reasoning for user confirmation before proceeding (Horismos not activated)
5. If boundary-undefined signal present: proceed to Phase 0b (KIND dispatch). Loop-state initialization (cycle_n, BoundaryEssence, essence_trend, default_for_residual, boundary_map, the B_prior partition seed) is deferred to Phase 0b step 4, after the kind is captured and the certificate passes — the value-space is the uniform disposition (kind-independent), captured here only so the certificate gate precedes binding.

Probe scope: Current task scope, conversation history, CLAUDE.md rules, project rule files, project conventions, prior /bound convergence emit in session text. Does NOT modify files or call external services.

Phase 0b: Kind Dispatch + Deficit-Fit Certificate (Constitution gate with single-dominant-kind relay + fail-closed certificate)

1. Dispatch the boundary kind (Constitution gate, with single-dominant-kind relay) — Surface one hypothesis for every recognition seed plus an emergent/naming free-response path (dispatch-first rationale: COMPOSITION; pipeline order: Rule 22). Each seed hypothesis carries a positive predicate, cited evidence, a differential future (what the loop classifies and how downstream consumers read it under this kind), and route-away conditions. The named kinds are priors (recognition seeds), NOT a closed coproduct (Rule 5: no fixed taxonomy) — the user may recognize a seed, name an emergent kind, or extend/replace a seed; seed inventory, salience ordering, and per-kind content glosses are typed in TYPES (Kind, typed_A). Before opening the gate, test this same complete carrier set — together with the live ground (T, context) — against single_dominant_kind (TYPES): when it holds, do NOT open the gate — present the captured kind + its basis as relay text and proceed without a turn yield (full relay contract: Rule 24). The basis is the dominating predicate and the foils' route-away when a seed dominates, and the user's own naming quoted verbatim when their wording already names one emergent kind unambiguously — gating there would ask them for a value they have already stated. When the test fails, default to the mandatory Constitution gate. Capture the user's response (gated branch) or the relayed dominating hypothesis (relay branch) as Λ.captured_kind.
2. Bind the kind — Λ.kind_binding = { label: captured_kind, positive_predicate, evidence, origin ∈ {seed, emergent}, atomicity }. If atomicity = non-atomic (the captured kind bundles two distinct boundary concerns), split or route before continuing — re-surface the KindRouteMap with the split hypotheses; bind a value-space only to an atomic kind.
3. Certify deficit fit (fail-closed) — Λ.certificate = certify(kind_binding, local_claims) where the local claims are bound's own claim and the route claims, both inscribed in this SKILL.md (TYPES: OwnClaim, RouteClaim); the certificate reads nothing outside this file. Fit the captured kind's positive predicate against every one of them and collect claimed_by, the set of claims the evidence supports: status = pass — claimed_by = {BoundaryUndefined}, the own claim holding alone, which means the predicate instantiates BoundaryUndefined AND the local value-space can carry it to DefinedBoundary → proceed to step 4; status = route — claimed_by = {d} for a single route claim's routed_deficit → emit d as the typed handoff and deactivate (the kind is out-of-scope for bound; route claims: missing pre-execution fact → ContextInsufficient (hint /inquire); an unnoticed decision gap rather than a boundary-kind settlement → GapUnnoticed (hint /gap); framework absent for the decision → FrameworkAbsent (hint /frame); cross-domain mapping uncertain → MappingUncertain (hint /ground); direction candidates' futures unrecognizable from description → DirectionUnrecognizable (hint /preview)); status = ambiguous — |claimed_by| ≠ 1, either because several claims hold or because none does on the evidence at hand → do NOT bind values; split, route, or ask one narrow disambiguation question, then re-certify (re-enter Phase 0b) — fail-closed: binding never proceeds under ambiguity. Which of those three resolves an ambiguous certificate is read at that turn from the session's own context and the user's wording; it is not fixed in advance here. What a pass certifies is local admissibility — bound's own gate over bound's own activation — not the absence of a claim anywhere in the wider protocol set.
4. Bind the uniform value-space + initialize loop state — ONLY after certificate.status = pass: bind Λ.value_space = BoundaryClassification = {UserSupplies, AIPropose, AIAutonomous, Dismiss} — the same settlement disposition for every kind (the captured kind set the content each option is about, not the coproduct); apply the option-set relay / dead-signal test and freeze the set for the activation. Then initialize loop state: cycle_n = 1, BoundaryEssence = "", Λ.default_for_residual = default_for(captured_kind) = AIAutonomous (Extension-default initial, every kind), Λ.essence_trend = MixedTrend (the per-cycle EssenceTrend → DefaultClassification derivation machinery of Phase 3 is kind-general — it reads disposition counts, never kind-specific content). Seed the prior BoundaryMap only when its kind matches the captured kind (same-kind — settled over the same boundary question): if Λ.B_prior ≠ ⊥ ∧ kind(Λ.B_prior) = captured_kind, set Λ.boundary_map = Λ.B_prior.map and initialize the partition: Λ.context_resolved = domain(Λ.B_prior.map), Λ.domains_touched = domain(Λ.B_prior.map) — seeded domains enter the context_resolved partition with basis "prior classification" so the MODE STATE partition invariant holds from Phase 0b onwards. If Λ.B_prior ≠ ⊥ ∧ kind(Λ.B_prior) ≠ captured_kind (kind-mismatched prior map), do NOT seed — the guard is semantic: the prior's dispositions are type-valid (same coproduct) but answer a different boundary question, so seeding them would commit a wrong-question disposition into the multi-consumer map; instead set Λ.boundary_map = ∅ and surface the prior map as advisory context at Phase 2 cycle 1 (a non-structural note that a prior boundary exists under a different kind), not as a structural seed. When no prior map is present (Λ.B_prior = ⊥), Λ.boundary_map = ∅. In every case Λ.B_seed = Bᵢ carries the Phase 0 domain-signal seed — the singleton d on zero-signal Reopen(d) — separately from the classified map (B_seed is never unioned into B, preserving the partition invariant); B_seed domains enter neither Λ.domains_touched nor a classified partition, so Phase 1 step 2 anchor selection can pick them. Proceed to Phase 1.

Phase 1: Per-Cycle Context Collection + Anchor Selection

Re-scan substrate for the current cycle and select one anchor domain (Sub-D[cycle_n]).

1. Per-cycle re-scan — Call artifact read/artifact search for boundary signals in CLAUDE.md, project rule files, project configuration. Skip domains already in Λ.domains_touched (single-source dedup — covers Λ.D_history ∪ Λ.context_resolved ∪ Λ.user_responded ∪ Λ.dismissed ∪ Λ.residual per the MODE STATE invariant). Stale-seed re-surface: when a re-scan signal contradicts an existing B_prior-seeded entry in Λ.context_resolved (e.g., the current substrate shows the seed's classification no longer fits — new convention, deleted file, shifted scope), remove that entry from Λ.context_resolved AND from Λ.domains_touched (the dedup source — otherwise steps 2/5 would mask the domain as already-touched and block re-processing) AND remove its stale classification from Λ.boundary_map (so the round-local boundary_map invariant holds — the re-surfaced domain is unclassified until re-anchored or re-accumulated, when it re-enters boundary_map with a fresh classification or the residual default) and append the domain to the newly-surfaced set so anchor selection (step 2) and non-anchored accumulation (step 5) can re-process it; it re-enters Λ.domains_touched when re-anchored (step 6) or accumulated into residual (step 5), so the partition invariant holds after the cycle; the seed's mutability provision applies.
2. Anchor selection — From newly-surfaced (not in Λ.domains_touched) domains:
   • Cycle 1: AI Impact ordering selects highest-impact domain as Sub-D[1] from cycle-1 candidates = this re-scan's newly-surfaced domains ∪ (Λ.B_seed \ Λ.domains_touched) (the unclassified Phase 0 domain-signal seed minus already-touched domains — a B_prior-seeded domain already in Λ.context_resolved re-enters only via step 1's stale-seed re-surface, preserving the pairwise-disjoint partition; incl. a zero-signal Reopen(d) domain, an anchor candidate even when the re-scan misses it again). When Λ.B_prior is non-empty AND kind-matched (B_prior.kind = captured_kind — only a kind-matched prior was seeded, so only it has entries that can be stale; a kind-mismatched advisory prior seeds nothing and does not steer anchor preference), Impact ordering may prefer domains where a prior classification appears stale relative to the current task scope (refinement target — stale seeds re-surfaced via step 1's re-surface mechanism are candidate anchors).
   • Cycle k≥2: previous cycle's classification typed_A[cycle_n-1] or free-response routes the substrate scan frame; the routed frame must narrow or refocus relative to the just-classified boundary's neighborhood (not duplicate the prior cycle's frame). Per-answer-type heuristics inform AI judgment but are not normative: Dismiss deprioritizes the topic cluster the dismissed domain belonged to; UserSupplies/AIPropose/AIAutonomous narrow toward adjacent unclassified domains in the same cluster. AI re-applies Impact ordering within the routed frame to select Sub-D[cycle_n].
3. Context enrichment — For the anchor domain, collect evidence (file/line citations, rule references, conflicting signals).
4. Auto-resolve check — If anchor domain has definitive boundary assignment found in substrate: set auto_resolved = true and append the anchor to Λ.context_resolved and Λ.boundary_map (with cited basis). This records ONLY the classification — steps 5–6 (non-anchored residual accumulation and the anchor Λ.D_history / Λ.domains_touched commit) still run this cycle; auto-resolve skips ONLY the Phase 2 user gate, not the per-cycle accumulation/commit. The exit signal (Phase 1 → Phase 3 vs Phase 1 → Phase 2) is emitted at step 7.
5. Non-anchored domain accumulation — Append every other surfaced-but-not-anchored domain to BOTH Λ.residual AND Λ.domains_touched (preserves dedup invariant). On cycle 1, also append non-anchored Λ.B_seed candidates (those not already in Λ.domains_touched — an already-touched seed domain re-enters only via step 1's stale-seed re-surface) to the same two sets, then clear Λ.B_seed := ∅ (consumed once). Residual domains receive provisional classification Λ.default_for_residual in the current boundary_map snapshot view; the provisional classification is committed if the user signals ImplicitTermination, or overwritten by FinalGateAnswer if Phase 4 is entered.
6. Anchor commit — Append Sub-D[cycle_n] to Λ.D_history and Λ.domains_touched.
7. Emit the cycle's anchor-exit signal: if auto_resolved, signal Phase 1 → Phase 3 (anchor classified from substrate — skip the Phase 2 user gate, carry the substrate-settled classification into Phase 3); else (anchor enriched, not auto-resolved), signal Phase 1 → Phase 2.
8. If no new domains surface this cycle (substrate exhausted): if Λ.residual ≠ ∅, signal Phase 1 → Phase 4 (substrate-exhaustion path to explicit bulk classify); if Λ.residual = ∅ (every surfaced domain already classified per-cycle), signal Phase 1 → converge directly — there is nothing for Phase 4 to classify, so emit DefinedBoundary without an empty final gate.

Scope restriction: Read-only investigation only. No file modifications.

Phase 2: Per-Cycle Classification + Essence Surfacing + B Snapshot (Constitution)

Present the cycle's anchor domain (Sub-D[cycle_n]), the accumulated essence (Λ.boundary_essence, of type BoundaryEssence — the crystallized whole, not a single cycle's Δessence), cycle counter, and the round-local complete BoundaryMap snapshot with current implicit-delegation default via Cognitive Partnership Move (Constitution).

Surfacing format — Materialize the applicable state conditions before presentation and replace every bracketed instruction with task-specific language. Show only the following everyday-language surface:

• Round: [current round number and a brief indication that the user may finish whenever the boundary summary is satisfactory]
• Earlier boundary work: [when applicable, either the earlier decisions carried into this round with their basis, or a note that the earlier work addressed a different boundary question and was not carried in]
• Carried from your earlier words: [when applicable, what the previous response added to the framing without settling the decision]
• Current decision area: [name and plain-language description]
• Evidence from the project: [each relevant observation with its source]
• Shared boundary so far: [the accumulated plain-language understanding, empty on the first round]
• How this choice would sharpen it: [the refinement this decision would contribute]
• Current boundary summary:
  • Decisions already settled: [each decision area and how it will be settled]
  • Decisions still open: [each remaining decision area and the currently proposed default]
• Current default for anything still open: [the default and why it follows]. On the first round, say there is no decision history yet and the initial fallback is to let AI decide within scope. On later rounds, cite only the counts of the choices made so far.

The numbered options below are type-preserving materializations, in order, of UserSupplies, AIPropose, AIAutonomous, and Dismiss. Parse the user's plain-language choice back into that coproduct, but present only this block:

How should this decision area's [plain-language boundary question] be settled?

Options:
1. **I'll supply it** — I already know [what I would provide] and will provide it.
2. **Draft options for me** — AI drafts [the relevant possibilities] and I choose or steer.
3. **Decide within this scope** — AI determines [the boundary value] within the stated limits.
4. **Use the stated default** — Continue with [the default shown above].

If the boundary summary above looks right, you can end this review now:
  • Accept it in your own words. Anything still open will use the default shown above.
    If you did not also choose one of the four options, the current decision area will use
    that default too. You may name a different default in the same response.
  • Ask to review the remaining decision areas together before finishing.

Phase 3: Per-Cycle Integration + Essence Crystallization + Default Derivation

Entered after conservative whole-utterance recognition finds a commitment in the Phase 2 response, or on an auto-resolved cycle with the substrate-derived classification. A response with no recognized commitment remains on the Phase 2 self-edge; it never enters the integration sequence. Step ordering matters: recognition and the current-cycle fold precede terminal routing, and default re-derivation runs only on continuation (commit invariant: Rule 19).

0. Snapshot the surfaced default (user-response cycles only — an auto-resolved cycle has no Phase 2 surfacing and produces no TerminationIntent, so default_at_surfacing is unused on that branch) — default_at_surfacing := Λ.default_for_residual (the value the just-completed Phase 2 displayed). This is the value any ImplicitTermination will commit. Re-derivation in step 5 (if reached) writes a NEW Λ.default_for_residual intended for the NEXT cycle's Phase 2, never for this round's commit.
1. Recognize the whole answer — Parse the typed classification, satisfaction intent, and optional default override only when that reading accounts for all decision-relevant meaning in the response. Satisfaction without a residual-review request is implicit termination; satisfaction with an alternative default carries that override; an explicit residual-review request is explicit termination. Material that reframes or undercuts an apparent commitment makes the recognition fail closed: return to Phase 2 with that material made visible from the response itself and leave the map unchanged. A response leaving ≥2 J routing branches viable — finishing now, continuing to the following cycle, or asking for the residual review — enters Rule 20's Constitution confirmation gate. On an auto-resolved cycle, use the substrate-derived classification and produce no termination intent.
2. Fold the recognized commitment into the cycle — integrate(typed_A?, B, BoundaryEssence) → (B', Δessence) is total over the two reachable commitment shapes. A typed classification updates the current anchor in Λ.boundary_map, appends its history entry, and files the anchor in the matching classified partition (an auto-resolved anchor is already in Λ.context_resolved). A termination-only commitment makes no classification: it files the anchor in Λ.residual, returns B' = B, and returns the empty Δessence. Thus B', the partition membership, and the trace delta are bound before any terminal route; neither Λ.default_for_residual nor Λ.essence_trend changes here. The classified dispositions retain the downstream signals defined in Core Principle.
3. Crystallize Δessence — crystallize(Δessence, BoundaryEssence) → BoundaryEssence'; append the delta to Λ.essence_history. The empty delta is the identity, so this operation is total and the convergence trace has one delta for every anchored cycle.
4. Refresh the boundary_map snapshot — BEFORE any route, on every fold including a terminating one — Λ.boundary_map = classified_entries ∪ (Λ.residual ↦ Λ.default_for_residual), using the CURRENT Λ.default_for_residual (the value Phase 2 surfaced as default_at_surfacing). This gives an anchor just filed in Λ.residual at step 2 its provisional entry, so the map every terminal write reads is complete for that anchor too. Placing it after the route would hold the round-local completeness invariant only on the continuing path, and the Phase 4 bulk_classify overwrite would find no entry to overwrite for a just-residualized anchor.
5. Route before re-derivation — Apply J from LOOP. Implicit termination completes the matching TERMINAL CARRIERS row; explicit termination enters Phase 4; only next proceeds to steps 6–8.
6. Derive next-cycle EssenceTrend (kind-general — runs for every captured kind): count-based ONLY — no textual-lean interpretation; analyze Λ.history count distribution across classified dispositions and update Λ.essence_trend: count(AIPropose ∪ AIAutonomous) strictly dominant → ExtensionTrend; count(UserSupplies) strictly dominant → ConstitutionTrend; no strict dominance OR cycle_n < 2 (explicit single-cycle initialization rule — see Rule 21) → MixedTrend.
7. Derive next-cycle DefaultClassification (kind-general) — Λ.default_for_residual ← DefaultClassification(Λ.essence_trend): ExtensionTrend → AIAutonomous; ConstitutionTrend → UserSupplies; MixedTrend → AIAutonomous (Extension-default fallback). This new Λ.default_for_residual is the value the NEXT cycle's Phase 2 will surface, NOT the value that just-committed any termination (which used default_at_surfacing).
8. Re-snapshot for the cycle about to open — Λ.boundary_map = classified_entries ∪ (Λ.residual ↦ Λ.default_for_residual) with the value step 7 just derived, superseding step 4's snapshot on the continuing path only. cycle_n += 1, return to Phase 1. (The current cycle's (domain, typed_A) was already appended to Λ.history in step 2.)

Phase 4 (Optional Path): Final Gate — Residual Bulk Classification (Constitution)

Present accumulated residual domains for bulk classification via Cognitive Partnership Move (Constitution). Phase 4 is reached via Phase 3 ExplicitTermination (user opts into explicit residual classification rather than implicit-delegation) or Phase 1 substrate exhaustion with residual remaining; ImplicitTermination bypasses Phase 4 entirely (residual committed with default_for_residual directly from Phase 3).

Surfacing format — present as text output:

• BoundaryEssence (final synthesis): [accumulated crystallized form of the responsibility boundary space — presented BEFORE residual classification so the user judges bulk disposition with full essence context]
• Per-cycle classified entries (already in BoundaryMap): [Domain → disposition per cycle]
• Residual domains (Λ.residual): [list of all surfaced-but-unclassified domains — every accumulated residual domain listed by name]

The two numbered phrases below are type-preserving materializations, in order, of UserSupplies and AIAutonomous. Parse the choice back into that subset, but present only this block:

How should the remaining domains be settled in bulk?

Options:
1. **I'll keep these decisions** — I will settle each remaining area when it becomes relevant.
2. **Decide within this scope** — AI settles each remaining area within the stated limits.

Granularity option: User may free-response per-domain mixed disposition. Free response is parsed as a Map(Domain, FinalGateAnswer); the uniform option (1 or 2) applies as default when free response is absent.

Mixed-disposition parsing — error handling: Unknown-domain reference — if the user names a domain absent from Λ.residual (typo or hallucinated reference), AI surfaces the discrepancy, re-presents the residual list, and re-prompts; Ambiguous disposition — if a domain's disposition is ambiguous or unparseable, AI re-prompts with the ambiguous portion isolated and the FinalGateAnswer coproduct re-presented; Partial coverage — domains in Λ.residual not addressed in the mixed-disposition free response default to whichever uniform option (1 or 2) the user selected, OR — if no uniform option was selected — AI re-prompts for the unaddressed remainder; Disposition conflict — if a domain receives multiple conflicting dispositions in the same response, AI re-prompts with the conflicting portion isolated.

After the Phase 4 response, execute the Phase 4 row in TERMINAL CARRIERS, append the final-gate trace to history, output DefinedBoundary and BoundaryEssence as session text artifacts, and trigger the converge extension transition.

Intensity

Light (1-2 cycles, narrow task scope, residual minimal): brief per-cycle anchor + Δessence + B_snapshot; typical termination via ImplicitTermination. Medium (3-5 cycles, multi-domain task scope): structured per-cycle surfacing + accumulated essence + B_snapshot with default visibility; ImplicitTermination or Phase 4 per user judgment. Heavy (6+ cycles, broad task scope, rich essence trajectory): detailed evidence + per-cycle Δessence + B_snapshot; ExplicitTermination → Phase 4 with mixed-disposition residual common.

UX Safeguards

The runtime safeguards are compiled into the Rules and the phase walkthrough rather than restated as a separate table: activation specificity — the gate predicate prevents false activation on clear tasks, and activation no longer requires ownership specifically to be unclear (Mode Activation gate predicate, Skip list); up-front kind dispatch, the single-dominant-kind relay — which prevents over-gating when the framing already settles the kind — and the fail-closed deficit-fit certificate (Rules 22, 24); the uniform settlement disposition with kind-general EssenceTrend / default machinery (Rules 19, 21, 22); per-cycle mechanics — re-scan with dedup, one anchor per cycle (preventing per-cycle classification overload), impact ordering, auto-resolve preference minimizing user interaction (Rules 3, 6, 7, 8); surfacing visibility — cycle counter, essence, complete snapshot, default with derivation cite, residual list, seed/advisory notice — carried inline in the Phase 2 surfacing format; termination affordances, default-override reachability without expanding the typed option set, and ambiguity confirmation (Rules 14, 19, 20); hermeneutic seed lifecycle with stale-seed re-surface (Rule 9, Phase 1 step 1); session immunity respecting the user's dismissal (Skip list); the BoundaryEssence artifact — periagoge contribution preserved as inspectable trace (Rule 11).

Rules

1. AI-guided, user-classified: AI detects boundary-undefined signal and surfaces per-cycle anchors; classification requires user choice via Cognitive Partnership Move (Constitution) at Phase 2 (per-cycle over BoundaryClassification — the uniform 4-value disposition) and at Phase 4 if entered (final gate over FinalGateDisposition — the uniform 2-value subset) — unless Phase 1 finds a definitive substrate assignment for the cycle's domain and takes the typed auto-resolved branch (Phase 1 → Phase 3, skipping Phase 2 for that cycle; the substrate-settled classification carries into Phase 3 with no user A). AI detection is implicitly confirmed when the user engages with classification.
2. Recognition over Recall: Present structured options with differential futures via Cognitive Partnership Move (Constitution); Constitution interactions yield turn for response. Phase 2 binds typed_A ∈ BoundaryClassification — the classification recognized within the open response A, which may instead carry only a termination signal, or no commitment yet (then the gate re-presents informed by what it did carry, per TYPES A) plus the complete BoundaryMap snapshot with provisional default_for_residual visible (Rule 19); Phase 4 binds to FinalGateAnswer = FinalGateDisposition (per TYPES).
3. Per-cycle context collection: Each cycle's Phase 1 re-scans substrate (CLAUDE.md, project rule files, project configuration). (Detailed step procedure in Phase 1 prose.)
4. Definition over Assumption: When a decision's boundary (its ownership, direction/priority, scope, or type/concept) is unsettled, define explicitly rather than assume — silence is worse than a dismissed classification.
5. No fixed taxonomy: Domains emerge dynamically from each task probe; the Domain = { name, description, evidence } type carries no category constructor — taxonomy emerges from the task context. This extends to the boundary kind: the Phase 0b seeds (direction/priority, scope, type/concept, ownership) are recognition PRIORS, NOT a closed coproduct — the user may name an emergent kind or extend/replace a seed via the KindRouteMap's naming path. Kind carries no category constructor either.
6. Context resolution preferred: Auto-resolve from existing config, rules, and conventions where possible within the cycle's anchor. Minimize user interaction to what truly requires human judgment.
7. One anchor per cycle: Each Phase 2 cycle presents one anchor domain (Sub-D[cycle_n]); the PHASE TRANSITIONS edge Phase 1 → Phase 2: Sub-D[cycle_n] non-empty ∧ ¬auto_resolved binds the per-cycle cardinality. Surfaced-but-not-anchored domains accumulate into Λ.residual and are provisionally mapped to Λ.default_for_residual in the round-local snapshot; so does the current anchor when a Phase 2 response carries a TerminationIntent with no typed selection (Phase 3 step 2 appends it to Λ.residual rather than classifying it). Final disposition is committed by ImplicitTermination (default fill) or by Phase 4 explicit bulk classification.
8. Impact ordering: Per-cycle anchor selected by Impact — highest-impact at cycle 1; previous answer or free-response routes the substrate scan frame at cycle k≥2, with Impact re-applied within the routed frame. Impact is relational to downstream protocol dependencies. (Detailed per-answer-type heuristics in Phase 1 prose.)
9. Per-decision boundary with hermeneutic carry-over (kind-aware seed): Each invocation produces a fresh BoundaryEssence for the current task scope. A prior BoundaryMap detected in current session context as a Horismos DefinedBoundary emit (NOT a /recollect recall artifact, NOT a hypomnesis store entry) is DETECTED at Phase 0 step 3 together with the kind it was produced over (binds Λ.B_prior and its kind only — Phase 0 does not seed boundary_map, which does not exist until loop-state init). The seed into the starting boundary_map AND the partition init into Λ.context_resolved ∩ Λ.domains_touched both occur at Phase 0b step 4, after the kind is captured and the certificate passes, and only when the prior map's kind matches the captured kind (kind(Λ.B_prior) = captured_kind — same-kind, i.e. settled over the same boundary question). A kind-mismatched prior map (kind(Λ.B_prior) ≠ captured_kind) is therefore NOT seeded — seeding it would commit a wrong-question disposition into the multi-consumer BoundaryMap; it is surfaced as advisory context at Phase 2 cycle 1 instead of a structural seed, and boundary_map starts empty. The MODE STATE partition invariant therefore holds from Phase 0b onward, not from Phase 0. Seeded entries remain mutable across cycles; Phase 1's stale-seed re-surface mechanism (Phase 1 step 1) re-classifies entries whose prior fit no longer holds. Cross-session recall (hypomnesis or /recollect) remains advisory heuristic input on candidate classifications only and does not seed B_prior.
10. Round composition: Compose each round so the reader can act on it without reassembling it — everyday language rather than this file's formal vocabulary, the judgment set beside the evidence it rests on together with the differential implication that matters for the next move, and analytical context laid out before a gate rather than inside it. Read references/round-composition.md before composing when a term's rendering has to hold across the session or wording has to be carried through unchanged, when some of what is in view belongs to a later round or a trace rather than this one, or when this protocol's own phases bear on where a sentence sits relative to a gate.
11. Convergence evidence: At convergence (Phase 3 ImplicitTermination ∨ Phase 4 completed ∨ substrate-exhaustion empty-residual), present per-cycle trace (for each anchored cycle k — k ranges over Λ.D_history, the cycles that produced a Sub-D; a substrate-exhaustion terminal scan contributes no entry: (Sub-D[k], Δessence[k], disposition[k]); disposition[k] ∈ BoundaryClassification is read from the finalized Λ.boundary_map entry for Sub-D[k].domain — the trace evidences the emitted map, so each cycle's disposition is the map's own value for that domain and cannot contradict it, whichever terminal path assigned that value (a per-cycle classification, the ImplicitTermination default fill, or a Phase 4 FinalGateAnswer). The rule never re-declares which value a given terminal path assigns; a new or changed terminal path therefore needs no edit here. Δessence[k] is the delta integrate produced for cycle k, or the empty delta when the cycle produced no classification (nothing refined the essence), so the trace tuple is total for every anchored cycle) plus residual disposition trace — ImplicitTermination: (∀ d ∈ residual, excluding domains already reported as anchored cycles: (d, default_at_surfacing_or_override) — basis follows which value committed: the EssenceTrend / count-distribution derivation when the surfaced default committed (kind-general), the user's stated override when one did); Phase 4 completion: (∀ non-anchored d ∈ final_gate_classified: (d, FinalGateAnswer(d))) — quantified over the partition bulk_classify moved them INTO, not over Λ.residual, which bulk_classify empties before convergence; seeded-and-unchanged: (∀ non-anchored d ∈ Λ.context_resolved: (d, disposition(d)) — cites the substrate assignment or prior-classification seed basis); substrate-exhaustion empty-residual: residual = ∅, no residual disposition. Cover: these parts together range over the domains of the EMITTED map, each reported exactly once. "Non-anchored d" means d ∉ { s.domain | s ∈ Λ.D_history }, compared on domain identity — Λ.D_history holds Sub-D projections while the partition sets hold Domains, so a raw cross-type membership test would fail to exclude an auto-resolved anchor. Anchored membership takes precedence over every other, so a domain anchored in some cycle is reported once as a per-cycle entry even when it also sits in Λ.context_resolved, Λ.residual, or Λ.final_gate_classified. BoundaryEssence as separate session text artifact. Convergence is demonstrated, not asserted.
12. Zero-signal surfacing: If Phase 0 probe detects no boundary-undefined signal, present this finding with reasoning for user confirmation.
13. Option-set relay test (Extension classification): If AI analysis converges to a single dominant option (option-level entropy→0 — Extension mode of the Cognitive Partnership Move), present the finding directly. Each Constitution option must be genuinely viable under different user value weightings. Options sharing a downstream trajectory collapse to one; options lacking an on-axis trajectory surface as free-response pathways rather than peer options.
14. Gate integrity (Safeguard tier): The defined option sets (per-cycle typed_A ∈ BoundaryClassification — the uniform 4-value disposition; Phase 4 FinalGateAnswer = FinalGateDisposition — the uniform 2-value subset) are presented intact — injection, deletion, and substitution each violate this invariant. Type-preserving materialization (specializing a generic option while preserving the TYPES coproduct) is distinct from mutation. Horismos-specific: the free-response termination affordance and its bifurcation into ImplicitTermination / ExplicitTermination sub-signals is positioned in Phase 2 surfacing prose (natural-language satisfaction signal guidance), not in the typed coproduct; Phase 3 parses termination_intent from free response and routes to either converge (Implicit) or Phase 4 (Explicit) — the affordance lives in prose rather than in the typed coproduct, so option-set integrity is preserved. Default override is free-response parsing into ImplicitTermination(default_override), not an option-set extension. Ambiguous parses (a response leaving ≥2 of J's routing branches viable) trigger a one-turn Constitution confirmation gate before J is evaluated — see Rule 20; the gate presents as text every candidate reading the response actually supports, each with its differential future, and awaits the user's answer, but does NOT extend BoundaryClassification — it resolves a free-response routing signal outside the typed coproduct, whose confirmed value is a TerminationIntent member on the terminating branches and the next branch that is the absence of one otherwise, so option-set integrity is preserved.
15. Final gate residual disposition — lazy-binding semantic: Phase 4 binds FinalGateAnswer = FinalGateDisposition = {UserSupplies, AIAutonomous} ⊆ BoundaryClassification (the uniform residual-disposition subset, same for every kind). The FinalGateAnswer coproduct contains no routing constructor — BoundaryMap entries carry only the typed disposition, and value provision or protocol invocation decisions occur when the user activates downstream protocols. UserSupplies(domain) records the disposition with the residual domain as the boundary (lazy-binding — user retains settlement authority, downstream gates present open questions at activation, and the user judges which protocol applies). User settlement authority is preserved at the residual disposition for every kind.
16. Default visibility — informed Constitution: The default_for_residual (a member of BoundaryClassification) and its derivation are surfaced at every Phase 2 round before the gate. The derivation basis is kind-general: the count-distribution / EssenceTrend basis at cycle k ≥ 2 and the explicit "MixedTrend (cycle 1 initialization)" cite at cycle 1 (count-only over the dispositions classified so far, identical for every kind). ImplicitTermination is only legitimate Constitution when the user has recognized the default they are committing to. Silent default = uninformed delegation — AI exercises the residual disposition without the user recognizing what they are committing to, which collapses the Detection-with-Authority separation that distinguishes AI surfacing from user judgment. The commit invariant: ImplicitTermination commits with default_at_surfacing (the value visible in the just-completed Phase 2), NEVER a Phase-3-re-derived value — Phase 3 re-derivation produces the NEXT cycle's default only. Override paths must be reachable in the same prose, parsed as ImplicitTermination(default_override : BoundaryClassification).
17. Ambiguity-confirmation gate (Constitution): When Phase 3 step 1 parses a free response that leaves ≥2 of J's routing branches viable — ImplicitTermination committing the residual to the surfaced default, next continuing to the following cycle, or ExplicitTermination handing the residual to Phase 4 — for example "looks good but can we check the rest?" — those readings commit to materially different downstream trajectories, so this is a Constitution interaction: it yields a turn and the user's answer constitutes which reading routes the loop. DO NOT silently route: present the contrast in everyday language and Stop, awaiting confirmation or correction. The question is built from THIS parse's candidate readings (Phase 3 confirm_intent, TOOL GROUNDING). For every reading the response actually leaves open, name its downstream future: ImplicitTermination names what finishing now would commit and cites the default Phase 2 actually surfaced (Rule 19); next names the return to the per-cycle scan with the remaining areas still open; ExplicitTermination names the handoff of the whole residual to the final gate. A reading the parse does not carry is not presented, so the user recognizes the futures this response left open rather than the general shape of the contrast. The user's confirmation or correction routes the loop. Does NOT apply when the parse is unambiguous.
18. Single-cycle MixedTrend (explicit design choice — kind-general): This derivation applies for every captured kind — the EssenceTrend → DefaultClassification machinery is kind-general, and AIAutonomous is always a member of BoundaryClassification (the uniform disposition). When cycle_n < 2, EssenceTrend is forced to MixedTrend and default_for_residual resolves to AIAutonomous (Extension-default fallback) regardless of any single prior answer — a single classification is insufficient to commit a count-dominance trend. Consequence: single-cycle ImplicitTermination always commits residual to AIAutonomous unless the user supplies a default_override.
19. Kind dispatch with fail-closed deficit-fit certificate (Phase 0b): Before the per-cycle loop opens, the boundary kind is dispatched through the shared meta-backbone pipeline — KindBinding → fail-closed DeficitFitCertificate → uniform settlement disposition, in that strict order. (a) Dispatch-first because BoundaryMap is a multi-consumer router: the kind must settle before any downstream consumer reads it, so bound presents an up-front KindRouteMap rather than emerging the kind cycle-by-cycle. The up-front dispatch is gated when ≥2 kind hypotheses stay viable and relayed (Extension, no turn yield) when one kind dominates (entropy→0) — see Rule 24; either way the kind settles before the loop opens. (c) Fail-closed certificate: certificate.status = pass strictly precedes value-space binding; status = route deactivates, emitting the matched route claim's routed_deficit (ContextInsufficient, GapUnnoticed, FrameworkAbsent, MappingUncertain, DirectionUnrecognizable — command hints /inquire, /gap, /frame, /ground, /preview); status = ambiguous or atomicity = non-atomic re-syncs Phase 0b (split / route / one-turn narrow disambiguation) before binding — binding never proceeds under ambiguity. The certificate is generated by fitting the captured kind's positive predicate against the own claim and the route claims inscribed in THIS SKILL.md, and reads nothing outside this file; claimed_by is a Set, so "no claim holds" is a value rather than a hole, and it lands in ambiguous alongside the several-claims case under |claimed_by| ≠ 1. A pass certifies local admissibility — bound's own gate over bound's own activation — not the absence of a claim anywhere in the wider protocol set. (d) Uniform value-space, kind sets content: the BoundaryMap value type, the per-cycle classification typed_A (parsed from the response A), the residual disposition, and the initial default default_for(kind) all range over BoundaryClassification = {UserSupplies, AIPropose, AIAutonomous, Dismiss} — the same coproduct for every kind, generated only after the certificate passes (the captured kind is the DOMAIN of bind_value_space, selecting each option's content, but the codomain is constant). The ownership kind is the degenerate case where the boundary value being settled IS the disposition (who decides); for every other kind the disposition says HOW the boundary value gets settled while the kind says WHAT it is about. (e) Backbone discipline: the schema is ONE canonical definition shared across protocols; bound instantiates only object_ref(kind), local_value_space, the label field's type (Kind), the own claim, and the local route claims — same field names, same fail-closed statuses, same certificate-before-binding order.
20. Formal blocks are runtime-normative: This protocol's formal blocks — those defined in its Definition code block above — are LLM-facing and constitutive of protocol identity: they type the prose and carry the operational contract executed at runtime. A reduced or single-shot realization carries every one of them through as runtime contract, since each block is the type that constitutes the protocol — preserving the blocks keeps the protocol intact. How its symbols render to the user is a separate emit-layer concern (see Round composition).
21. Single-dominant-kind relay (Phase 0b Extension fast-path): The Phase 0b kind dispatch is NOT unconditionally gated. Apply the option-set relay test (Rule 13) to the KindRouteMap hypotheses, which carry one hypothesis for every recognition seed. Relay when the live ground — (T, context), the user's own wording and the accumulated context — determines exactly one kind, by either route. Seed route: exactly one hypothesis' positive predicate is unambiguously satisfied, every other hypothesis' route_away_if holds, and the live ground indicates no emergent capture. Emergent route: the user's own wording already names exactly one emergent kind unambiguously — that naming IS the capture, so opening the gate would ask them to state what they have stated. The seed conjuncts read the KindRouteMap they receive; the emergent conjunct does NOT, because it turns on what the framing denotes, and the seed summary cannot stand in where an unresolved denotation is what the branch rests on — resolve it against the live ground or do not resolve it. Present the captured kind + its basis as relay text and proceed, recording Λ.captured_kind without a turn yield (sync_kind_route_relay, Extension); the basis quotes the user's own wording rather than paraphrasing it, verbatim on the emergent route where that wording is itself the capture. The mandatory Constitution gate (sync_kind_route, Rule 22) fires whenever the test fails — ≥2 hypotheses stay viable, a foil is undecidable, an emergent gesture resolves to no single naming, or the live ground leaves the emergent question undetermined — which is the default when in doubt: the kind seeds a frozen multi-consumer signal, so the relay is the NARROW exception. The fail-closed DeficitFitCertificate still applies on the relay branch: a relay-captured kind flows through the same bind_kind → certify → bind_value_space pipeline, and a status = route certificate routes away/deactivates and a status = ambiguous certificate re-syncs the full Constitution gate (Rule 22c) — the relay collapses only the kind-capture turn yield, never the deficit-fit gate. The relay does NOT open an in-loop kind-redirect: the captured kind is committed for the activation. The certificate guards deficit-fit, not which bound-kind is correct — among the seeds or on the emergent route; kind correctness on the relay branch is carried by single_dominant_kind. A rare mis-relay is corrected by re-invoking /bound, preserving the frozen multi-consumer kind invariant rather than mutating a kind mid-activation.
22. Seam relay on declared continuation: when a user-declared chain names the next protocol, the between-protocol seam after this protocol's convergence (DefinedBoundary) is relay (Extension) — proceed directly, citing the settling source (the chain declaration). This protocol declares no wired outbound continuation edge — a route claim fires at certificate.status = route, a pre-loop out-of-scope route-away that deactivates before any DefinedBoundary, not a post-convergence handoff — so the second trigger is vacuously absent. This governs only the seam BETWEEN protocols; every Constitution gate inside this protocol and the next fires unchanged.
23. Form feedback: Silence about form is not evidence about form. Too dense fails quietly — the reader skims, answers past it, stops — while too plain fails out loud, so the complaints that arrive come from one side only. Density therefore does not carry over from the previous round: each round takes it from what this request asked for, while a statement about form does carry over until it is countermanded. Read an instruction about form for the parts of a round it reaches, not for what kind of reaction it is — a complaint, a request, a symptom report and a bare preference are one input here, and sorting them by kind yields nothing the reach reading does not already give while costing a clause per kind. Change the form rather than asking which form they want; naming one is the recall this discipline exists to remove. What such an instruction reaches is whatever the active protocol leaves open in how a round is composed — its density, its ordering, its length. What it does not reach is whatever is already fixed for this round elsewhere: content the protocol requires, wording carried verbatim, an order it presents in, a cadence it caps, a turn boundary it sets. Those stay in place, and the layer that fixed them is what states why. Say in one line what changed; where the instruction overlapped something that stays, say in one line that it stays and why — that second line is owed by the overlap, not by how the instruction was worded.

Cross-session enrichment: Prior session indices from the hypomnesis store, when present, may seed Phase 1 calibration proposals; the constitutive judgment remains with the user.