misuse

name	misuse
description	Retrospective protocol contract violation detector. Scan past sessions for /ground (Sₐ confabulation) and /induce (stereotype misconflation) contract violations and surface structured violation records for user-constituted review. Use this skill whenever the user asks to 'audit my misuse', 'check protocol misuse', 'scan past invocations', 'misuse history', wants retrospective audit of past /ground or /induce calls, or suspects silent contract violations in prior sessions.
user_invocable	true

Misuse Skill

Retrospective Contract Violation Detector — when the user wants to audit past /ground and /induce invocations for silent contract violations, scan session history against contract integrity criteria and surface candidate violations for user-constituted review. Type: (ContractIntegrityOpaque, AI, AUDIT, SessionHistory) → ViolationReview.

Invoke directly with /misuse when the user wants a retrospective audit of past protocol invocations against their declared Phase 0 contracts.

Definition

Misuse (ἔλεγχος, élenchos: examination by drawing out, Socratic refutation): A dialogical act of resolving the opacity of past protocol contract integrity into a recognized violation history, where AI scans session JSONL for /ground and /induce invocations, classifies each against the contract criteria in references/violation-taxonomy.md (LEGITIMATE / VIOLATION / AMBIGUOUS), and the user constitutes the verdict via per-invocation recognition — never AI-resolved verdict assertion.

This skill stands in time-axis dual relationship to /probe. Probe is prospective: when a deficit is unrecognized at the present moment, surface candidate hypotheses with reverse-evidence so the user routes forward. Misuse is retrospective: when contract integrity in past invocations is opaque, surface candidate violations with operational evidence so the user audits backward. Both refuse AI-side resolution; both treat user recognition as the constitutive act.

Phase 4 recognition is structurally homologous to Anamnesis Phase 2 — past-identity synthesis (verifying whether a past act conformed to its contract), not future-trajectory selection. The Differential Future Requirement does not apply: a 1-correct option structure (was-violation / was-legitimate) is legitimate by purpose, not a degradation.

When to Use

Invoke this skill when:

• The user suspects past /ground or /induce invocations may have violated contract integrity
• The user wants to audit a recent session or set of sessions for silent Sₐ confabulation or stereotype misconflation
• The user wants empirical evidence about misuse patterns to inform calibration of future live nudges or contract refinement

Skip when:

• The deficit is forward-looking (use /probe for prospective deficit recognition)
• The user wants accumulated session analytics without contract-violation focus (use /report or /dashboard)
• The user wants strength-shadow analysis of behavioral patterns (use /curses)
• The user is asking about a present-moment invocation, not past invocations

Distinction from Adjacent Skills

Skill	Time axis	Subject	Output
/probe	Prospective (present situation)	Deficit recognition fit review	ProtocolRoute or FitReviewNote
/misuse	Retrospective (past invocations)	Contract integrity audit	ViolationReview (per-invocation verdict)
/sophia	Retrospective (behavioral patterns)	Philosophical tradition match	Philosopher profile
/curses	Retrospective (strengths)	Strength-shadow extraction	Shadow-cost analysis
/report	Retrospective (usage)	Growth Map	Aggregated insight integration
/dashboard	Retrospective (coverage)	Protocol coverage analytics	Coverage statistics

The skill family coexists by phenomenology — none replaces the others. Misuse is for contract integrity; the other retrospective skills serve user-pattern questions.

Protocol

Phase 0: Scope Determination

Resolve the audit scope before scanning. Decisions:

• Target protocols — fixed at /ground and /induce for v1.0. Other protocols deferred pending accumulated use evidence.
• Session window — default is the current session only. Cross-session scanning requires explicit user confirmation per Rule 4.
• Cross-project scope — default off. Scanning across ~/.claude/projects/ requires explicit user confirmation.

