sublate

What this skill does

# Elenchus Protocol

Vet working context by dialectical antithesis before action through structured per-source disposition judgment, resolving suspect context into vetted context. Type: `(ContextSuspect, User, VET, WorkingContext) → VettedContext`.

## Definition

**Elenchus** (ἔλεγχος): A dialogical act of cross-examination — from the Socratic refutation tradition meaning "testing by argument" — resolving suspect working context into vetted context through provenance challenge, counterfactual gap forecasting, cross-source consistency check, and inference-fallacy archetype scan before pre-execution sync. The protocol's lexical verb is `/sublate`. Each suspect source undergoes the motion of stating its current claim, surfacing what would shake it, and then deciding how to handle the source in light of that challenge (the Hegelian *Aufhebung* — preserve + negate + lift up — supplies the source vocabulary).

```
── FLOW ──
W → identify(W) → S_high → tag(provenance, freshness, leverage) → S' → posit(antithesis) → A[] →
  Q(per-source disposition slots) → J → integrate(J, S') → V →
  (loop if ∃ s : disposition(s) = Deferred ∧ trigger(s) met)

── MORPHISM ──
WorkingContext
  → identify(high_leverage_sources, S_high)    -- silent scan for sources warranting audit
  → tag(provenance, freshness, leverage)        -- attach metadata triple per source
  → posit(antithesis per source)                -- Pattern A ∪ Pattern B ∪ Pattern C ∪ Pattern D
  → present(antitheses, disposition slots)      -- per-source Constitution interaction
  → judge(disposition per source)                -- closed coproduct response
  → emit(VettedContext with disposition table)
  → VettedContext
requires: working_context_pre_execution_committed   -- runtime checkpoint (Phase 0)
deficit:  ContextSuspect                            -- activation precondition (Layer 1)
preserves: source_chain                              -- W.sources is read-only; antithesis and disposition annotate, never mutate
invariant: Dialectical Vetting over Silent Trust

── TYPES ──
W              = WorkingContext { sources: List(Source), action: Prospect }
Source         = { content: String, origin: Origin, observed_at: Timestamp, downstream: List(Reference) }
Origin         ∈ {UserStatement, DocumentRead, ToolOutput, AIInference, ExternalAPI, PastSession} ∪ Emergent(Origin)
identify       = WorkingContext → Set(Source)            -- silent selection per Source Identification Criteria
S_high         = Set(Source)                              -- audit-candidate set; cardinality 0 yields trivial convergence
ClaimRef       = { referent: String, claim_kind: String, scope: String, text: String }
               -- claim_kind = the SEMANTIC CATEGORY of claim the source is tested as authority for (a distinct axis from an evidence-channel kind); values are protocol-local (self-contained, no shared cross-protocol enum). text = claim verbatim, used by Pattern A's cite-claim-verbatim test
ProvenanceTag  = { source: Source, claim: ClaimRef, evidence: VerificationPath, confidence: Float }
               -- claim-relative tag: the source's authority is recorded for the claim it authorizes, not for the source in general
VerificationPath ∈ {DirectObserved, InferredFromN, ExternalCited, ProvisionalAssumption}
FreshnessTag   = { source: Source, age: Duration, horizon: Duration, stale: Bool }
               -- currency only: a source can be fresh yet still not track the behavior its claim asserts (it documents intent with nothing enforcing the match). Freshness is necessary but not sufficient for trusting a source; the support-integrity challenge is posited per source in Pattern A (Source Provenance Audit).
LeverageTag    = { source: Source, downstream_count: Nat, branches: Set(Reference) }
S'             = Map(Source, ProvenanceTag × FreshnessTag × LeverageTag)
Pattern        ∈ {ProvenanceAudit, CounterfactualGap, CrossSourceConsistency, InferenceFallacyAudit} ∪ Emergent(Pattern)
Antithesis     = { source: Source, pattern: Pattern, thesis: String, antithesis: String, basis: String }
A[]            = List(Antithesis)
Disposition    = Confirmed                                   -- assumption survived antithesis
               | Revised(refinement: String)                 -- assumption updated per antithesis
               | Discarded(reason: String)                   -- assumption withdrawn
               | Deferred(re_trigger_condition: String)      -- next iteration on trigger
               | Conditional(measurement: String)            -- pending external measurement
               | Bounded(external_reference: String)         -- routed to other source-of-truth
               | Routed(downstream_protocol: ProtocolId)     -- handed off to a different protocol
Qs             = Per-source disposition gate
J              = Map(Source, Disposition)
V              = VettedContext { dispositions: J, trace: Map(Source, Antithesis) }
trigger_met(c)        = Bool                                                                            -- evaluator: true when a Deferred re_trigger_condition c is now satisfied at the LOOP scan
deferred_pending(Λ)   = {s ∈ S_high | Λ.dispositions(s) = Deferred(c) ∧ ¬trigger_met(c)}                -- sources whose Deferred condition has not yet fired
vetted(V)      = ∀ s ∈ S_high : ¬(∃c. J(s) = Deferred(c) ∧ trigger_met(c))
VettedContext  = V where vetted(V) ∨ user_esc

── PHASE TRANSITIONS ──
Phase 0: W → identify(W) → S_high                                       -- silent scan (no user interaction)
Phase 1: S_high → Step₁ tag(provenance, freshness, leverage) → S'       [Tool: Read, Grep]
         Step₂ posit(antithesis per s ∈ S') → A[]                        -- per-source Pattern A ∪ B ∪ C ∪ D generation
Phase 2: (A[], disposition slots) → Qs(per-source) → Stop → J            [Tool: Constitution interaction]
Phase 3: J → integrate(J, S') → V                                        -- per-source disposition recorded

── LOOP ──
After Phase 3: scan for Deferred dispositions whose re_trigger_condition is met.
If ∃ s : J(s) = Deferred(c) ∧ trigger_met(c): return to Phase 1 with s as fresh ContextSuspect; new antithesis under updated evidence.
If all dispositions resolved (no Deferred or all triggers unmet): terminate with VettedContext.
User can exit at Phase 2 (user_esc).
Continue until: vetted(V) ∨ user_esc.
Convergence evidence: At vetted(V), present transformation trace — for each s ∈ S_high, show (s → antithesis(s) → disposition(s)). Convergence is demonstrated, not asserted.

── CONVERGENCE ──
vetted(V): see TYPES
progress(Λ) = 1 - |deferred_pending(Λ)| / |S_high|
early_exit = user_esc

── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 identify        (sense)        → Internal analysis (high-leverage / age / chain / contradiction / inference-character scan)
Phase 1 ProvenanceTag   (observe)      → Read, Grep (verification of source origin, authorized claim, and downstream references)
Phase 1 AntithesisPosit (sense)        → Internal analysis (Pattern A/B/C/D antithesis generation per source)
Phase 2 Qs              (constitution) → present (mandatory; per-source disposition slots; Esc → loop termination at LOOP level, not a Disposition)
Phase 3 integrate       (track)        → Internal state update (Λ.dispositions, Λ.history)
converge                (extension)    → TextPresent+Proceed (per-source disposition trace; proceed with VettedContext)

── MODE STATE ──
Λ = {
  phase: Phase,
  W: WorkingContext,
  S_high: Set(Source),
  tagged: Map(Source, ProvenanceTag × FreshnessTag × LeverageTag),
  antitheses: Map(Source, Antithesis),
  dispositions: Map(Source, Disposition),
  history: List<(Source, Antithesis, Disposition)>,
  active: Bool,
  cause_tag: String
}

── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). graph.json edges preserved. Pattern resolution emergent via session context.
```

## Core Principle

**Dialectical Vetting over Silen