induce

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:

Cross-session enrichment: Accumulated abstraction formation history from Anamnesis's hypomnesis store (session recall indices written by the SessionEnd/PreCompact hook) provides Fuse candidates for Phase 1 — previously crystallized abstractions in adjacent domains become lateral Synagoge targets. When /recollect has been invoked in session, recalled adjacent abstractions enter the candidate construction pool as fuse-reference. Heuristic input may bias toward previously observed patterns; 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:

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

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.

Design principles:

• Personalized grounding: Always draw the grounding example from the user's own domain context so they recognize it as theirs.
• Calibration before choice: Show the preservation/sharpening/pruning/open map before the gate so the user evaluates the concept pressure, not just an AI label.
• Socratic shaping: Each move (widen/narrow/fuse/reorient) is a recognized dialectical turn, not a free-form revision request.
• Budget framing: Display the attempt counter as a framing signal — the remaining refinement budget the user reasons with — bounded by the attempt cap; not a progress count.
• Free response honored: When the presented moves do not capture the user's shape, parse free response as candidate redirection. If the user disputes K itself, absorb the correction through the existing UserMove/free-response path rather than adding a separate calibration-review constructor.

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