Probe

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 pattern-based recommendation from session history with optional trial (use /onboard)

Distinction from /onboard

The two coexist by design — neither replaces the other. Probe is for experienced users with frame-binding uncertainty; /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).

Intent-decoding disambiguation (Rule 18): Before defaulting a candidate to a missing-information framing (e.g., ContextInsufficient//inquire), check Euporia's own deficit (aporia, euporia/skills/elicit/SKILL.md): the user holds a direction but has not fixed which decisions it turns on. The undetermined decision may show in the user's own utterance, in evidence within Probe's scope — 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) — or in the decision structure of the domain the intent sits in. When it holds, include AbstractAporia (/elicit) in the candidate set — a decision the user has not named is intent-decoding, not external-fact supply, and belongs to /elicit rather than /inquire. A missing fact the work needs, with the intent itself settled, still routes to /inquire.

Single-pass routing scope: Phase 1 enumerates named deficits across the catalog as a one-shot fit review. Per-protocol convergence dynamics — including the rounds within a protocol such as /elicit — remain internal to that destination protocol; Probe does not surface, measure, or aggregate convergence efficiency across uses (Rule 7 reinforcement; how rounds are shown is the destination protocol's 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,
                    MappingUncertain, AbstractionInProcess, AbstractAporia,
                    GoalPlanUncompiled, ApplicationDecontextualized,
                    ContextSuspect, RecallAmbiguous, TargetUngrasped,
                    MethodUnderdetermined,
                    DirectionUnrecognizable, CandidateFieldUnderexpanded,
                    FitUnrecognized} ∪ Emergent
ProtocolId       ∈ {bound, inquire, ground, induce, elicit,
                    apportion, contextualize, sublate, recollect,
                    grasp, conduct, preview, ideate, sketch} ∪ 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.