Resolve scope from the invocation argument; if none is given, apply the safe default — current session only, cross-project off. This default scope is read-only and privacy-local (/misuse preserves SessionHistory, Rule 6), and its selection is deterministic and citable (the safe default), so it is a relay (Extension): surface the inferred scope to the user and proceed directly to Phase 1, without a scope-authorization gate. The Constitution interaction is retained only for the cross-session / cross-project expansion — the privacy-sensitive widening the user opts into. When the resolved scope is an expansion (cross-session or cross-project), present the widening for constitutive authorization before scanning; if the user declines, fall back to the safe default scope. This mirrors /probe's Phase 0 — silent on the current-session default (its Rule 3), explicit confirmation only on cross-session expansion (its Rule 4).

Phase 0 is otherwise silent — no surfacing of detection heuristics. If the user has no past /ground or /induce invocations in the chosen scope, deactivate with a brief no-op note (Phase 1 will be empty).

Phase 1: Invocation Extraction

Delegate to the epistemic-cooperative:session-analyzer subagent in friction-pointers mode to extract /ground and /induce slash command invocations from session JSONL files within the chosen scope. For each invocation, retrieve:

• The invocation turn (slash command line)
• 10–20 turns of preceding user messages (pre-invocation context window)
• The assistant turn(s) immediately following the invocation (Phase 0 output of the invoked protocol)

Optional auxiliary read: the ~/.claude/projects/{slug}/hypomnesis/{session-id}/misfit.md file if present and the user has consented to cross-session scope. This is opt-in evidence enrichment, not a primary data source.

Construct the candidate set I[] of {invocation, pre_context, post_output} triples.

If |I[]| = 0, deactivate with no-op note.

Phase 2: Per-Invocation Classification

Read references/violation-taxonomy.md to load the contract integrity criteria. For each invocation in I[]:

1. Surface shape match — does the invocation pattern superficially resemble a violation type (e.g., /ground with multiple instances and no apparent abstract structure)?
2. Operation-kind verification — examine the cognitive operation actually performed against the protocol's declared operation. Surface match alone is insufficient (Rule 1).
3. Classification — assign one of:
   • LEGITIMATE — contract integrity verified by evidence
   • VIOLATION — contract violated; specify violation type (Sₐ confabulation, stereotype misconflation) and cite textual evidence
   • AMBIGUOUS — surface match but operation-kind verification produces uncertain result; defaults toward AMBIGUOUS, not VIOLATION (Rule 2)

Each classification must cite specific turn evidence — the user message demonstrating absent framework prior to /ground, or the AI binding of Sₐ without prior user framework, or the named-candidate comparison pattern preceding /induce.

Phase 3: Pattern Aggregation

Cluster classifications across I[]:

• Group by violation type (Sₐ confabulation cluster, stereotype misconflation cluster)
• Identify recurring contexts (project, time period, situation shape)
• Rank candidates by evidential strength (clearest evidence first)
• Suppress AMBIGUOUS classifications from primary presentation; surface them only on user request after VIOLATION review completes

Construct presentation order: highest-evidence VIOLATION candidate first, then descending evidential strength.

Phase 3 produces no cumulative score or rate. No "user reliability index", no "violation percentage", no "trustworthiness metric" (Rule 6).

Phase 4: Per-Invocation Recognition

Present the highest-priority VIOLATION candidate for user-constituted recognition. Format per candidate:

Candidate N — [VIOLATION_TYPE]
  Session: <session_id>, turn <turn_index>
  Invocation: /ground or /induce, with original argument
  Pre-context (10-20 turns): <quoted excerpt or paraphrase showing absence of required framework / presence of named-candidate comparison>
  Phase 0 output: <quoted AI response showing Sₐ binding or stereotype acceptance>
  Violation criterion: <specific clause from violation-taxonomy.md that this invocation contradicts>

Then present the recognition Constitution interaction:

Did this past invocation violate its contract?

Options:
1. Recognize — violation confirmed (the cited evidence is correctly read)
2. Dismiss — legitimate invocation (the framework was implicit, the context was elsewhere, the cited evidence is misread)
3. Reorient — different violation kind than presented (re-classify against taxonomy)
4. Stop — exit /misuse without further candidates

The verdict belongs to the user. AI never asserts violation unilaterally. After response:

• Recognize — record the candidate as confirmed violation, proceed to next candidate or converge
• Dismiss — record the candidate as user-dismissed legitimate, proceed to next candidate
• Reorient — re-classify the candidate; if a different violation type matches, present anew; otherwise dismiss
• Stop — deactivate, emit confirmed violations to date

Loop Phase 4 over I[] until exhausted, user Stops, or 10 candidates reviewed (whichever first; see Rule 7).

Phase 5: Emit

After Phase 4 loop completes, emit a ViolationReview artifact to session text. Format:

## Misuse Audit — [scope description]

Confirmed violations: <count>
Dismissed candidates: <count>
Stopped at: <user disposition or exhaustion>

### Confirmed violations

For each: session_id + turn_index + violation_type + brief evidence summary.

### Calibration metadata (for future Output Style nudge layer)

For each violation type: pre-invocation linguistic patterns observed,
operation-kind verification trace.

The artifact is observation-only. No automated rewrite, no automated reroute (Rule 6). Calibration metadata is the sole structured output beyond the verdicts themselves; downstream live-nudge design is a separate task with its own evidence threshold.

── FLOW ──
Misuse(arg) → Phase0: scope_resolve(arg) → s →
  default_scope(s): relay(surface s) → proceed                       -- Extension; safe read-only default, no gate
  expansion(s):     present(widening) → Stop → R_scope →             -- Constitution privacy authorization [Tool]
                      authorize: proceed with s
                      decline:   s ← safe_default → proceed
  empty(s): deactivate(no-op note)
  scoped(s): Extract(s) → I[] →
    |I[]| = 0: deactivate(no-op note)
    |I[]| > 0: Classify(I[], Taxonomy) → C[] →
      Aggregate(C[]) → ranked(V[]) →
      Loop over V[]:
        present(v, evidence) → Qc(v) → Stop → R →
          Recognize(v): record_confirmed(v) → next
          Dismiss(v): record_dismissed(v) → next
          Reorient(v): reclassify(v) → present anew | dismiss
          Stop: break loop
        |reviewed| ≥ 10: break loop (max review threshold)
      reviewed > 0: emit(ViolationReview) → converge
      reviewed = 0: deactivate(no-op note)

── MORPHISM ──
SessionHistory
  → scope(audit_window)                  -- default_scope relayed (current-session); expansion user-confirmed
  → extract(invocations)                 -- /ground and /induce slash command extraction
  → classify(invocation, taxonomy)       -- per-invocation contract integrity check
  → aggregate(classifications)           -- cluster + rank
  → present(candidate, Constitution)     -- per-invocation recognition Constitution interaction
  → recognize(verdict, user)             -- user-constituted verdict (synthesis of identification)
  → emit(ViolationReview)                -- session-text artifact
  → ViolationReview
requires: contract_integrity_opaque(scope)  -- activation precondition (user-invoked)
deficit:  ContractIntegrityOpaque             -- activation precondition
preserves: SessionHistory                     -- read-only audit; no mutation
invariant: Recognition over Verdict-Assertion

── TYPES ──
Scope            = { protocols: Set(ProtocolId), session_window: SessionWindow,
                     cross_project: Bool }
SessionWindow    ∈ {current_session, named_session, time_range, all_sessions}
default_scope    = (s: Scope) ⊢ s.session_window = current_session ∧ ¬s.cross_project
                   -- safe, read-only, privacy-local default; relay-eligible (Extension)
safe_default     = { protocols: {ground, induce}, session_window: current_session, cross_project: false }
                   -- the canonical Scope satisfying default_scope(·); Phase 0 decline-fallback value
expansion        = (s: Scope) ⊢ ¬default_scope(s)
                   -- cross-session ∨ cross-project widening; privacy-sensitive (Constitution gate)
R_scope          = ScopeAuth ∈ {authorize, decline}   -- Phase 0 expansion-gate disposition (Constitution); decline falls back to safe_default
Invocation       = { protocol: ProtocolId, session_id: SessionId,
                     turn_index: Int, argument: String }
