probe

name	probe
description	Deficit Recognition Probe — surface multiple deficit hypotheses for the user's current situation and route by user-constituted recognition (fit review, not protocol scoring).
user_invocable	true

Probe Skill

Deficit Recognition Probe — when the user is uncertain which epistemic deficit (and therefore which protocol) fits the current situation, surface AI-generated multi-hypothesis candidates with reverse-evidence conditions, and route on user-constituted recognition. Type: (DeficitUnrecognized, AI, RECOGNIZE, UserSituation) → ProtocolRoute.

Invoke directly with /probe when the user wants a fit review across the protocol catalog before committing to a single protocol invocation. The AI may also surface these hypotheses on its own when it detects genuine deficit-ambiguity — offered as a low-confidence horizon for the user's fusion, not a covert frame (Rule 1); explicit invocation is one entry, not the only one.

Definition

Probe (ἐπίγνωσις, epígnōsis: knowing-upon, recognition of what was already there): A dialogical act of resolving a user's vague sense that "something is off" into a recognized deficit + protocol route, where AI scans the user's recent situation against the catalog of epistemic deficits, presents at minimum two hypotheses with falsification conditions, and the user constitutes the route via recognition — never AI-resolved scoring.

This skill stands in structural homology with Anamnesis (/recollect) — both realize the RECOGNIZE operation family. Anamnesis recognizes past context from vague recall; Probe recognizes present-situation deficit from vague unease. Anamnesis output is RecalledContext; Probe output is ProtocolRoute. Both treat user recognition as the constitutive act and refuse AI-side resolution.

When to Use

Invoke this skill when:

• The user feels something is off but does not yet name which epistemic deficit fits
• A protocol invocation is being considered, and the user wants a fit review across alternatives before committing
• Multiple plausible routes coexist (e.g., "is this a goal problem or a context problem?") and the user wants the alternatives surfaced explicitly with their reverse-evidence conditions

Skip when:

• The deficit is already named with confidence (invoke the matching protocol directly)
• The user wants a passive reference handbook (use /catalog)
• The user wants pattern-based recommendation from session history with optional trial (use /onboard)
• The user wants accumulated session analytics (use /report or /dashboard)

Distinction from /catalog and /onboard

Skill	Stance	Input	Output
/catalog	Passive reference	Browse / lookup	Static handbook entries
/onboard	Pattern-based recommendation + optional trial	Session history patterns	Recommended protocol + scenario + trial
/probe	Active AI-hypothesized deficit recognition	Current user situation	At minimum two hypothesis candidates + user-constituted route

The three coexist by design — none replaces the others. Probe is for experienced users with frame-binding uncertainty; /catalog is for users who already know the question; /onboard is for users who want pattern-based learning.

Protocol

Phase 0: Detection

Detect that the user's situation admits ambiguous deficit framing. Heuristics:

• The user's request describes symptoms ("something feels off", "not sure which protocol") rather than naming a deficit
• The session shows a pattern that maps to two or more candidate deficits with comparable plausibility
• The user explicitly invokes /probe

Phase 0 detection is silent — internal analysis, no output of its own. On a positive detection the protocol may proceed to surface the hypothesis horizon (Phase 1–2) without waiting for an explicit /probe, provided the surface is horizon-marked (Rule 1). If detection fails (the deficit is already clearly named with confidence), deactivate without surfacing.

Phase 1: Catalog Scan

Scan the user's situation against the full catalog of epistemic deficits. For each candidate hypothesis, build a Set(CoverageEntry) where each entry pairs:

• A deficit: DeficitName matched against the situation
• The protocol: ProtocolId that addresses that deficit
• evidence: Evidence — the situation signal supporting the match
• reverse_evidence: Evidence — the observation that would shrink the coverage to exclude this entry

A hypothesis with |coverage| = 1 is a single-protocol projection (preserves prior single-protocol behavior). A hypothesis with |coverage| ≥ 2 is a set-valued coverage — multi-protocol projection within one hypothesis. This intra-hypothesis multi-protocol projection is structurally distinct from the inter-protocol composition defined in the ── COMPOSITION ── block; do not conflate the two.

