induce

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 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 artifact read, artifact search, and a conditional external fetch 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) ∨ 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 = 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) → artifact read, artifact search (user's domain context for personalized grounding); external fetch (conditional: cross-domain adjacent abstractions)
Phase 2 Qs         (constitution)    → present calibration map + candidate + grounding (mandatory)
Phase 3            (track)   → Internal state update
converge           (extension)   → TextPresent+Proceed (convergence evidence trace + open disposition; proceed with crystallized abstraction)
seam               (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: its only cross-protocol link is an inbound misfit absorption (Rule 11), not a post-crystallization 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, 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₂). 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

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.

Trigger Signals

Heuristic evidence signals for in-process abstraction detection:

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
• An existing abstract structure needs validation against a concrete target, not a new abstraction formed
• Comparative analysis between already-named candidate readings or frames — 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:

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):

• Comparative analysis between already-named candidate readings/frames
• Audit of decision gaps
• Validating an existing abstract structure against a concrete target

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

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 an upstream colimit-shaped-input signal is present (essence sensed, locator absent, previously read as a validation target): absorb it as a 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 artifact read/artifact search 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 (external fetch). 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 (artifact read, artifact search, external fetch). 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]
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

UX Safeguards

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 or attempt cap.
8. Not a validation operation: A pre-existing abstract structure needing validation against a target falls outside Periagoge's own operation, which forms new abstractions rather than validating existing ones.
9. 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, so the gate carries the question and each option's differential implication. 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.
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 upstream misfit: When an upstream detection of colimit-shaped input (essence_sensed + locator_absent(A)) nudges here, absorb it as a valid Periagoge trigger. Before Phase 1, surface the routing rationale with its cited 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. 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).
15. Seam relay on declared continuation: when a user-declared chain names the next protocol, the between-protocol seam after this protocol's crystallization is relay (Extension) — proceed directly, citing the settling source (the chain declaration). This protocol declares no wired outbound continuation edge — its only cross-protocol link is an inbound misfit absorption (Rule 11), not a post-crystallization 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.
16. 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.