--- name: Onboard slug: onboard-3 category: AI Engineering description: Onboard recommends an epistemic protocol from recent sessions, then can guide the user through scenario, trial, and quiz. Use it for new-user onboarding, re-onboarding, or protocol discovery. github: "https://github.com/jongwony/epistemic-protocols/tree/main/epistemic-cooperative/skills/onboard" language: JavaScript stars: 161 forks: 15 install: "npx degit https://github.com/jongwony/epistemic-protocols/tree/main/epistemic-cooperative/skills/onboard ~/.claude/skills/onboard" installs_to: ~/.claude/skills/onboard source_path: epistemic-cooperative/skills/onboard/SKILL.md collection_size: 25 category_size: 3670 collection_url: "https://dirskills.com/collections/jongwony/epistemic-protocols" added: 2026-09-08T05:36:05.700Z last_synced: 2026-09-08T05:36:05.700Z canonical_url: "https://dirskills.com/skills/onboard-3" --- # Onboard Onboard recommends an epistemic protocol from recent sessions, then can guide the user through scenario, trial, and quiz. Use it for new-user onboarding, re-onboarding, or protocol discovery. **Install:** ```bash npx degit https://github.com/jongwony/epistemic-protocols/tree/main/epistemic-cooperative/skills/onboard ~/.claude/skills/onboard ``` ## README # Onboard Skill Start with a quick recommendation based on recent sessions, then optionally continue to guided learning — so users experience value first, learn second. Invoke directly with `/onboard` when the user wants onboarding or protocol discovery. ## When to Use Invoke this skill when: - A new user wants to discover which epistemic protocols fit their workflow - A user wants to experience protocols through guided practice - Re-onboarding after new protocols are added or workflow changes Skip when: - User already knows which protocol to use (direct invocation) - Quick single-protocol question (answer directly) ## Workflow Overview ``` Quick Proof: ENTRY → QUICKSCAN → PICK-1 → EVIDENCE → TRIAL → INSIGHT → NEXT Targeted: ENTRY → QUICKSCAN → MAP → SCENARIO → TRIAL → QUIZ → GUIDE Targeted + std: ENTRY → SCENARIO → TRIAL → QUIZ → GUIDE ``` | Phase | Owner | Tool | Purpose | |-------|-------|------|---------| | 0. Entry | Main | Gate | Path selection: quick/targeted | | 1. Quick Scan | Main | Glob, Read | User Context Profile extraction | | 2a. Pick-1 | Main | — | Quick path: select 1 recommendation | | 2b. Evidence | Main | — | Quick path: show 1 evidence card | | 2. Map | Main | — | Targeted path: Profile → Protocol matching | | 3. Scenario | Main | Gate | Targeted path: context-personalized intervention point | | 4. Trial | Main | Gate | Real protocol execution (quick: mini trial, targeted: full trial) | | 4→Q. Insight | Main | — | Quick path: post-trial insight card | | 4→Q. Next | Main | Gate | Quick path: simplified navigation | | 4→5 LOOP | Main | Gate | Targeted path: post-trial navigation | | 5. Quiz | Main | Gate | Targeted path: Socratic protocol recognition quiz | | 6. Guide | Main | Gate | Targeted path: summary + next protocol suggestion | ## Data Sources Compact mapping for inline use. | Protocol | Cluster | When to Use | Key Patterns | |----------|---------|-------------|-------------| | Aitesis `/inquire` | Planning | AI is about to answer without enough observable context | External fact queries, verifiable grounding (for prior-session recall → use `/recollect`) | | Euporia `/elicit` | Planning | Intent articulated but axis-undetermined; decision coordinates implicit in codebase / rules / past sessions | Multi-axis intent without single axis-specific protocol fit; substrate-implicit coordinates surface through cycle-emergent dimensions | | Heuresis `/ideate` | Planning | Object-level candidate field is empty or has prematurely converged — widen it before any selection is made | Zero entry questions (seed vs. blank inferred from the utterance), frame-first mode on a blank entry, no elimination or ranking during generation, every candidate tagged `origin ∈ {User, AI}` | | Proplasma `/preview` | Planning | Right before a direction commitment when the candidates cannot be judged from descriptions — contrast cheap discard-committed placeholder probes on user-settled axes | Principle-delegation at direction gates ("go with the recommended direction"), option-set reconstruction instead of choosing, "I'd have to see it" decision stalls | | Hypotyposis `/sketch` | Planning | A form has to be made, intent cannot yet be settled from descriptions, and the user would recognize it on sight — sketch under a settled focus, take marks on a specific version, revise the retained version, finish on the recognized one | "I'd know it when I see it", a plan stalled at its first draft, a description rewritten repeatedly instead of made | | Prothesis `/frame` | Analysis | Unsure which analytical perspective to use | Exploration ratio 3:1+ (Read+Grep+Glob vs Edit+Write) | | Analogia `/ground` | Analysis | Checking if abstract advice fits your situation | Abstract pattern application without domain validation | | Periagoge `/induce` | Analysis | Concrete cases accumulating into an unnamed essence — crystallize the emerging abstraction | 3+ instances with essence intuition but no located abstraction; `/ground` misfit where colimit is forced into substitution | | Merismos `/apportion` | Execution | An autonomous goal is stated but its unit plan is uncompiled — cut it into coarse units at cited seams and close each unit before the run begins — a derived completion condition where one compiles, a recorded acceptance or a recorded reservation where none does | An unattended-run directive ("work through", "go through all", "run until done"), a goal that plainly exceeds one execution horizon, or a stop-hook being configured — each only shows an autonomous interval is *intended*, so the deciding check is whether the goal already carries units whose completion conditions are settled — closed by a determinate predicate, by a recorded acceptance, or by a recorded reservation; a plan that does is out of scope | | Epharmoge `/contextualize` | Verification | Output is correct but doesn't fit the accumulated conversation context | Mismatch against session-built constraints (user-aware context accumulation) | | Elenchus `/sublate` | Verification | About to externalize a working context whose apparent sufficiency has decayed | Dialectical antithesis per claim under test (provenance / counterfactual / cross-source consistency) before pre-execution sync | | Horismos `/bound` | Cross-cutting | Deciding what to delegate to AI | Boundary probe, domain classification, BoundaryMap | | Anamnesis `/recollect` | Cross-cutting | Resolving vague recall of prior sessions or discussions — one session, or a line of work, topic, or settled concept spread across several | Cross-session state recovery via narrative recognition (Recognition over Retrieval); a unit above one session is composed from its deposits at read time | | Katalepsis `/grasp` | Cross-cutting | Rapid comprehension verification via intent-scented entry points | User-intent grasp for a target present in context and quotable, whoever produced it — reviews, plans, papers, docs, or code changes | | Hyphegesis `/conduct` | Cross-cutting | Conducting the method of a multi-move work prospect before object-level cognition — order, independence, reconciliation, termination, routing | Multi-move work with non-trivial conduct (migrations, staged investigations, entangled adversarial/parallel/synthesis); "how should I approach this whole thing?" meta-questions | ## Phase Execution Paths below written `{config_dir}/…` take `{config_dir}` = `CLAUDE_CONFIG_DIR` when set, else `~/.claude`. Resolve it ONCE per invocation with Bash `printf '%s\n' "${CLAUDE_CONFIG_DIR-$HOME/.claude}"` and substitute the absolute result before any Read/Glob/Grep call. ### Phase 0: Entry (Path Selection) Begin with a concise welcome and path selection, reserving the full catalog for the Browse-all path. **Gate #1**: - Text: Path selection prompt - Options: - Quick recommendation (Recommended) - Learn a specific protocol - Browse all protocols **If Quick recommendation**: set `path = quick`, proceed to Phase 1. **If Browse all**: Present the protocol catalog (check installation status via Glob `{config_dir}/plugins/cache/epistemic-protocols/*/`, then render all core protocols from Data Sources as a numbered list grouped by Cluster with name + "When to Use" + installation badge). After catalog, present: - Text: Post-catalog path selection - Options: - Quick recommendation - Learn a specific protocol (type name in Other) Then proceed based on selection. **If Targeted + Other contains protocol name**: proceed directly to session source question. **If Targeted + no protocol specified**: Present a condensed catalog as text output: render the Data Sources table grouped by Cluster, each protocol as `/command — When to Use description`. Then **Gate #2**: - Text: Protocol selection (type name or number in Other) - Options: - Pre-execution (Planning) — /bound, /inquire, /elicit, /ideate, /preview, /sketch - Analysis — /frame, /ground, /induce - Execution/Verification/Understanding — /apportion, /contextualize, /sublate, /recollect, /conduct, /grasp **Gate #3** (Targeted only, session source): - Text: Session source selection - Options: - Personalize with my recent sessions - Use standard examples (no session needed) State after Phase 0: - `path`: quick | targeted - `target_protocol`: (targeted only) selected protocol name - `session_source`: (targeted only) scan | standard — Quick path always runs Quick Scan **Skip rule**: If targeted + standard → skip Phases 1-2, jump to Phase 3 with preset scenarios from `references/scenarios.md`. ### Phase 1: Quick Scan (User Context Profile) — Inline Build a User Context Profile from recent session metadata. Runs inline with Glob + Read (no subagent delegation). Both Quick and Targeted paths share this phase. **Step 1: Collect session metadata** Glob `{config_dir}/projects/*/sessions-index.json` (exclude directories containing `-worktrees-`). Read the 2-3 most recently modified indexes. For each, parse `entries` and extract the 5 most recent entries' `firstPrompt` and `summary` fields. **Step 2: Infer User Context Profile** From collected metadata, infer: - **Work domains**: What areas the user works in (e.g., API development, infrastructure, data pipeline) - **Conversation patterns**: Request clarity level, incremental vs. batch requests, question types (how/why/what) - **Task types**: Ratio of feature development, debugging, refactoring, documentation If no `sessions-index.json` files found: Quick path proceeds to Pick-1 with fallback (`/elicit`); Targeted path falls back to Onboarding Pool (`/elicit`, `/inquire`, `/frame`). **Output for Phase 2**: User Context Profile (work domains, conversation patterns, task types). Quick Scan infers user context for protocol matching and scenario personalization. ### Phase 2a: Pick-1 (Quick Path — Single Recommendation) **Quick path only.** Select exactly 1 protocol recommendation from the auto-recommend pool. **Onboarding Pool**: `/elicit` (Euporia), `/inquire` (Aitesis), `/frame` (Prothesis). These three are chosen because users can quickly experience their value. Protocols like `/grasp` are user-initiated by nature and should not be proactively suggested in the first encounter. **Recommendation rules** (applied to Quick Scan Profile): | Protocol | Signal patterns | Priority | |----------|----------------|----------| | `/elicit` | Vague first prompts ("improve", "optimize", "make it better", "help me plan"); intent articulated but axis-undetermined; substrate-implicit decision coordinates. An ideation ask ("ideas for", "brainstorm") routes to `/ideate` (Heuresis), which is user-initiated and therefore outside this proactive pool | Highest (also fallback) | | `/inquire` | Hand-off or finalization language ("go ahead", "just do it", "ready", "ship", "merge") — the AI is about to execute on the context it has; tasks with implicit requirements or environment dependencies in summary. It checks what the imminent execution rests on (assumptions, missing facts, environment dependencies); it does not audit the decision for unconsidered trade-offs, alternatives, or omitted steps | Medium | | `/frame` | Exploration/comparison language ("approach", "options", "tradeoffs", "compare", "architecture", "which way") | Medium | **Decision logic**: 1. Score each protocol by signal match count from `firstPrompt` and `summary` fields 2. **Ideation route-away**: ideation asks ("ideas for", "brainstorm") score no pool protocol — when they are the only matched signals, relay in one sentence that the ask itself maps to `/ideate` (user-initiated: named as the route for that ask, not presented as the onboarding recommendation), then continue via the Fallback rule; the Phase 2b evidence card follows its fallback form, since the recommendation rests on the default, not on a matched signal 3. Select the single strongest match 4. Tie-break: `/elicit` > `/inquire` > `/frame` 5. **Fallback**: If no signals detected (no sessions, sparse metadata) — or every detected signal was routed away — recommend `/elicit` **Output**: Present exactly one recommendation as a single sentence. Format: Present as a single sentence stating which protocol is most likely to help right now. ### Phase 2b: Evidence (Quick Path — Evidence Card) **Quick path only.** Present exactly 1 evidence card explaining why this recommendation was made. **Evidence generation** (per protocol, referencing Data Sources table): - Line 1: Cite the specific signal pattern from Quick Scan Profile that matched this protocol's "Key Patterns" column in Data Sources - Line 2: State the expected benefit, derived from the protocol's "When to Use" column in Data Sources Fallback (no session data): State that no patterns were detected, then cite the protocol's core value proposition from Data Sources "When to Use." **Rules**: - Evidence is maximum 2 lines — a focused cue. - Do not show confidence scores or numbers. - Do not quote session content verbatim. After presenting evidence, present: - Text: Trial invitation - Options: - Try it now - Learn more about this recommendation - See a different recommendation - Go to full learning path Branch: Try it now → Phase 4 (quick trial), Learn more about this recommendation → show Data Sources row for the recommended protocol then re-ask, See a different recommendation → pick next from pool and re-present from Phase 2a, Go to full learning path → set `path = targeted` and go to Phase 0 targeted flow. ### Phase 2: Map (Targeted Path — Protocol Matching) **Targeted path only.** Apply User Context Profile to match protocols to the user's context. 1. Match Profile against the compact mapping table (Data Sources section). Select 2-3 protocols most relevant to the user's work domains and conversation patterns, defaulting to Onboarding Pool (`/elicit`, `/inquire`, `/frame`). 2. **Targeted sub-path**: Filter to target protocol, use Profile for scenario personalization. Note related protocols from the compact mapping table. 3. **Fallback**: If Profile quality is insufficient (no sessions, sparse metadata) → use **Onboarding Pool** (`/elicit`, `/inquire`, `/frame`). Proceed immediately without blocking the onboarding flow. ### Phase 3: Scenario (Targeted Path — Intervention Point) **Targeted path only.** Present a concrete scenario showing where the protocol would have helped. **Scenario construction** (2-tier fallback): - **Tier 1** (User Context Profile available): Generate a hypothetical scenario grounded in the user's work context (domains, task types, conversation patterns from Quick Scan). Personalize standard scenarios from `references/scenarios.md` using Profile data. - **Tier 2** (no data / Onboarding Pool fallback): Use preset scenarios directly from `references/scenarios.md`. Present scenarios for each of the top 2-3 protocols sequentially. **Scenario format**: ``` Scenario: /X (Protocol Name) [Situation]: [Concrete situation grounded in user's work context — or preset from scenarios.md] [Intervention]: If you had called /X at this point: - [what the protocol would have done — step 1] - [step 2] Expected outcome: [e.g., reduced rework, clearer direction] ``` **Clarity rule**: Scenarios must present **clear-cut** protocol fits where the mapping is unambiguous. If a situation could plausibly map to multiple protocols (e.g., "exploration" could be `/elicit` or `/frame`), reserve it for Phase 5 quiz material instead of using it as a scenario. The scenario phase builds confidence through recognition; the quiz phase builds discrimination through ambiguity. **Anti-pattern**: Scenarios must be self-contained (situation + intervention) with unambiguous protocol fit. Ambiguous patterns belong in Phase 5 quiz. Present each scenario as regular text output (Tier 1/2 format above). Then present for navigation only: **Gate** (per scenario): - Text: Scenario navigation - Options: - Try it — practice this protocol - Show another example - Skip to quiz ### Phase 4: Trial (Protocol Execution) Guide the user through a real, abbreviated protocol experience. #### Quick Path Trial **Mini practice prompt**: Present a single realistic request (one sentence) that naturally triggers the selected protocol's deficit. When User Context Profile is available, adapt the domain to match the user's work context. Source from `references/scenarios.md` Trial prompt field, or generate from Data Sources context. Follow with gate interaction: - Text: Trial scenario confirmation (user can also define their own) - Options: - Start with this scenario — call /X - Start with my own scenario (type in Other) **Execution**: The user invokes the actual protocol (e.g., type `/elicit`). The protocol runs in the same session with the mini prompt as context. Trial ends when the invoked protocol reaches its natural termination. After protocol termination, proceed to **Quick Post-Trial** below. **Quick Post-Trial Insight** (2 lines max): Generate from the protocol just experienced: - Line 1: Name the epistemic operation performed (source: protocol's deficit → resolution type, or `references/scenarios.md` Philosophy field) - Line 2: Connect to a concrete workflow benefit **Epistemic Ink Tip** (1 line, after Post-Trial Insight): "Tip: Run `/config` to enable Epistemic Ink — an Output Style that enhances protocol interactions with structured formatting." **Quick Post-Trial Navigation**: Present via gate interaction: - Text: Post-trial navigation - Options: - That's enough for today - Try a different protocol - Continue to full onboarding Branch: That's enough for today → end session with brief closing, Try a different protocol → check pool exhaustion: if unrecommended protocols remain in Onboarding Pool, pick next and restart from Phase 2a; if pool exhausted (all 3 recommended in session), present You've experienced all core recommendations and offer Targeted transition, Continue to full onboarding → set `path = targeted` and go to Phase 2 MAP with Quick Scan results. #### Targeted Path Trial "Try it" selection from Phase 3 already signals intent — enter trial directly without additional confirmation. **Mini practice prompts** (scoped for 2-3 exchanges): Use the **Trial prompt** field from `references/scenarios.md` for the target protocol. Present the trial guidance as regular text output. **Execution**: Prompt the user to invoke the actual protocol (e.g., type `/inquire`). The protocol runs in the same session with the mini prompt as context. Trial ends when the invoked protocol reaches its natural termination. After protocol termination, present Post-Trial Insight and LOOP. Offer trial for the top-recommended protocol first. If user completes it, optionally offer trial for the second recommendation. **Post-Trial Insight** (presented after trial completion): After each trial, present a brief insight card sourced from the **Philosophy** field in `references/scenarios.md`. Structure: ``` Protocol Insight: /X (Greek name) [Core principle — one sentence] [Workflow position — where this protocol sits and why] [Game feel — the experiential pattern you just went through] ``` **Post-Trial LOOP**: After the Post-Trial Insight, present: - Text: Post-trial navigation - Options: - Quiz — test my understanding - Another scenario — see more examples - Try a different protocol - Guide — see my learning summary Branch: Quiz → Phase 5, Another scenario → Phase 3, Different protocol → Phase 3 with next MAP protocol or Phase 0 with cached MAP, Guide → Phase 6. ### Phase 5: Quiz (Socratic Verification) Test protocol recognition through situation-based questions. Question format differs by path. **Question sourcing** (in priority order): 1. **Ambiguous scenarios from Phase 3 filtering** — situations that were too ambiguous for scenarios are ideal quiz material (e.g., "exploration" that could be `/elicit` or `/frame`) 2. Protocols from TRIAL + MAP results (personalized) 3. Profile-personalized variants of preset scenarios (if Use