--- name: Heuresis Protocol slug: heuresis-protocol category: AI Engineering description: Heuresis Protocol widens an underexpanded idea field by generating diverse candidates in parallel without ranking or eliminating them. Use it when a topic is blank or has converged too early and you need more possibilities before choosing. github: "https://github.com/jongwony/epistemic-protocols/tree/main/heuresis/skills/ideate" language: JavaScript stars: 161 forks: 15 install: "npx degit https://github.com/jongwony/epistemic-protocols/tree/main/heuresis/skills/ideate ~/.claude/skills/ideate" installs_to: ~/.claude/skills/ideate source_path: heuresis/skills/ideate/SKILL.md collection_size: 25 category_size: 3670 collection_url: "https://dirskills.com/collections/jongwony/epistemic-protocols" added: 2026-09-08T05:36:09.078Z last_synced: 2026-09-08T05:36:09.078Z canonical_url: "https://dirskills.com/skills/heuresis-protocol" --- # Heuresis Protocol Heuresis Protocol widens an underexpanded idea field by generating diverse candidates in parallel without ranking or eliminating them. Use it when a topic is blank or has converged too early and you need more possibilities before choosing. **Install:** ```bash npx degit https://github.com/jongwony/epistemic-protocols/tree/main/heuresis/skills/ideate ~/.claude/skills/ideate ``` ## README # Heuresis Protocol Resolve an underexpanded candidate field through frame-parallel divergent generation, without ever eliminating, ranking, or selecting among the candidates it produces. Type: `(CandidateFieldUnderexpanded, User, DIVERGE, IdeationRequest) → DiverseCandidateField`. ## Definition **Heuresis** (εὕρεσις): the act of finding or discovering — a dialogical act of widening a candidate field that is empty or has prematurely converged, before any selection is made. Divergent and convergent thinking are distinct cognitive operations (Runco & Acar, 2012), and no protocol in this catalog carries a typed guarantee to generate the object-level alternative set itself — heuresis sits at the point where the candidate field itself is thin. On a blank entry, heuresis opens an abstract frame map before showing any concrete idea — early concrete examples measurably narrow independent generation (Wadinambiarachchi et al., 2024), and ideating before seeing material preserves ownership and diversity that seeing it first does not (Qin et al., 2025). Generation is frame-parallel and never eliminates, ranks, or scores: selection is a downstream act, out of this protocol's scope. ``` ── FLOW ── Heuresis(U) → bind(U) → classify_entry(U) → Entry → [Entry = Blank] derive_frames(topic) → Qframes(frame_map) → Stop → FrameSelection → [FrameSelection = Open(F_selected)] generate(∥ F_selected) → Round₁ [FrameSelection = Stop] → EarlyExit [Entry = Seeded(seeds)] derive_frames(seeds, topic) → generate(∥ frames; seeds fold in under their origin — utterance fragments as User) → Round₁ present(Round) → Qround → Stop → D → [D = Continue(frames)] shape_frames(frames)? → generate(∥ frames) → Round → present → Qround (loop) [D = Stop] assemble(Λ) → DiverseCandidateField (Λ.candidates ≠ ∅) | EarlyExit (Λ.candidates = ∅) -- chain note: when U names a ChainRef (a prior protocol's output), its material folds in as seeds at classify_entry — -- origin preserved when already tagged (a chained DiverseCandidateField), origin=User when untagged (collection -- output, utterance fragments); a deliberate substrate-first choice the user made, documented as a trade-off (`Chain semantics`) -- park note: a deepen request at any Qround (wanting more on an already-open frame) parks into Λ.parked — it never -- re-opens a frame mid-loop; parked follow-ups are declared at either terminal for post-protocol chaining -- signal note: Phase 0 also extracts Signal(s) — concerns, weaknesses, or requirements present in the same bound -- utterance + named ChainRef material — tagged by source (Utterance or Chain); coverage (unaddressed(Λ)) is -- recomputed each round from Λ.candidates, never separately stored, and never a score, elimination reason, or -- ranking signal ── MORPHISM ── IdeationRequest → bind(utterance) -- read only the invocation utterance + any explicitly named chain reference → classify_entry(utterance) -- Blank | Seeded(seeds); zero entry questions — inferred, never asked; a named -- ChainRef's material folds in here as seeds (origin preserved when already -- tagged, origin=User otherwise), so a ChainRef-bearing -- entry classifies Seeded even on a bare-topic utterance → derive_frames(Entry) -- candidate GenerationFrames — the registry later rounds progressively open → select_frames(frames) -- Blank only: Cognitive Partnership Move (Constitution) — frame map BEFORE any concrete candidate → generate(∥ open frames) -- parallel candidate production; no elimination, no ranking, no scoring → present(Round) -- relay: candidates by frame + explored/unexplored declaration + unaddressed -- signals when any exist → continue_or_stop(Round) -- user constitutive judgment; Stop available at every round AND before the first one; -- a deepen request parks (relay) rather than continuing — the loop only widens → assemble(field) -- the surviving field entire under the bound topic: every candidate origin- and frame-tagged, parked -- follow-ups and unaddressed signals declared, nothing dropped → DiverseCandidateField -- happy-path terminal; the zero-candidate stop path exits as EarlyExit (FLOW) requires: candidate_field_underexpanded(U) -- runtime checkpoint (Phase 0); direct /ideate invocation satisfies it deficit: CandidateFieldUnderexpanded -- activation precondition (Layer 1) preserves: seed_provenance(U) -- every seed keeps the origin it folded in with (User for the user's own -- fragments, an already-tagged chain origin as-is) through every later -- round; never relabeled invariant: Divergence over Selection -- generation never eliminates, ranks, or converges; selection is outside this protocol ── TYPES ── U = IdeationRequest: the invocation utterance, read as-is — a natural-language topic, optional idea fragments, and an optional explicit reference to a prior collection protocol's output -- Input type: the morphism reads only the bound utterance plus an explicitly named prior-output reference — a -- bare invocation binds the immediately preceding user message AS the utterance (U-BINDING: a one-turn -- binding rule, still the user's own words); beyond that binding it never scans the wider session, codebase, -- or rules (Euporia's reverse-trace territory, not this protocol's) Entry = Blank -- utterance carries a topic only — no idea fragments, no named ChainRef | Seeded(Set(Seed)) -- utterance carries idea fragments and/or names a ChainRef; both sources -- fold in as seeds at classify_entry — utterance fragments as origin=User, chained material under its -- existing origin tag when it carries one (origin=User only when untagged) -- coproduct: Blank and Seeded take DIFFERENT phase paths (frame-first gate vs. expand-first) — behavioral -- branching per the structural convention (natural-language definitions are for uniform-processing inputs only) Seed = { content: String, origin ∈ {User, AI} } -- a pre-frame fragment; origin=User for utterance-borne fragments and -- untagged chained material, while chained material already carrying an origin tag keeps it (a chained -- DiverseCandidateField's candidates re-seed under their existing tags — an origin=AI candidate is never -- relabeled User by re-chaining). Carries no frame yet — frames do not exist until Phase 1 derives them -- (GenerationFrames are invocation-local, so a chained candidate's old frame is dropped, not preserved). -- Promoted to Candidate on the first generation pass, gaining the frame it lands under (origin travels unchanged) ExpansionWitness ∈ {Empty, NarrowAcrossFrames, PrematurelyConverged} ∪ Emergent(T) -- classification of WHY the candidate field is underexpanded; cited as Phase 0 relay basis. Sub-level to -- CandidateFieldUnderexpanded — NOT itself a top-level deficit, and never gates activation (User-initiated: -- direct /ideate invocation IS the activation) ChainRef = an explicit reference the utterance itself names to a prior collection protocol's output (e.g. "using what -- /inquire just gathered") -- the ONLY substrate-adjacent material this protocol reads; absent a named -- reference, no external material enters (Euporia boundary: no substrate scan, no reverse-traced coordinates) Signal = { content: String, source ∈ {Utterance, Chain} } -- a concern, weakness, or requirement present in the bound input only — extracted at Phase 0 alongside Entry, -- from the same bound utterance plus any explicitly named ChainRef material (never a wider scan); source -- records which of the two it came from. Never a quality score, elimination reason, or ranking signal -- (coverage — unaddressed(Λ), defined in CONVERGENCE — is a binary observation, not a judgment on any candidate) Candidate = { content: String, frame: Frame, origin ∈ {User, AI} } -- a generated idea item (raw material for divergence) — NOT a selection-ready alternative; carries no score, -- rank, or preference signal Frame = GenerationFrame { label: String, angle: String } -- a partition for parallel candidate production; distinct from Prothesis's -- FramedInquiry lens — GenerationFrame carries no substrate_need, no per-perspective directive, no -- epistemic-perspective machinery. It organizes divergent generation only — derived at Phase 1, extended -- only for a user-named new angle, opened progressively across rounds (never re-derived by a bare -- continue) — and is never handed off as a framed inquiry object Round = { candidates: Set(Candidate) } -- one generation pass over F_open; F_open ∩ Λ.frames_open = ∅ is guaranteed at Phase 2, -- so each pass opens only not-yet-open frames (no mid-loop re-entry; a deepen wish parks instead) Qframes = frame-map presentation (Blank path only) — abstract frames, no concrete candidate yet [Tool: Constitution interaction] FrameSelection ∈ {Open(frames: Set(Frame)), Stop} -- Qframes answer type, Open/Stop differential-future rationale: read references/blank-entry.md Qround = per-round presentation: candidates by frame + explored/unexplored (direction contrast) + parked-so-far + unaddressed-signal declaration, then continuation ask, Continue always first and Stop always second [Tool: Constitution interaction] D = ContinuationAnswer ∈ {Continue(frames: Set(Frame)), Stop} -- Continue's frames are drawn from the declared unexplored set, or are user-named frames outside the declared -- set (free response — type-preserving materialization of Continue, not a new constructor). An already-open -- frame is NOT a Continue target: wanting more on it is a park request (→ ParkedFollowUp) — mid-loop -- deepening narrows the very field the loop exists to widen, so depth belongs to a later invocation chaining -- on the assembled field. A Continue naming no frames defaults to the declared unexplored set; when none -- remain, Continue has no default target — it materializes only with a user-named new angle (the gate's -- option text renders that state), and a Continue that materializes no target re-presents the round -- question rather than entering generation — an empty pass never runs. Stop is available at every Qround exactly as at -- Qframes — the user's stop is the constitutive act that bounds the field, not a pre-convergence abandonment ParkedFollowUp = { frame: Frame, note: Optional(String) } -- a mid-loop wish to go deeper on an already-open frame, captured as a typed follow-up instead of narrowing -- the live loop; held in Λ.parked and declared at either terminal — its durable externalization (a task -- record, an issue) is a host-side handoff after the protocol ends, so the loop itself stays side-effect-free DiverseCandidateField = { topic: String, candidates: Set(Candidate { content, frame, origin }), explored_frames: Set(Frame), unexplored_frames: Set(Frame), parked: Set(ParkedFollowUp), unaddressed_signals: Set(Signal) } -- "diverse" = frame-distributed, never scored/ranked/optimized; candidates ≠ ∅ always holds here (see EarlyExit -- for the empty case). unaddressed_signals holds only signals with no responding candidate at Stop — an -- addressed signal needs no field of its own: the candidates heuresis read as answering it are already in -- the field, and judging that fit is the consumer's own act at selection time. -- The field is the propagation contract: endpoint-neutral and complete for unfolding what it carries -- (an issue tracker, /preview, a chained /ideate) — topic carries the bound request; the one declared -- boundary is the full signal take/discard ledger, which stays in session text (see Known Limitations); -- endpoint-specific unfolding is downstream scope, not heuresis's EarlyExit = { frames_offered: Set(Frame), parked: Set(ParkedFollowUp), unaddressed_signals: Set(Signal) } -- the typed terminal for a stop (Qframes Stop, a Qround Stop after passes that produced nothing) -- that fires while no candidate exists — an empty -- field is never mislabeled DiverseCandidateField; frames_offered declares what was on the table even -- though nothing was generated, unaddressed_signals holds every signal extracted (none had a candidate to -- respond to it), and any parked follow-ups are declared alongside — nothing is silently dropped ── U-BINDING ── bind(U) = explicit_arg ∪ colocated_expr ∪ prev_user_turn ∪ chain_ref Priority: explicit_arg > colocated_expr > prev_user_turn > chain_ref -- prev_user_turn binds only on a bare invocation: the immediately preceding user message BECOMES the utterance -- (one turn, the user's own words) — a binding rule for U, not a license to scan session history -- chain_ref, when named, folds its material in as seeds (origin preserved when tagged, User otherwise) — it never substitutes for the topic itself /ideate "topic or fragments" → U = "topic or fragments" /ideate (alone) → U = previous user message "give me some ideas ... /ideate" → U = text before trigger "using what /inquire just found, /ideate" → U also carries the named ChainRef; its material folds in as origin=User seeds (untagged collection output; a chained DiverseCandidateField would keep its candidates' own origin tags) ── PHASE TRANSITIONS ── Phase 0: U → bind(U) → classify_entry(U) → Entry ⊗ ExpansionWitness; Λ.topic := topic(U); Λ.signals := extract_signals(U) -- silent; zero entry questions; topic(U) records the bound request in mode state, so assemble(Λ) has a formal source for the field's topic; extract_signals(U) reads the same bound utterance + named ChainRef only (`Euporia boundary — utterance-only input` boundary) and tags each Signal's source classify_relay(Entry, ExpansionWitness) → TextPresent+Proceed -- states the inferred entry + its basis + the extracted signals (source-tagged) before proceeding; relay, not a gate — every signal enters session text once, at extraction Phase 1: Entry → Λ.frames_candidate := derive_frames(Entry) -- registered into mode state at derivation, so the frames_open ⊆ frames_candidate invariant is checkable from the first pass [Entry = Blank] present(frame map) → Qframes → Stop → FrameSelection [Tool] -- read references/blank-entry.md [FrameSelection = Open(F_selected)] → Phase 2 with F_selected [FrameSelection = Stop] → EarlyExit(frames_offered := Λ.frames_candidate, parked := Λ.parked, unaddressed_signals := Λ.signals) -- stop before any candidate exists; Λ.parked is necessarily ∅ here (parks originate at Qround) — passed explicitly for uniform construction; every extracted signal is unaddressed since no candidate exists yet [Entry = Seeded(seeds)] → Phase 2 directly with Λ.frames_candidate (no gate — expand-first) -- read references/seeded-entry.md Phase 2: F_open → generate(∥ over F_open) → Round(candidates) -- no elimination, no ranking; on the first pass of a Seeded entry, seeds promote to Candidates under the frame each lands in, each keeping its seed origin (utterance fragments User); generated candidates carry origin=AI; F_open ∩ Λ.frames_open = ∅ (Phase 3 admits only unexplored or newly registered frames), so every pass opens genuinely new frames Λ.candidates := Λ.candidates ∪ Round.candidates, Λ.frames_open := Λ.frames_open ∪ F_open, Λ.rounds := append(Λ.rounds, Round) -- state absorbed BEFORE Phase 3 presents: every Qround guard (the Stop branches' Λ.candidates test) reads post-round state, never stale Phase 3: Round → present(Round: candidates by frame, explored_frames, unexplored_frames, parked so far, unaddressed(Λ)) → Qround → Stop → D [Tool] [park request — the response asks for more on an already-open frame] Λ.parked := Λ.parked ∪ {ParkedFollowUp(frame, note)} — relay the parking (extension); a response carrying only a park leaves the continuation question open, so Qround is re-presented with the park acknowledged [D = Continue(frames: F'), F' ≠ ∅, F' ⊆ frames_unexplored(Λ)] → Phase 2 with F' (open unexplored — no new derivation; an already-open frame is never a Continue target) [D = Continue(frames: F'), F' ⊄ Λ.frames_candidate] Fₙ := shape_frames(F' \ Λ.frames_candidate); Λ.frames_candidate := Λ.frames_candidate ∪ Fₙ → Phase 2 with (F' ∩ frames_unexplored(Λ)) ∪ Fₙ (user-named new angle — shape_frames shapes it into registered frames before generation, a distinct operation from Phase 1's derive_frames: its domain is Set(Frame), not Entry; type-preserving materialization of Continue; any already-open frame the response also named routes to the park branch, never back into F_open) -- a Continue naming no frames defaults F' := frames_unexplored(Λ); when none remain, Continue has no default target — it materializes only with a user-named new angle (the gate's option text renders that state), and a bare Continue never derives new frames [D = Continue(frames: ∅) — the default resolved to an empty set: no unexplored frame remains and no new angle was named] → re-present Qround with that state rendered — Continue materialized no target, so no generation pass runs (F' ≠ ∅ guards Phase 2 entry; an empty round never exists) [D = Stop, Λ.candidates ≠ ∅] → assemble(Λ) → DiverseCandidateField(topic := Λ.topic, candidates := Λ.candidates, explored_frames := Λ.frames_open, unexplored_frames := frames_unexplored(Λ), parked := Λ.parked, unaddressed_signals := unaddressed(Λ)) -- every field sourced from Λ; explored_frames is the chain-contract name of Λ.frames_open [D = Stop, Λ.candidates = ∅] → EarlyExit(frames_offered := Λ.frames_candidate, parked := Λ.parked, unaddressed_signals := Λ.signals) -- a completed pass can yield nothing; honest stop typing routes an empty field to EarlyExit, never DiverseCandidateField; with no candidates, every extracted signal is unaddressed ── LOOP ── Round cadence: Phase 2 (generate, ∥ over open frames) → Phase 3 (present + Qround). Before every Qround, heuresis evaluates four things: which signals remain unaddressed, how the explored and unexplored frames differ in direction (not just their labels), what continuing would cost to review, and what stopping would finalize and preserve — the evaluation is fixed every round, but what renders adapts to what carries decision-relevant content this round (empty or unchanged detail may compress), except unaddressed signals, which are always surfaced whenever any exist. A Continue answer triggers shape_frames only when the user names a wholly new angle (shaped into registered frames before generation); opening declared-unexplored frames returns directly to Phase 2 — then back to Phase 3. A deepen request never re-enters Phase 2 mid-loop: it parks (Λ.parked) for a later invocation chaining on the assembled field — depth is downstream, width is this loop's whole business.