Triple           = { invocation: Invocation, pre_context: List(Turn),
                     post_output: List(Turn) }
I[]              = List(Triple)                  -- candidate set
Taxonomy         = ViolationTaxonomy             -- loaded from references/violation-taxonomy.md
ViolationType    ∈ {SaConfabulation, StereotypeMisconflation, FrameOverextension, Emergent}
Classification   = LEGITIMATE | VIOLATION(ViolationType, Evidence) | AMBIGUOUS(Reason)
Evidence         = { pre_context_quote: String, post_output_quote: String,
                     criterion_cited: String }
C[]              = List({Triple, Classification})
V[]              = List({Triple, ViolationType, Evidence})  -- ranked VIOLATION subset
R                = Verdict ∈ {Recognize, Dismiss, Reorient, Stop}
ViolationReview  = session text { confirmed: List(Triple+Type+Evidence),
                                  dismissed: List(Triple),
                                  calibration_metadata: Prose }
ProtocolId       ∈ {ground, induce}              -- v1.0 scope
SessionId        = String (UUID)
Turn             = { role, content, timestamp }
Phase            ∈ {0, 1, 2, 3, 4, 5}

── PHASE TRANSITIONS ──
Phase 0: arg → scope_resolve(arg) → s : Scope
           default_scope(s) → relay(surface s) → Phase 1               -- Extension; no gate (safe read-only default)
           expansion(s)     → present(widening) → Stop → R_scope → Phase 1   -- Constitution privacy authorization [Tool]
                                authorize → scan s ; decline → s ← safe_default
Phase 1: scope → session-analyzer(friction_pointers) → I[]        -- subagent extraction [Tool]
           |I[]| = 0 → emit(no-op note) → deactivate
           |I[]| > 0 → Phase 2
Phase 2: I[] → Read(references/violation-taxonomy.md) → Classify(I[], Taxonomy) → C[]   -- per-invocation classification
Phase 3: C[] → Aggregate(C[]) → V[] (ranked VIOLATION subset)     -- pattern clustering
Phase 4: V[] → for each v: present(v, evidence) → Qc(v) → Stop → R   -- per-invocation Constitution interaction [Tool]
           Recognize(v) → record_confirmed(v) → next | exhaust
           Dismiss(v) → record_dismissed(v) → next | exhaust
           Reorient(v) → reclassify(v) → present anew | dismiss
           Stop → break loop
           |reviewed| ≥ 10 → break loop
Phase 5: emit(ViolationReview) → converge                         -- artifact emission [Tool]

── LOOP ──
Phase 4 internal loop: present → Qc → record → next, bounded by min(|V[]|, 10).
Reorient sub-loop: re-classify → present anew → Qc; bounded by 1 reclassification per candidate (no cycles).

Convergence evidence: ViolationReview emitted with confirmed/dismissed counts and calibration metadata; Stop deactivates without partial artifact when no candidate was reviewed.

── CONVERGENCE ──
reviewed = |confirmed| + |dismissed|
converged = (reviewed > 0 ∧ user_stop_or_exhaust) ∨ |I[]| = 0
session_text(misuse) ∋ ViolationReview when reviewed > 0; empty no-op note when |I[]| = 0