When Λ.coverage_constraint is set (from a prior Narrow(CoverageSubset)), filter the scan output to hypotheses whose coverage protocol set intersects with the constraint — this preserves user-directed narrowing across re-scan iterations.

Construct the candidate set. Keep at minimum two candidates with non-overlapping reverse-evidence conditions — singleton high-confidence framing is forbidden (see Rules section, Rule 5).

Substrate-implicit disambiguation (Rule 18): Before defaulting a candidate to a missing-information framing (e.g., ContextInsufficient//inquire, FrameworkAbsent//frame), check Euporia's own aporia(I) gate: the situation is not already committed to a single specific protocol, AND its substrate — current-session evidence (Rule 3 default scope), the user's own codebase, project rules or Northstar documents, or environment (cross-session recall stays opt-in per Rule 4) — already carries an implicit, not-yet-articulated decision signal relevant to the utterance (axis_undetermined(r) ∧ substrate_implicit(r), per euporia/skills/elicit/SKILL.md Gate predicate). When both hold, include AbstractAporia (/elicit) in the candidate set — an implicit-but-unarticulated decision coordinate is intent-decoding, not external-fact supply, and belongs to /elicit rather than /inquire. Utterance-only ambiguity without an external substrate signal still routes to /inquire, consistent with that same boundary.

Single-pass routing scope: Phase 1 enumerates named deficits across the catalog as a one-shot fit review. Per-protocol convergence dynamics — including cycle iteration within a routed protocol such as /elicit's reverse-induction loop — remain internal to that destination protocol; Probe does not surface, measure, or aggregate convergence efficiency across uses (Rule 7 reinforcement; cycle-counter visibility is the destination protocol's UX surface, not Probe's).

Phase 2: Hypothesis Presentation

Present the candidate hypotheses as text output before the Constitution interaction. Each rendered line under Coverage: corresponds to one CoverageEntry (deficit, protocol, evidence, reverse_evidence). Format per hypothesis:

Hypothesis N — N interpretations possible / decision point is X
  Coverage:
    /<protocol_a> (<DeficitName>):
      Evidence: <quote or paraphrase>
      Reverse-evidence: <observation that would shrink coverage to exclude this entry>
    /<protocol_b> (<DeficitName>):
      Evidence: <...>
      Reverse-evidence: <...>
  (Singleton |coverage|=1: render the single CoverageEntry as one protocol line, equivalent to prior single-protocol format)

Coverage option-set minimality: When |coverage| ≥ 2, coverage subsets are NOT enumerated as additional options — the per-entry Evidence and Reverse-evidence within the Coverage block serve as the short descriptions that guide singleton selection. The user invokes a singleton through free response or Narrow(CoverageSubset). This preserves option-set minimality and induces the Hermeneutic circle through iterative user-initiated dialogue rather than AI-side menu expansion. (This contextual rule informs the gate decision and therefore precedes the gate options.)

The hypothesis surface above offers a candidate horizon of the deficit space — open to your recognition, redirection, or transcendence, not a settled answer. Present the recognition Constitution interaction as a free-response prompt:

Which hypothesis fits your present situation?

Free response — the disposition is constituted by the user's natural utterance.
Recognition / Redirect / Dismiss / Narrow scope / Stop are all reachable via free response; no typed selection is required.

The disposition field belongs to the user. AI does not score, rank, or pre-resolve the choice. Free response preserves the user's implicit freedom to respond beyond any anticipated typed options — this freedom is inherent in conversation turn structure: gated does not mean unstructured; it means the user's response is constitutive (Rule 12 Recognition over Recall, inscribed in this SKILL.md; and evidence is presented as text output before the gate rather than folded into it).

Phase 3: Route Integration

After user response (free-response utterance from Phase 2):

Free-response parse: Phase 3 resolves the utterance to the R coproduct constructor whose semantic intent most closely matches — affirmative adoption of a presented hypothesis routes to Recognize, alternative deficit/protocol nomination routes to Redirect, rejection of all hypotheses routes to Dismiss, scope restriction (situation slice or coverage subset) routes to Narrow, and exit signal routes to Stop. The presented hypotheses serve as the recognition substrate; no typed selection is required. When the utterance does not unambiguously resolve into a single constructor, Phase 3 issues one bounded re-prompt requesting clarification; persistent ambiguity after the bounded retry defaults to Stop to preserve the user's exit-without-disposition right.

Disposition handling:

• Recognize: Emit the recognized route as session text, carrying target_coverage: Set(CoverageEntry) — each entry pairs a deficit with its protocol, plus the supporting evidence and reverse-evidence. The user may invoke any subset of coverage protocols; the constituted recognition record covers the entire coverage set.
• Redirect: Record the user-named deficit/protocol as the recognized route. AI does not contest user redirection.
• Dismiss: Emit a short fit-review note recording that none of the presented hypotheses fit. No protocol is recommended.
• Narrow scope — branches by argument type (distinct semantics):
  • Narrow(s: Slice): User restricts the situation scope (e.g., a specific decision, file, conversation slice). Rebind U.session_slice ← s, clear Λ.dismissed_in_session (new scope justifies fresh dismissals), and re-run Phase 1.
  • Narrow(s: CoverageSubset): User restricts the protocol set of the selected hypothesis without changing situation scope. Write Λ.coverage_constraint ← s, preserve Λ.dismissed_in_session (situation unchanged), and re-run Phase 1 — Scan filters output to hypotheses whose coverage protocols intersect s. Compound-filter exhaustion: if |H[]| < 2 cannot be satisfied after both Λ.coverage_constraint and Λ.dismissed_in_session filters apply, surface a fit-review note explaining the constraint combination and deactivate (explicit handling for the compound case; do not rely on the generic narrow_iterations ≥ 3 exhaustion path alone).
• Stop: Deactivate without disposition.

No cumulative score, grade, or ranking is produced or stored across uses.

── FLOW ──
Probe(U) → Detect(U) →
  named_deficit(U): skip → deactivate
  vague_deficit(U): Scan(U, Catalog, Λ.coverage_constraint) → H[] →           -- each h ∈ H[] carries Set(CoverageEntry), |coverage|≥1
    |H[]| < 2: enrich Scan or expand Catalog window → re-scan
    |H[]| ≥ 2: present(H[]) → Qc(H[]) → Stop → utterance → parse → R →
        Recognize(h):     emit(ProtocolRoute(h.coverage)) → converge            -- target_coverage = h.coverage : Set(CoverageEntry)
        Redirect(d):      emit(ProtocolRoute(d)) → converge
        Dismiss:          emit(FitReviewNote(no_fit)) → converge
        Narrow(s: Slice): rebind(U.session_slice, s) → clear(Λ.dismissed_in_session) → Phase 1
                          -- new situation scope justifies clearing dismissals
        Narrow(s: CoverageSubset): write(Λ.coverage_constraint, s) → Phase 1
                          -- coverage filter only; situation scope unchanged; dismissals preserved
        Stop:             deactivate

── MORPHISM ──
UserSituation
  → detect(vague_deficit)             -- recognize that a deficit is implied but not named
  → scan(situation, Catalog, Λ.coverage_constraint)
                                      -- enumerate candidate hypotheses as Set(CoverageEntry); set-valued coverage
                                      --   (multi-protocol projection within a hypothesis is structurally distinct
                                      --    from inter-protocol composition defined in the COMPOSITION block)
  → present(H[], multi_hypothesis)    -- surface offered as one horizon for the user's fusion (marked: low-confidence + per-entry reverse-evidence + transcendable); the user's recognition, not the surface, is constitutive
  → recognize(h, user)                -- user adopts h.coverage as a whole; refinable via Narrow(CoverageSubset)
  → emit(ProtocolRoute | FitReviewNote)   -- ProtocolRoute carries target_coverage as Set(CoverageEntry)
  → ProtocolRoute | FitReviewNote
requires: vague_deficit(U)             -- activation precondition: a detected vague deficit; on detection the surface may follow as a marked horizon (Rule 1), invoked or AI-initiated
deficit:  DeficitUnrecognized          -- activation precondition
preserves: Catalog                     -- catalog read-only; U is rebindable on Narrow
invariant: Recognition over Resolution

── TYPES ──
U                = UserSituation { utterance: String, session_slice: Optional(Slice) }
Catalog          = Set(DeficitEntry)               -- all named deficits + Emergent
DeficitEntry     = { deficit: DeficitName, protocol: ProtocolId,
                     trigger_signal: String, reverse_evidence_template: String }
Evidence         = String                           -- quoted or paraphrased situation evidence
CoverageEntry    = { deficit: DeficitName, protocol: ProtocolId,
                     evidence: Evidence, reverse_evidence: Evidence }
                   -- per-protocol unit; deficit label is co-located with its protocol (no top-level deficit set)
Hypothesis       = { coverage: Set(CoverageEntry) } -- |coverage| ≥ 1
                   -- |coverage|=1: singleton hypothesis (single-protocol projection)
                   -- |coverage|≥2: set-valued coverage (multi-protocol projection within one hypothesis)
H[]              = List(Hypothesis)                 -- |H[]| ≥ 2 invariant
Scan             = (UserSituation, Catalog, Optional(Set(ProtocolId))) → H[]
                   -- third argument is Λ.coverage_constraint; when set, output is filtered to hypotheses
                   --   whose coverage protocol set intersects with the constraint
CoverageSubset   = Set(ProtocolId)                  -- 0 < |CoverageSubset| < |selected.coverage|
                   -- non-empty proper subset of a selected hypothesis's coverage protocols
Qc               = present hypothesis set with evidence and reverse-evidence;
                   free-response Constitution interaction (Phase 3 parses utterance into R)
R                = Recognition ∈ {Recognize(Hypothesis),                  -- adopts entire coverage
                                  Redirect(DeficitName | ProtocolId),
                                  Dismiss,
                                  Narrow(Slice | CoverageSubset),         -- distinct semantics per variant; see FLOW
                                  Stop}
ProtocolRoute    = session text { target_coverage: Set(CoverageEntry) }    -- |target_coverage| ≥ 1
                   -- recognized_deficits = π_deficit(target_coverage); evidence_trace = π_evidence(target_coverage)
                   --   (derived projections, not separate fields)
FitReviewNote    = session text { presented_hypotheses, dismissed: true }
DeficitName      ∈ {BoundaryUndefined, ContextInsufficient, FrameworkAbsent,
                    MappingUncertain, AbstractionInProcess, AbstractAporia,
                    GapUnnoticed, GoalPlanUncompiled, ApplicationDecontextualized,
                    ContextSuspect, RecallAmbiguous,
                    RecallGranularityInsufficient, ResultUngrasped,
                    MethodUnderdetermined,
                    DirectionUnrecognizable, CandidateFieldUnderexpanded} ∪ Emergent
ProtocolId       ∈ {bound, inquire, frame, ground, induce, elicit, gap,
                    apportion, contextualize, sublate, recollect, ascend,
                    grasp, conduct, preview, ideate} ∪ Emergent
Phase            ∈ {0, 1, 2, 3}

── PHASE TRANSITIONS ──
Phase 0: U → Detect(U) → vague_deficit(U)?                          -- silent trigger detection
Phase 1: U → Scan(U, Catalog, Λ.coverage_constraint) → H[]          -- catalog scan; each h carries Set(CoverageEntry)
           Λ.coverage_constraint set → filter H[] to {h : π_protocol(h.coverage) ∩ Λ.coverage_constraint ≠ ∅}
           |H[]| < 2 → enrich(U) → Phase 1                          -- multi-hypothesis invariant
           |H[]| ≥ 2 → Phase 2
Phase 2: H[] → present(H[], evidence, reverse_evidence) → Qc(H[]) → Stop → utterance → parse → R   -- free-response Constitution interaction [Tool]
Phase 3: R → integrate(R, U) →
           Recognize(h)            → emit(ProtocolRoute(h.coverage)) → converge   -- target_coverage : Set(CoverageEntry)
           Redirect(d)             → emit(ProtocolRoute(d)) → converge            -- user-named alternative
           Dismiss                 → emit(FitReviewNote(no_fit)) → converge       -- no fit, recorded
           Narrow(s: Slice)        → rebind(U.session_slice, s) → clear(Λ.dismissed_in_session) → Phase 1
           Narrow(s: CoverageSubset) → write(Λ.coverage_constraint, s) → Phase 1  -- preserve dismissed_in_session
           Stop                    → deactivate                                    -- exit without disposition

── LOOP ──
Phase 1 → Phase 2 → Phase 3 →
  Recognize: converge
  Redirect: converge
  Dismiss: converge
  Narrow(Slice): rebind U to narrower scope → Phase 1
  Narrow(CoverageSubset): apply coverage filter → Phase 1
  Stop: deactivate
Max 3 narrowing iterations. Exhausted: surface candidate set as fit-review note → deactivate.
Convergence evidence: per disposition, emit one of {ProtocolRoute, FitReviewNote} or deactivate without artifact (Stop).

── CONVERGENCE ──
recognized = R ∈ {Recognize(h), Redirect(d), Dismiss}
exhausted  = narrow_iterations ≥ 3
session_text(probe) ∋ {ProtocolRoute | FitReviewNote} (Stop deactivates without artifact)

── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 Detect      (sense)    → Internal analysis (heuristic vague-deficit detection)
Phase 1 Scan        (sense)    → Internal analysis (catalog match against situation)
Phase 1 enrich      (sense)    → Internal analysis (situation broadening when |H[]| < 2)
Phase 2 Qc          (constitution)     → present (multi-hypothesis surface) + free-response receive (no typed option enumeration)
Phase 3 parse       (sense)        → Internal analysis (free-response utterance → R coproduct by semantic intent; bounded retry on ambiguous)
Phase 3 emit        (extension)    → TextPresent+Proceed (ProtocolRoute or FitReviewNote)
Phase 3 rebind      (track)    → Internal state update (Narrow(Slice) disposition — rebinds U.session_slice, clears Λ.dismissed_in_session)
Phase 3 write       (track)    → Internal state update (Narrow(CoverageSubset) disposition — sets Λ.coverage_constraint, preserves Λ.dismissed_in_session)
converge            (extension)    → TextPresent+Proceed (convergence trace)

── MODE STATE ──
Λ = { phase: Phase, U: UserSituation,
      hypotheses: List(Hypothesis), presented: Set(Hypothesis),
      dismissed_in_session: Set(Hypothesis),
      coverage_constraint: Optional(Set(ProtocolId)),   -- written by Narrow(CoverageSubset); consumed by Phase 1 Scan filter
      narrow_iterations: Nat,
      disposition: Optional(Recognition),
      active: Bool, cause_tag: String }

── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). Probe composes downstream into the recognized protocol when the user selects Recognize or Redirect — composition target is determined at runtime by user disposition.

