bound

What this skill does

# 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 boundary ownership per decision, where AI probes for boundary-undefined domains, collects contextual evidence to enrich classification quality, and presents each domain for user classification into a BoundaryMap consumed by all downstream protocols.

```
── FLOW ──
Horismos(T, B_prior?) → Probe(T) → Bᵢ? →
  |Bᵢ| = 0: skip → deactivate
  |Bᵢ| > 0: cycle_n=1, BoundaryEssence="", B = seed(B_prior) ∪ ∅, EssenceTrend=MixedTrend, default=AIAutonomous (Extension-default initial), loop:
    Phase 1 Ctx(T, cycle_n) [per-cycle re-scan] → (Sub-D[cycle_n], auto_resolved?) →
      auto_resolved: → Phase 3 (skip Phase 2 for this cycle)
      else:          → Phase 2
    Phase 2 Qc(Sub-D[cycle_n], BoundaryEssence, cycle_n, B_snapshot, default) → Stop → A
    Phase 3 parse(A) → (typed_A, termination?, override?) →
      integrate(typed_A, B, BoundaryEssence) → (B', BoundaryEssence')                              -- classified-portion update only
      ImplicitTermination: → finalize(B', residual, default_or_override) → DefinedBoundary → converge
                            -- "default" is Λ.default_for_residual at entry to Phase 3 (the value Phase 2 surfaced); NOT re-derived
      ExplicitTermination: → Phase 4
      Esc:                 → ungraceful deactivate (residual untreated, BoundaryEssence finalized at current cycle_n)
      else:                → derive(EssenceTrend, history') → default' (for NEXT cycle) → refresh B'-snapshot → cycle_n += 1, loop
  Phase 4 (optional path) Qf(residual, {UserSupplies, AIAutonomous}) → Stop → bulk_classify → DefinedBoundary
                       Esc → ungraceful deactivate

── MORPHISM ──
TaskScope, B_prior?
  → probe(task, context)                                           -- detect boundary-undefined domains
  → seed(B_prior, B)                                               -- hermeneutic carry-over: optional prior BoundaryMap as starting B; seeded domains enter `context_resolved` partition with "prior classification" basis (entries mutable in subsequent cycles)
  → enrich(domains, codebase, cycle_n)                             -- per-cycle context collection (re-scan)
  → classify(domain, as_inquiry)                                   -- per-cycle domain classification (4-value preserved)
  → integrate(typed_A, B, BoundaryEssence) → (B', BoundaryEssence')-- classified-portion update for current anchor; does NOT update default_for_residual
  → crystallize(Δessence, BoundaryEssence) → BoundaryEssence'      -- per-cycle essence delta integration (crystallized form of the responsibility boundary space)
  → derive(EssenceTrend, history') → default'                      -- count-based EssenceTrend → DefaultClassification for NEXT cycle's residual (only runs on loop continuation)
  → snapshot(B', residual, default') → B_complete'                 -- round-local complete BoundaryMap view for next cycle's Phase 2: classified entries ∪ (residual ↦ default')
  → finalize(B', residual, default_at_surfacing | override | FinalGateAnswer)
                                                                   -- ImplicitTermination: residual ↦ (default_at_surfacing | override); Phase 4: residual ↦ FinalGateAnswer
                                                                   -- "default_at_surfacing" = Λ.default_for_residual visible in just-completed Phase 2 (NOT re-derived)
  → DefinedBoundary
requires: boundary_undefined(T)            -- runtime checkpoint (Phase 0)
deficit:  BoundaryUndefined                -- activation precondition (Layer 1/2)
preserves: task_identity(T)                -- task scope invariant; BoundaryMap and BoundaryEssence mutated; B_prior seed entries are mutable across cycles
invariant: Definition over Assumption

── TYPES ──
T              = TaskScope (task/project requiring boundary definition)
B_prior        = Optional(BoundaryMap)                        -- optional invocation seed for hermeneutic carry-over (prior BoundaryMap detected in session context); seed entries are mutable across cycles
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)
cycle_n        = Nat                                          -- current cycle counter (visible at Phase 2)
                                                              -- bound index `k ∈ [1, cycle_n]` ranges over cycle history in convergence trace
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 at Phase 3 integration
BoundaryEssence = String                                      -- accumulated boundary essence (crystallized form of the responsibility boundary space); initialized "" at Phase 0; updated as BoundaryEssence' = BoundaryEssence ⊕ Δessence at Phase 3
EssenceTrend   ∈ {ExtensionTrend, ConstitutionTrend, MixedTrend}
                                                              -- derived from count distribution of classified entries across Λ.history (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)
DefaultClassification : EssenceTrend → {AIAutonomous, UserSupplies} ⊆ BoundaryClassification
                                                              -- codomain restricted to the 2-value reachable subset (AIPropose and Dismissed are unreachable from this function)
                                                              -- ExtensionTrend → AIAutonomous; ConstitutionTrend → UserSupplies; MixedTrend → AIAutonomous (Extension-default fallback)
Qc             = Per-cycle boundary classification interaction [Tool: Constitution interaction]
A              = User answer ∈ {UserSupplies(scope), AIPropose(scope), AIAutonomous(scope), Dismiss}
                 -- 4-value coproduct (per-cycle Phase 2 answer; presented intact per gate integrity invariant)
                 -- termination_intent surfaces via free-response affordance, NOT as 5th option
TerminationIntent = parsed natural-language signal of user satisfaction
                  ∈ {ImplicitTermination(default_override?), ExplicitTermination}
                                                              -- ImplicitTermination: commit current B_snapshot — 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 — emit DefinedBoundary directly
                                                              -- ExplicitTermination: enter Phase 4 for bulk residual classification