── TOOL GROUNDING ──
-- Realization: Constitution → TextPresent+Stop; Extension → TextPresent+Proceed
Phase 0 scope_resolve        (sense)        → Internal analysis (resolve Scope from invocation arg; if none, apply default current_session ∧ ¬cross_project)
Phase 0 scope_from_arg       (extension)    → TextPresent+Proceed (user-specified default_scope arg: current_session ∧ ¬cross_project; bind scope, relay)
Phase 0 scope_default_relay  (extension)    → TextPresent+Proceed (scope unspecified → safe default current_session ∧ ¬cross_project; surface inferred scope, relay)
Phase 0 scope_expand_confirm (constitution) → present (resolved scope is expansion(s): cross-session ∨ cross-project widening, whether arg-hinted or user-requested; constitutive privacy authorization; decline → fall back to safe_default)
-- Phase 0 relay basis: default_scope(s) is read-only and privacy-local (SessionHistory preserved, Rule 6); its resolution is deterministic and citable (the safe default), so it is relay-eligible (Extension) per the A5 option-set relay test and the project Extension-default profile. The (constitution) gate is retained only for the privacy-sensitive cross-session / cross-project widening, where the user constitutes authorization to read beyond the current session.
Phase 1 extract        (extension)     → Agent(epistemic-cooperative:session-analyzer, mode=friction_pointers)
Phase 1 read_misfit    (extension)     → Read (~/.claude/projects/{slug}/hypomnesis/{session-id}/misfit.md, opt-in)
Phase 2 read_taxonomy  (extension)     → Read (references/violation-taxonomy.md)
Phase 2 classify       (sense)         → Internal analysis (per-invocation 2-step check)
Phase 3 aggregate      (sense)         → Internal analysis (clustering + ranking)
Phase 4 Qc             (constitution)  → present (per-invocation recognition Constitution interaction; constitutive user verdict)
Phase 5 emit           (extension)     → TextPresent+Proceed (ViolationReview)
converge               (extension)     → TextPresent+Proceed (convergence trace)

── MODE STATE ──
Λ = { phase: Phase, scope: Scope,
      candidates: List(Triple), classifications: List(Classification),
      ranked_violations: List(V),
      confirmed: List(Triple+Type+Evidence),
      dismissed: List(Triple),
      reviewed_count: Nat,
      active: Bool, cause_tag: String }

── COMPOSITION ──
*: product — (D₁ × D₂) → (R₁ × R₂). Misuse composes downstream when the user wants to act on confirmed violations (e.g., re-invoke /induce on a Sₐ-confabulation case). Composition target is determined at runtime by user disposition outside this skill (Rule 6 forbids automated reroute), not by statically registered dependency edges.

Storage Reference

The ~/.claude/projects/{slug}/hypomnesis/{session-id}/misfit.md file (written by /probe sessions) is opt-in auxiliary read input for Phase 1 evidence enrichment. Misuse does not write to this location. Default scope reads only the current session; cross-session reads require explicit user confirmation in Phase 0.

Rules