Storage Reference

The hypomnesis sibling misfit.md sub-index (under {config_dir}/projects/{slug}/hypomnesis/{session-id}/) is the designed-for read location for accumulated probe usage records — fit-review notes, recognized routes, and dismissed hypotheses. Probe reads this sub-index when available to enrich situation context. {config_dir} is the Claude Code config directory — CLAUDE_CONFIG_DIR when set, else ~/.claude; a substrate detail of this realization, not protocol vocabulary. Read the value and substitute an absolute path before reading; a ${...} left in this text is inert, since Read/Grep perform no shell expansion. The writer mechanism is out of scope for this skill and is implemented separately at the substrate layer.

Rules

1. Horizon-marked surfacing (not invocation-gated) — Probe surfaces its hypotheses on explicit /probe invocation OR when the AI detects genuine deficit-ambiguity (Phase 0) and offers the surface as one horizon for the user's fusion of horizons. AI-initiated surfacing is licensed precisely by the marking already inscribed elsewhere — low-confidence dialogic form (Rule 11), per-entry reverse-evidence (Rule 5), free-response transcendence (Rule 8), and user-held disposition (Rule 6) — which together render the framing visible as framing, so a surfaced hypothesis cannot covertly install itself as the user's own fore-understanding. Still forbidden: unmarked surfacing (presenting the set as the settled deficit-space or the answer rather than a transcendable horizon), and sticky/background re-activation (Rule 2). The user's recognition stays the constitutive act; AI surfacing aids the fusion, it does not perform it.
2. No sticky mode — per-occasion surfacing — Probe has no persistent activation: no always-on background loop, no implicit carry-over re-activation across turns, no sticky session state. AI-initiated surfacing (Rule 1) fires per-occasion on a genuine ambiguity detected in the present turn and then rests; it is not a standing scanner. Each surfacing — invoked or AI-initiated — is a fresh, self-contained occasion.
3. Current-session default scope — Default evidence window is the present session. Cross-session evidence is opt-in only.
4. All-time scope requires explicit confirmation — Cross-session recall (reading prior misfit.md records or session history beyond the current session) requires an explicit Active-authority confirmation; never default behavior.
5. Multi-hypothesis required — Minimum two alternatives with distinct reverse-evidence conditions per hypothesis. Singleton high-confidence framing collapses Probe into Resolution; this is forbidden. Anti-singleton guard operates at hypothesis level (|H[]| ≥ 2). Each hypothesis carries set-valued coverage (|coverage| ≥ 1; |coverage| ≥ 2 represents intra-hypothesis multi-protocol projection — structurally distinct from inter-protocol composition defined in the ── COMPOSITION ── block). The reverse-evidence requirement applies per CoverageEntry within Hypothesis.coverage. Two-level cardinality: A single hypothesis with |coverage| = 2 does NOT satisfy this guard — |H[]| ≥ 2 requires at minimum two distinct Hypothesis records, each with its own coverage. The |H[]| ≥ 2 guard operates on hypothesis count; |coverage| ≥ 1 on per-hypothesis projection.

