induce

name

induce

description

Calibrate and crystallize in-process abstraction through dialectical triangulation. Proposes calibrated candidate abstractions with personalized grounding examples and shapes them via user widen/narrow/fuse/reorient moves when an instance set has converged toward an unnamed essence, producing crystallized abstraction. Type: (AbstractionInProcess, AI, INDUCE, A) → CrystallizedAbstraction. Alias: Periagoge(περιαγωγή).

Periagoge Protocol

Calibrate and crystallize in-process abstraction through AI-proposed candidate plus user dialectical triangulation. Type: (AbstractionInProcess, AI, INDUCE, A) → CrystallizedAbstraction.

Definition

Periagoge (περιαγωγή): A dialogical act of turning an in-process abstraction toward its crystallized form, where AI detects when an instance set has converged toward an unnamed essence, calibrates the user's in-process concept against that instance set, proposes a calibrated candidate abstraction paired with a personalized grounding example drawn from the user's own domain, and shapes the candidate through the user's response — accept the candidate, broaden its scope, narrow it along a specific dimension, fuse it with an adjacent abstraction, or redirect onto an orthogonal axis — until the abstraction locates itself (the Greek dialectical vocabulary supplies the source terms, attributed in the footnote).¹

── FLOW ──
Periagoge(A) → Detect(A) → in_process? →
  true:  (Iᵢ, E, L?) → Calibrate(Iᵢ, E, L?, ctx) → K →
         Propose(Iᵢ, E, K, ctx) → (P, G) →
         Qs(P, G, K, framing) → Stop → V → integrate(V, candidate) → candidate' →
         loop until crystallized(A) → declare(completion_trace, open_trace) → CrystallizedAbstraction
         or user_esc ∨ attempts_exhausted → deactivate
  false: deactivate

── MORPHISM ──
A
  → detect(instances, essence, locator)   -- verify in-process abstraction exists
  → calibrate(E, L?, Iᵢ, ctx)             -- surface what instances preserve, sharpen, prune, and leave open
  → propose(candidate, grounding, calibration)  -- AI generates candidate + personalized example + calibration map
  → triangulate(candidate, user_move)     -- user shapes via type-preserving materialized moves
  → integrate(V, candidate)               -- update candidate per user response
  → crystallize(abstraction)              -- convergence when confirmed
  → declare(trace, open_trace)             -- terminal evidence trace + open-item disposition
  → CrystallizedAbstraction
requires: in_process(A)                    -- runtime checkpoint (Phase 0)
deficit:  AbstractionInProcess              -- activation precondition (Layer 1/2)
preserves: instance_set(A)                  -- Iᵢ read-only; K computed per Phase 1 entry and recomputed on Phase 1 re-entry; candidate mutates per user move
invariant: Calibrative Induction through Dialectical Triangulation over Unilateral Correction

── TYPES ──
A              = AbstractionSeed (in-process state: instances + essence intuition + optional user concept label)
Detect         = A → (Bool, (Iᵢ, E, L?) if true)
Iᵢ             = Set(Instance)                             -- instance set observed; cardinality unconstrained (any N ≥ 1 qualifies when essence is sensed; richer sets provide stronger triangulation material)
Instance       = { content: String, context: String }       -- concrete case observed
E              = EssenceIntuition                           -- variation-stable core signal from conversation
L              = Option(TentativeLabel)                     -- user-provided provisional name or concept, if any
ctx            = DomainContext                              -- user's domain context gathered via Read, Grep, and conditional WebSearch in Phase 1
Calibrate      = (Iᵢ, E, L?, ctx) → K
K              = CalibrationMap { keeps, sharpens, prunes, open }
                 keeps     = supported core to preserve
                 sharpens  = under-specified decision-relevant structure
                 prunes    = overextended or unsupported scope to release
                 open      = residual uncertainty that does not block crystallization