1. Operation-grounded classification — Surface shape (e.g., "N instances + slash command") is necessary but not sufficient for VIOLATION classification. The cognitive operation actually performed must be examined against the protocol's declared operation. Protocols are defined by cognitive operation, not by input shape (instance count is evidence, not gate).
2. Self-stereotype guard — The classifier itself must not commit the same stereotype error it detects. Apply 2-step check (surface match → operation verification). On uncertain operation verification, classify as AMBIGUOUS, not VIOLATION. False-positive cost (eroded protocol use) exceeds false-negative cost (missed violation surfaced later).
3. Recognition is verification, not decision-axis — Phase 4 Qc is structurally homologous to Anamnesis Phase 2 recognition gates: past-identity synthesis, not future-trajectory selection. The Differential Future Requirement (which mandates differential downstream trajectories among gate options) does not apply to verification gates whose option structure is determined by verification task requirements. A 1-correct option structure (was-violation / was-legitimate) is legitimate by purpose.
4. Cross-session opt-in, default off; safe-default relay — The current-session, cross-project-off default is a read-only, privacy-local scope; when scope is unspecified (or specified as this default), Phase 0 surfaces the inferred scope and proceeds (relay/Extension) — no scope-authorization gate fires on the safe default. Reading other sessions or other projects — the cross-session / cross-project expansion — requires explicit user confirmation in Phase 0 (the retained Constitution gate); a declined expansion falls back to the safe default. This mirrors /probe's Phase 0 (silent on the current-session default per its Rule 3, explicit confirmation on cross-session expansion per its Rule 4) and applies to both session JSONL reads and misfit.md reads.
5. Extension / Constitution vocabulary — Classification descriptions use the Cognitive Partnership Move vocabulary: Extension (relay-mode, citable basis, deterministic) and Constitution (gated-mode, AI-inference basis, multiple valid results). Older relay/gated phrasing is replaced by the current vocabulary throughout output.
6. Observation-only artifact — Misuse never auto-rewrites past sessions, never auto-reroutes a past invocation to a different protocol, never produces a corrective action. Calibration metadata in Phase 5 is for future live-nudge design, not for present action.
7. Bounded review depth — Phase 4 loop terminates at min(|V[]|, 10) candidates per session of /misuse. Audit fatigue erodes verdict quality; bounded review preserves recognition fidelity. The user can re-invoke /misuse for additional candidates.
8. No cumulative score / rate / index — Across uses, no "violation rate", "user reliability index", "protocol fidelity score", or aggregated metric is produced or stored. Each audit is independent. Aggregation at the cumulative-rate level reintroduces the corrective-judge framing that Rule 6 (observation-only artifact) and Rule 10 (audit-vocabulary) jointly reject.
9. Verdict belongs to the user — Recognize / Dismiss / Reorient / Stop is a constitutive user act. AI presents evidence and cited criterion; AI never resolves the verdict unilaterally.
10. Recommended vocabulary — Use "violation review", "contract integrity audit", "candidate violation", "evidence", "criterion cited". Vocabulary that frames the skill as a corrective judge (e.g., "wrong", "should have used", "user error") is replaced by the audit-and-fit-review vocabulary.
11. Recognition over Recall — Each Phase 4 candidate presents structured evidence (pre-context, post-output, cited criterion) so the user recognizes the violation pattern from presented context, not from memory of the past session.
12. Detection with Authority — AI detects candidate violations with cited textual evidence; the user constitutes the verdict. AI never asserts violation unilaterally (Rule 9 reinforcement at the architectural level).
13. Context-Question Separation — All evidence (pre-context, post-output, cited criterion) is presented as text output before the Phase 4 Constitution interaction. The interaction contains only the verdict options.
14. Convergence evidence — Phase 5 emit produces a transformation trace (scope → extracted invocations → classified candidates → user verdicts → confirmed violations) before declaring convergence.

UX Safeguards

• Session immunity for dismissed candidates — A candidate dismissed in the current /misuse session is not re-presented in the same session unless the user re-invokes /misuse with explicitly different scope. Re-presenting dismissed candidates erodes the user's verdict authority (Rule 9 reinforcement).
• Progress opacity — No progress counter framed as "X of Y violations confirmed" or similar. Presence of such a counter reintroduces the verdict-rate framing that Rule 8 forbids. The Phase 4 loop tracks reviewed-count internally for Rule 7 termination, but does not surface it as a quasi-score.
• Ephemeral verdicts — Each /misuse audit is a present-tense fit review of past invocations. Verdicts produced in one audit do not bind future audits — the user can re-invoke and reach a different verdict on the same candidate if context shifts.
• Pre-gate evidence visibility — All evidence is laid out before the verdict Constitution interaction. The user reads context before deciding (Rule 13 reinforcement; structural).
• AMBIGUOUS as default tie-break — When operation verification is uncertain, classify AMBIGUOUS, not VIOLATION. Surface AMBIGUOUS candidates only on user request after primary VIOLATION review (Rule 2 reinforcement).
• Vocabulary discipline — Output uses "candidate violation", "audit", "fit review", "evidence", "criterion", "verdict". Output never frames past invocations as mistakes, errors, or culpable acts (Rule 10 reinforcement).

Trigger Signals

Invoke /misuse when:

• The user asks to audit past /ground or /induce invocations for misuse
• The user suspects silent contract violations in past sessions
• The user wants empirical evidence about misuse patterns to inform future calibration
• The user explicitly invokes /misuse

Skip Conditions

Skip Misuse when:

• The user is asking about a forward-looking deficit (use /probe)
• The user wants accumulated session analytics without contract focus (use /report or /dashboard)
• The user wants strength-shadow analysis (use /curses)
• The user is asking about a present-moment invocation, not past invocations
• The chosen scope contains no /ground or /induce invocations (Phase 1 will deactivate gracefully)