UX Safeguards

• Session immunity for dismissed hypotheses — A hypothesis dismissed in the current session is not re-presented in the same session unless the user explicitly re-probes the same scope. Re-presenting a dismissed hypothesis without user-driven re-scope erodes the user's disposition authority (Rule 6 reinforcement). Realized via Λ.dismissed_in_session: Phase 3 Dismiss adds presented hypotheses to this set; Phase 1 Scan filters out members of this set. Clearing rules: Narrow(Slice) clears the set (new situation scope justifies fresh dismissals); Narrow(CoverageSubset) preserves the set (situation unchanged, only coverage filter applied).
• Progress opacity — No progress counter, no "X of Y hypotheses considered" framing. Such counters reintroduce a quasi-score (Rule 7 reinforcement).
• Ephemeral recognition — Each probe disposition is a present-tense fit review, not a permanent record. The user's disposition does not bind future probes (Rule 7 reinforcement).
• Pre-gate evidence visibility — All hypothesis evidence and reverse-evidence is laid out before the disposition gate so the user reads context before deciding (evidence stays out of the disposition question itself; structural).
• Vocabulary discipline — Probe output uses "hypothesis", "fit review", "evidence", "reverse-evidence", "disposition", "route". The skill never speaks of mistakes, errors, or misuse (Rule 9 + Rule 10 reinforcement).

Trigger Signals

Invoke /probe when:

• The user describes symptoms but cannot name a single protocol that fits
• The user is about to invoke a protocol but expresses uncertainty between two or more candidates
• The user asks "which one fits this?" without providing a specific deficit name
• The user wants a fit review before committing to a protocol invocation

Skip Conditions

Skip Probe when:

• The user has already named the deficit with confidence
• The user requests a passive handbook reference (/catalog)
• The user requests pattern-based recommendation from session history (/onboard)
• The user requests accumulated analytics (/report, /dashboard)