OpenDisposition ∈ {None, Nonblocking, Deferred}
                 None        = no open calibration pressure remains; explicitly declared
                 Nonblocking = open item remains visible but does not block Confirm
                 Deferred    = user routes an open item to later work via free response
OpenItemDisposition ∈ {Nonblocking, Deferred}
OpenTrace      = { status: OpenDisposition, items: Map(String, OpenItemDisposition) }
                 -- terminal disposition for K.open; empty open sets declare status None
status(OpenTrace) = None if K.open = ∅; Deferred if ∃ item : items(item) = Deferred; otherwise Nonblocking
P              = CandidateAbstraction { name, structure, instance_map, provenance }
G              = GroundingExample { scenario: String, domain: String, mapping: String }
                                                             -- personalized to user's own domain context
Propose        = (Iᵢ, E, K, ctx) → (P, G)
V              = UserMove ∈ {Confirm, Widen(direction), Narrow(specializer), Fuse(adjacent), Reorient(axis), Dismiss}
                 direction    ∈ {upward, lateral}           -- Synagoge family; AI-proposed broadening (user Recognition mode)
                 specializer  = dimension to constrain      -- Diairesis family (user-directed specialization)
                 adjacent     = neighboring abstraction ref  -- lateral Synagoge with user-named reference (user Production mode)
                 axis         = orthogonal dimension         -- full redirection
Qs             = Shaping interaction with candidate + grounding [Tool: Constitution interaction]
crystallized(A) = ∃ step ∈ history : V(step) = Confirm
CompletionTrace = List<(A, K, P, V, candidate')>
                 -- derived from Λ.history with A sourced from Λ.A and candidate' computed from each step's post-move candidate state
CrystallizedAbstraction = P where confirmed(P) via Confirm move ∧ completion_trace_declared(CompletionTrace) ∧ open_disposition_declared(OpenTrace)

── A-BINDING ──
bind(A) = explicit_arg ∪ recent_instance_cluster ∪ surfaced_essence
Priority: explicit_arg > recent_instance_cluster > surfaced_essence

/induce "theme"              → A = AbstractionSeed with theme label
/induce (alone)              → A = most recent instance cluster in session (any cardinality)
"the pattern across..."      → A = instance cluster under discussion

If no essence signal is detectable (neither user sensing language nor AI-inferrable core pattern): pause activation and surface the scan result before Phase 0, inviting the user to either name what feels in-process or withdraw.

── PHASE TRANSITIONS ──
Phase 0: A → Detect(A) → in_process?                                       -- detection checkpoint (silent)
Phase 1: (Iᵢ, E, L?) → Calibrate(Iᵢ, E, L?, ctx) → K → Propose(Iᵢ, E, K, ctx) → (P, G); carry (P, G, K)  -- calibration + candidate + grounding construction [Tool]
Phase 2: (P, G, K) → Qs(P, G, K, framing) → Stop → V                      -- triangulation Constitution interaction [Tool]
Phase 3: V → integrate(V, candidate) → candidate'                          -- candidate update (track)

── LOOP ──
After Phase 3: evaluate user move.
If V = Confirm: crystallize(candidate), Λ.completion_trace := derive(Λ.history, Λ.A, candidate'), Λ.open_trace := derive(K.open, V, free_response), declare(Λ.completion_trace, Λ.open_trace), terminate.
If V = Widen(direction): candidate' = widened(candidate, direction) via Synagoge → return to Phase 2.
If V = Narrow(specializer): candidate' = narrowed(candidate, specializer) via Diairesis → return to Phase 2.
If V = Fuse(adjacent): candidate' = fused(candidate, adjacent) via lateral Synagoge → return to Phase 1 (grounding recomputed).
If V = Reorient(axis): candidate' = orthogonal(axis) → return to Phase 1 (full recompute).
If V = Dismiss: abandon candidate; if essence still sensed, return to Phase 1 with fresh candidate; else deactivate.
Max 5 triangulation attempts per abstraction seed.
Continue until: crystallized(A) ∨ user_esc ∨ attempts_exhausted.
Convergence evidence: At crystallized(A), present transformation trace — for each step ∈ history, show (calibration → candidate → user_move → candidate') — plus OpenTrace for K.open. OpenTrace status is None when K.open is empty, Deferred when any open item is routed to later work, and Nonblocking otherwise. Convergence is demonstrated, not asserted.

── CONVERGENCE ──
crystallized(A): see TYPES (V = Confirm in history)
progress(Λ) = |history| / max_attempts
early_exit = user_esc ∨ attempts_exhausted

── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 Detect     (sense)   → Internal analysis (no external tool)
Phase 1 Calibrate+Propose (observe) → Read, Grep (user's domain context for personalized grounding); WebSearch (conditional: cross-domain adjacent abstractions)
Phase 2 Qs         (constitution)    → present calibration map + candidate + grounding (mandatory; Esc key → loop termination at LOOP level, not a UserMove)
Phase 3            (track)   → Internal state update
converge           (extension)   → TextPresent+Proceed (convergence evidence trace + open disposition; proceed with crystallized abstraction)

── MODE STATE ──
Λ = { phase: Phase, A: AbstractionSeed, Iᵢ: Set(Instance), E: EssenceIntuition,
      calibration: Option(K), candidate: Option(P), grounding: Option(G),
      history: List<(P, G, K, V)>, attempts: Nat, crystallized: Option(P),
      completion_trace: Option(CompletionTrace),
      open_trace: Option(OpenTrace),
      active: Bool, cause_tag: String }

── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). registered dependency edges preserved. Dimension resolution emergent via session context.

Core Principle

Calibrative Induction through Dialectical Triangulation over Unilateral Correction: When an instance set has converged toward an unnamed essence but the abstraction has not located itself, neither AI nor user alone can crystallize the form. AI first shows how the instance set calibrates the user's in-process concept — what it preserves, sharpens, prunes, and leaves open — then proposes a candidate paired with a personalized grounding example drawn from the user's own domain. The user shapes the candidate through Socratic moves — widening (Synagoge), narrowing (Diairesis), fusing with an adjacent abstraction, or reorienting onto an orthogonal axis. The abstraction turns toward its crystallized form through the exchange, not by unilateral AI correction.

Mode Activation

Activation

AI detects in-process abstraction OR user calls /induce. Detection is silent (Phase 0); candidate proposal plus triangulation always requires user interaction via Cognitive Partnership Move (Constitution) (Phase 2).

Activation layers:

• Layer 1 (User-invocable): /induce slash command or description-matching input. Always available.
• Layer 2 (AI-guided): In-process abstraction detected via in-protocol heuristics (essence intuition signal + locator gap; instance cluster contributes evidence strength). Detection is silent (Phase 0).

In-process abstraction = an essence is sensed toward which an abstraction is forming, with locator gap active (name, scope, or positional claim remains unsettled). Concrete instances supply evidence for the sensed essence; richer instance sets provide stronger triangulation material.

Gate predicate:

in_process(A) ≡ essence_sensed(A) ∧ ¬located(A)

Periagoge's scope is specified by operation: colimit formation — constructing a new abstraction from an instance cocone when essence is sensed and locator gap is active. Instance cardinality is an evidence signal (see Trigger Signals table): stronger accumulation offers richer triangulation material. The operation distinguishes Periagoge from adjacent protocols (see Non-scenarios below); only colimit formation is Periagoge territory.

Priority

When Periagoge is active:

Supersedes: Direct output patterns that assert a label without triangulation (Abstraction must be crystallized through dialectical exchange, not unilaterally proposed)

Retained: Safety boundaries, tool restrictions, user explicit instructions

Action: At Phase 2, present calibration map plus candidate abstraction and personalized grounding example via Cognitive Partnership Move (Constitution).

• Periagoge completes before output dependent on the crystallized abstraction proceeds
• Loaded instructions resume after crystallization or Esc

Trigger Signals

Heuristic evidence signals for in-process abstraction detection:

Signal	Detection
Instance accumulation	Concrete cases carry a shared essence signal and provide triangulation material for abstraction formation
Essence intuition language	User phrases such as "something about these cases...", "the pattern I'm seeing...", "these all have...", "why do these keep happening..."
Locator gap	Name, scope, or positional claim remains unsettled for the emerging abstraction
Analogia misfit redirect	/ground Phase 0 detects colimit-shaped input (essence signal + locator_absent(A)) and nudges to /induce
Adjacent abstraction surfacing	Recall yields neighboring abstractions, suggesting a fuse or specialize move is imminent

Cross-session enrichment: Prior session indices from the hypomnesis store (prior-session recall indices), when present, may seed Phase 1 Fuse candidates; the constitutive judgment remains with the user.

Skip:

• No essence signal detectable (neither user sensing language nor AI-inferrable core pattern)
• Abstraction already located (name + scope + position settled) — no in-process state to turn
• User explicitly names the abstraction without in-process signals
• /ground substitution is the actual need (abstract structure exists; validate against concrete target)
• Comparative analysis between already-named candidate readings or frames — defer to Prothesis (frame selection) or Syneidesis (gap in decision); this is not colimit formation regardless of instance count
• Same (instance set, essence) pair was crystallized or dismissed in current session (session immunity)

Canonical Invocation Scenarios

Periagoge's scope, stated positively by canonical use patterns:

#	Scenario	Prototype	Structure
S1	Review-time pattern accumulation — multiple observations accumulating during ongoing review/work feel coherent but lack a name	PR-review session recognizing a recurring deficit pattern; multi-sprint retro finding common success factors	accumulated observations + review/reflection context
S2	Terminology crystallization — several loose phrases are being used interchangeably and need consolidation into a single precise term	"eidetic variation" settling a previously loose terminological space; informal "we keep saying X-ish" → settled term	lexical colimit
S3	Cross-domain structural sensing — parallel structures observed across different domains; user wants to name the shared essence	same pattern across multiple projects/codebases; "these pipelines feel structurally similar"	cross-domain colimit
S4	Meta-pattern in own recurring work — reflection on a recurring cognitive/behavioral move in one's own practice → naming	"I keep doing X in different contexts" → formalization as a principle	self-reflective colimit

Edge case (still valid): Single instance with strong phenomenological grip — e.g., "yesterday I was in a strange mode, what was that?" — qualifies when essence_sensed is active and no locator exists. Rare but legitimate.

Non-scenarios (out of scope — defer to named protocol):

• Comparative analysis between already-named candidate readings/frames → Prothesis (/frame, frame selection)
• Audit of decision gaps → Syneidesis (/gap)
• Validating an existing abstract structure against a concrete target → Analogia (/ground)

The operational test: "Is the user operation forming a new abstraction from observed instances, or is it something else (selecting, validating)?" Only the first is Periagoge.

Mode Deactivation

Trigger	Effect
User confirms candidate	Crystallize and proceed
User Esc key	Return to normal operation; abstraction remains in-process
Attempt cap reached (5 triangulations)	Surface remaining candidate with explicit unresolved status, deactivate

Protocol

Phase 0: In-Process Detection Checkpoint (Silent)

Analyze conversation state for in-process abstraction. This phase is silent — no user interaction.

1. Bind seed A: use explicit argument or the most recent instance cluster surfaced in session (any cardinality qualifies when essence is sensed — single case strong-grip, paired comparison, or accumulated set)
2. Check essence signal E: scan for variation-stable core signal in conversation (user essence-intuition language or AI-inferred pattern). This is the primary gate — if no essence is sensed, the abstraction has nothing to turn toward
3. Check locator absence: if a name plus scope plus position is already settled, skip (no turning needed)
4. If essence_sensed ∧ ¬located: proceed to Phase 1 with (Iᵢ, E, L?)
5. If Analogia misfit signal is present (colimit-shaped input forced into substitution): absorb the misfit as valid Periagoge trigger without re-confirmation

Scope restriction: Detection is silent. Does NOT modify files or call external services.

Phase 1: Calibration + Candidate Proposal + Grounding Construction

Generate a calibration map, candidate abstraction, and personalized grounding example.

1. Calibrate the seed K: compare (Iᵢ, E, L?) against the user's context and sort the concept pressure into four fields: keeps (supported core to preserve), sharpens (decision-relevant structure needing clarity), prunes (unsupported overextension to release), and open (residual uncertainty that does not block crystallization). When L? is absent, calibrate on E alone: sharpens and prunes are relative to the inferred essence rather than to a user-named concept.
2. Synthesize candidate P: from (Iᵢ, E, K), construct a named abstraction with structure and instance-to-abstraction mapping. The candidate is a working hypothesis, not a claim.
3. Construct personalized grounding G: call Read/Grep to collect evidence about the user's own domain context (codebase, configs, session history). The grounding example must be drawn from the user's domain — a scenario they recognize as theirs — not a generic textbook case.
   • When the user's domain is outside the current codebase (external API, academic field, professional practice), extend context collection to web search (WebSearch). Tag web evidence with source: "web:{url}" for traceability.
4. Check adjacent abstractions: if recall (Anamnesis hypomnesis store or in-session history) surfaces neighboring abstractions, note them as Fuse candidates for Phase 2.
5. Package (P, G, K) with Fuse candidates and proceed to Phase 2.

Scope restriction: Read-only investigation (Read, Grep, WebSearch). No test execution or file modifications.

Phase 2: Dialectical Triangulation (Constitution)

Present the calibration map, candidate, and grounding example via Cognitive Partnership Move (Constitution).

Surfacing format:

Present the calibration map and candidate as text output:

• Keeps: [what the instance set repeatedly supports and the candidate preserves]
• Sharpens: [what must become clearer for the abstraction to be usable]
• Prunes: [what the instance set does not support or overextends]
• Open: [what remains unresolved without blocking crystallization]
• Candidate: [name] — [structural description]
• Instance map: [how Iᵢ maps to the candidate's structure]
• Grounding example: [scenario drawn from user's domain, with mapping to the candidate]
• [If Fuse candidates exist: list adjacent abstractions with brief relation]
• Budget: how many refinement tries remain before the cap — the budget you reason with, stated as prose, not a numeric attempt fraction

Then present:

Does this crystallize the concept enough to use?

Options:
1. **Confirm / Use this** — [what the crystallized abstraction enables downstream]
2. **Widen / Broaden it** — [how upward or lateral scope expansion reshapes the candidate]
3. **Narrow / Tighten it** — [what dimension specializes or what to exclude]
4. **Fuse / Merge it** — [which adjacent abstraction to explicitly pull in for merge] *(presented only when Phase 1 surfaces adjacent candidates; otherwise omitted)*
5. **Reorient / Change the axis** — [what orthogonal axis to pursue instead]
6. **Dismiss / Drop this candidate** — [what assumption about this essence is released]

When Phase 1 surfaces no adjacent candidates, omit the Fuse option — dead signal suppression. Free response is always available — the user may name an adjacent abstraction for fusion, propose an alternative abstraction, specify a dimension not captured by the presented moves, or describe a shape the options do not cover.

Phase 3: Integration

After user response:

1. Confirm: Record crystallized(P) in Λ, derive CompletionTrace from Λ.history with A sourced from Λ.A and candidate' computed from the post-move candidate state, derive OpenTrace from K.open and the Confirm response, assign both traces in Λ, terminate with convergence evidence trace.
   • If K.open = ∅: OpenTrace.status = None, OpenTrace.items = ∅.
   • If K.open ≠ ∅ and the Confirm response has no explicit deferral signal for an open item: every open item defaults to Nonblocking, and OpenTrace.status = Nonblocking.
   • If the Confirm response explicitly names or unambiguously points to an open item with deferral markers such as "defer", "later", "next", or "come back to": classify that item as Deferred; all other open items default to Nonblocking; OpenTrace.status = Deferred if any item is Deferred.
   • Ambiguous or unnamed deferral text does not classify an item as Deferred; the item remains Nonblocking unless the response instead routes the candidate through an existing shaping move.
2. Widen(direction): Apply Synagoge — for direction = upward, generalize the candidate's scope; for direction = lateral, broaden sibling coverage. Return to Phase 2 with widened candidate (grounding may persist).
3. Narrow(specializer): Apply Diairesis — constrain the candidate along the specified dimension, excluding instances that fall outside. Return to Phase 2 with narrowed candidate.
4. Fuse(adjacent): Lateral Synagoge — merge candidate with named adjacent abstraction. Return to Phase 1 (grounding must be recomputed for fused structure).
5. Reorient(axis): Abandon current axis, restart along orthogonal dimension. Return to Phase 1 (full recompute).
6. Dismiss: Release the candidate. If essence is still sensed, return to Phase 1 with fresh candidate proposal; else deactivate.

After integration:

• Log (P, G, K, V) to history
• Increment attempts counter
• Check attempt cap (max 5) — if exceeded, surface unresolved candidate with explicit status and deactivate

Intensity

Level	When	Format
Light	Small instance set (3-4), clear essence	Brief candidate + one grounding example
Medium	Moderate instance set (5-8), essence present but ambiguous	Candidate + grounding + fuse candidates if recall surfaces them
Heavy	Large instance set, multiple plausible axes, adjacent abstractions compete	Full candidate decomposition + grounding + fuse candidates + orthogonal probes

UX Safeguards

Rule	Structure	Effect
Gate specificity	activate(Periagoge) only if essence_sensed ∧ ¬located	Prevents false activation on settled abstractions or essence-less inputs; instance count is evidence-for-essence, not a gate
Calibration map	Phase 1 sorts concept pressure into Keeps / Sharpens / Prunes / Open, surfaced before the candidate	Lets instances correct the concept without AI overriding the user; keeps evaluation on concept pressure, not just an AI label
Session immunity	Crystallized or dismissed (Iᵢ, E) pair → skip for session	Respects user's crystallization or release
Attempt cap	Max 5 triangulations per abstraction seed	Prevents infinite refinement; forces convergence or release
Budget framing	Attempt counter in Phase 2 surfacing — a framing signal, not a progress count	User sees remaining refinement budget
Analogia misfit absorption	/ground colimit-detection nudge routes here	Prevents source-domain confabulation in substitution path

Rules

1. AI-guided, user-triangulated: AI detects in-process abstraction and proposes candidates; crystallization requires user move via Cognitive Partnership Move (Constitution) (Phase 2).
2. Recognition over Recall: Present structured options via Cognitive Partnership Move (Constitution) — structured content reaches the user with response opportunity; Constitution interaction requires turn yield before proceeding.
3. Calibration plus candidate plus grounding required: Every Phase 2 surfacing pairs a calibration map, candidate abstraction, and personalized grounding example drawn from the user's own domain context — recognizable to the user as theirs (codebase, configs, session history, or stated domain), not a generic textbook example.
4. Calibrative Induction through Dialectical Triangulation over Unilateral Correction: AI candidate is a working hypothesis, not a claim. Concept correction is mediated by the instance set surfaced through K; crystallization belongs to the user's move.
5. Socratic move preservation: Phase 2 options map to recognized dialectical families (Synagoge / Diairesis / Fuse / Reorient — per-move mapping in Phase 3 Integration); the vocabulary is operational, not ornamental — each move is a recognized dialectical turn, not a free-form revision request.
6. Free response honored: When presented moves do not capture the user's shape, free response routes the candidate to reorient or fresh proposal. The user may also name an adjacent abstraction via free response when Fuse is not presented (because Phase 1 surfaced no candidates) and they hold one in mind. If the user disputes the calibration map (K) itself, the same free-response path absorbs the correction rather than requiring a separate calibration-review constructor. 6a. Fuse dead-signal suppression: Phase 2 omits the Fuse option when Phase 1 surfaces no adjacent abstraction candidates. Free response remains the channel for user-proposed fusion targets.
7. Convergence persistence: Mode active until crystallized, Esc, or attempt cap.
8. Cross-protocol awareness: Defer to Analogia when a pre-existing abstract structure needs validation against a target.
9. Context-Question Separation: Output all analysis, evidence, and rationale as text before presenting via Cognitive Partnership Move (Constitution). The question contains only the essential question; options contain only option-specific differential implications. Keeping context in the pre-gate text lets each option's differential implication stand alone, so the question arrives with the analysis already absorbed.
10. Convergence evidence: At crystallization, present transformation trace — for each step in history, show (calibration → candidate → user_move → candidate'). Per-step evidence is required. 10a. Open residual disposition: K.open persists at convergence as OpenTrace: None for an empty open set, Nonblocking for open items that remain visible without blocking crystallization, and Deferred for open items explicitly routed to later work through free response. Bare Confirm defaults every open item to Nonblocking; explicit deferral requires an open-item name or unambiguous open-item reference adjacent to deferral language. OpenTrace.status aggregates item dispositions as Deferred when any item is Deferred, Nonblocking when all items are Nonblocking, and None only when K.open = ∅. This is terminal trace metadata, not a separate user gate.
11. Absorb Analogia misfit: When /ground Phase 0 detects colimit-shaped input (essence_sensed + locator_absent(A)) and nudges here, absorb the misfit as valid Periagoge trigger. Before Phase 1, surface the routing rationale with the cited /ground detection basis ("colimit-shaped input detected: essence_sensed(A), locator_absent(A), [N supporting instances] — redirecting to abstraction crystallization") so the user can recognize the evidence that justified the redirect; the concrete instance count makes the routing rationale verifiable rather than vague.
12. Option-set relay test (Extension classification): If AI analysis converges to a single dominant move (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. Exception (Periagoge-scoped): The Confirm/Dismiss pair is excluded from the entire preceding test (Extension resolution, cost-symmetric collapse, and off-axis pathway demotion) — user crystallization judgment is constitutive regardless of AI analysis entropy. Phase 2 remains Constitution even when only one shaping move appears analytically viable.
13. Gate integrity (Safeguard tier): The defined option set is presented intact — injection, deletion, and substitution each violate this invariant. Type-preserving materialization (specializing a generic option like "Widen" into a concrete direction or pairing "Confirm" with "Use this" while preserving the UserMove coproduct) is distinct from mutation.
14. Plain emit discipline: User-facing emit (Phase 2 surfacing prose, convergence traces, gate options, and any text shown to the user) uses everyday language to reduce the user's cognitive load — every emit token should carry decision-relevant meaning, not project-internal overhead. SKILL.md formal-block vocabulary — variable names with subscripts, Greek-rooted terms in narrative, formal type labels inline, and code-style backtick tokens — stays in the formal block. What the user reads is the action, observation, or question in their idiom.
15. Round-local salience bundling: Each user-facing round bundles the current judgment, its nearest evidence, and the differential implication that matters for the next move. Keep adjacent material together so the user can recognize the decision without context-switching; defer background, distant context, and unrelated findings to pre-gate text, convergence traces, or later cycles.
16. 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 Plain emit discipline).

Footnotes

1. The name draws a structural analogy from Plato Republic VII.518d, where περιαγωγή names the soul's turning-around toward the intelligible. The protocol borrows the turning-toward structure; it does not claim Platonic paideia. Synagoge (συναγωγή, collection) and Diairesis (διαίρεσις, division) are the twin dialectical moves described in Phaedrus 265d–266a; here they name user response families, not a claim to Platonic method. ↩