A plugin to turn Claude Code into your personal assistant

GitHub stars
128

Install

/plugin install personal-assistant@ai-launchpad

Run it inside Claude Code after adding the marketplace with /plugin marketplace add kenneth-liao/ai-launchpad-marketplace.

Contents

Discovered from source

Skills 8

Context Health Audit

Audit the Elle context system at ~/.claude/.context/core/ for data quality issues.

Audit Checklist

Run each check in order. Report findings as a summary table at the end.

1. Staleness Check

Read ~/.claude/.context/core/triggers.md:

  • Flag any dates in the past that haven't been cleaned up
  • Flag events more than 30 days old

Read ~/.claude/.context/core/session.md:

  • Flag if "Current Focus" references work from a different session
  • Flag if last-modified date is more than 7 days ago

Read ~/.claude/.context/core/projects.md:

  • Flag any "Active" projects that haven't been referenced in recent sessions

2. Bloat Check

For each file in ~/.claude/.context/core/:

  • Count lines (warn if > 100 lines)
  • Count empty <guide> sections that could be filled with real data
  • Flag excessive placeholder text
wc -l ~/.claude/.context/core/*.md

3. Contradiction Check

Read ~/.claude/.context/core/preferences.md and ~/.claude/.context/core/rules.md:

  • Look for contradictions between preferences and rules
  • Look for duplicate or near-duplicate entries
  • Flag rules that may no longer apply

4. Gap Check

For each file, check if key sections are still placeholder text:

  • identity.md -- Basic Info, Professional, Personal Life
  • preferences.md -- Communication, Working Style
  • relationships.md -- any entries at all?
  • triggers.md -- any upcoming events?
  • workflows.md -- any workflows defined?

5. Sync Check

Compare ~/.claude/rules/elle-core.md against source files:

  • Is the timestamp recent?
  • Do the rules in elle-core.md match rules.md?
  • Do the projects in elle-core.md match projects.md?
head -5 ~/.claude/rules/elle-core.md
grep "Last synced" ~/.claude/rules/elle-core.md

If out of sync, recommend running /sync-context.

6. Improvements Check

Read ~/.claude/.context/core/improvements.md:

  • Flag Active Proposals older than 30 days without status change
  • Flag Friction Log entries with 2+ occurrences not yet promoted
  • Report total pending proposals

7. System Freshness Check

Locate the evolve skill's platform capabilities reference:

EVOLVE_REF=""
# Source mode (marketplace repo)
if [ -f "<cwd>/personal-assistant/skills/evolve/references/platform-capabilities.md" ]; then
  EVOLVE_REF="<cwd>/personal-assistant/skills/evolve/references/platform-capabilities.md"
else
  # Deployed mode (plugin cache)
  EVOLVE_REF=$(find ~/.claude/plugins/cache -path "*/personal-assistant/*/skills/evolve/references/platform-capabilities.md" 2>/dev/null | sort -V | tail -1)
fi

If found, read the ## System State section and check:

  • Flag if "Last evolve run" is > 60 days ago or missing
  • Flag if "Claude Code version at last audit" is "unknown" or differs from current
  • Flag if "Platform docs last fetched" is > 60 days ago
  • If System State section doesn't exist, flag as "never audited"
  • Flag if "Model capabilities last assessed" is missing or > 90 days ago
  • If "Model Capabilities" section doesn't exist in the reference, flag: "Model capabilities never assessed -- run /evolve to check for obsolete skills"

If reference file not found, skip with note: "Evolve reference files not found -- cannot check system freshness"

Recommend running /evolve if any flags are raised.

Report Format

Present findings as:

CheckStatusDetails
StalenessOK / Warning[specific issues]
BloatOK / Warning[file: line count]
ContradictionsOK / Warning[specific conflicts]
GapsOK / Warning[empty sections]
SyncOK / Warning[sync status]
ImprovementsOK / Warning[stale proposals]
System FreshnessOK / Warning[evolve run recency, version drift]

Recommended actions: List specific fixes the user can take, prioritized by impact.

Evolve -- Research-Driven Self-Upgrade Pipeline

This skill researches the latest Claude Code platform state, audits Elle against it, plans upgrades, executes them, and verifies results. It auto-updates the reference files in this skill's references/ directory to keep the knowledge base current between runs.

Context Detection

Determine execution mode before doing anything else.

Check: Does <cwd>/personal-assistant/.claude-plugin/plugin.json exist AND does <cwd>/.git exist AND does <cwd>/CONVENTIONS.md exist?

  • YES -- Source Mode. Operating in the marketplace repo where Elle is maintained. Operate on skill files, hooks, and references directly. Bump version and update CHANGELOG when done.

  • NO -- Deployed Mode. Show this disclaimer:

    Note: Evolve is designed to run from Elle's source repo where the plugin is maintained. Running here will audit and modify your installed copy at ~/.claude/plugins/cache/.... These changes will be overwritten on the next plugin update.

    To run from source, navigate to your marketplace repo.

    Proceed with deployed copy?

    Wait for confirmation. If declined, stop.

Set ELLE_ROOT:

  • Source mode: <cwd>/personal-assistant
  • Deployed mode: the installed plugin path (find via the highest version directory in ~/.claude/plugins/cache/ai-launchpad/personal-assistant/)

Phase 1: Research

Run six research tasks in parallel using subagents. Each subagent summarizes its findings.

1A. Claude Code Changelog

Fetch latest Claude Code releases:

WebFetch: https://github.com/anthropics/claude-code/releases

Also check the raw changelog:

WebFetch: https://raw.githubusercontent.com/anthropics/claude-code/main/CHANGELOG.md

Extract from the last 3-5 releases:

  • New tool capabilities or parameters
  • New hook events or rule features
  • Changes to skill loading, triggering, or frontmatter
  • New agent/subagent patterns
  • Deprecations or breaking changes
  • Performance improvements relevant to skill design

1B. Claude Code Documentation (Discovery-Driven)

Discover the Claude Code documentation landscape. Do NOT hardcode doc page URLs -- discover them dynamically.

  1. Find available documentation:

    WebSearch: "Claude Code" site:docs.anthropic.com
    WebFetch: https://docs.anthropic.com/en/docs/claude-code/overview
    
  2. From the search results and overview page, identify and fetch pages covering these categories:

    • Core infrastructure: skills, hooks, rules, CLAUDE.md
    • Agent capabilities: subagents/Agent tool, agent teams
    • Plugin system: commands, output styles, MCP servers, plugin architecture
    • Memory & context: auto memory, context management
    • Configuration: settings, permissions, tool gating
    • Workflow: worktrees, session management
  3. For each fetched page, extract:

    • Current best practices and recommended patterns
    • New features not in ${CLAUDE_SKILL_DIR}/references/platform-capabilities.md
    • Deprecated patterns Elle might still use
    • Capabilities Elle doesn't leverage yet

1C. Skill-Creator Best Practices

Find and read the installed skill-creator:

Glob: ~/.claude/plugins/cache/*/skill-creator/*/skills/skill-creator/SKILL.md

Extract:

  • Current skill writing patterns
  • Progressive disclosure guidelines (line limits, reference files)
  • Description optimization guidance (triggering, "pushy" descriptions)
  • Testing and evaluation patterns

1D. Superpowers & Platform Patterns

Check official plugins for patterns worth adopting:

Glob: ~/.claude/plugins/cache/*/superpowers/*/skills/*/SKILL.md

Note structural patterns, frontmatter conventions, or composition techniques.

1E. Plugin Architecture

Understand the full plugin specification and what Elle could be using:

  1. Read the marketplace conventions (source mode only):

    Read: <cwd>/CONVENTIONS.md
    
  2. Examine other installed plugins for structural patterns:

    Glob: ~/.claude/plugins/cache/*/*/skills/*/SKILL.md
    Bash: ls ~/.claude/plugins/cache/*/*/ | head -50
    

    Focus on: plugin.json fields, agents/ directories, MCP server integration, output style patterns.

  3. Compare Elle's plugin structure against the full spec:

    • What directories does Elle have vs. what's available?
    • What plugin.json fields exist vs. what Elle uses?
    • Are other plugins using agents/ or MCP servers effectively?

1F. Model Capability Assessment

Check for model-level improvements that may supersede Elle's skills:

  1. Search for recent Anthropic model releases:

    WebSearch: "Anthropic Claude" model release OR capability update site:anthropic.com
    WebSearch: "Claude" new capabilities 2026
    
  2. Fetch the models overview page:

    WebFetch: https://docs.anthropic.com/en/docs/about-claude/models
    
  3. Extract capabilities relevant to skill obsolescence:

    • Built-in tool use improvements (web search, code execution)
    • Reasoning and planning improvements
    • Multi-step task handling
    • Areas where dedicated prompting/orchestration adds less value
  4. Compare against Elle's skill inventory:

    • For each skill, ask: "Does the model now do this well enough without specialized prompting?"
    • Flag skills where the answer is "yes" or "probably"
  5. Cross-reference against ${CLAUDE_SKILL_DIR}/references/platform-capabilities.md Model Capabilities table to detect changes since last run.

Research Output

After all research completes, compile a Research Summary with sections:

  • New Claude Code Features (from changelog + docs)
  • Updated Skill Best Practices (from skill-creator)
  • Platform Patterns (from superpowers and other plugins)
  • Plugin Architecture Gaps (capabilities Elle doesn't use yet)
  • Deprecations & Breaking Changes
  • Model Capability Overlap (skills potentially superseded by model improvements)

In source mode: save to <cwd>/.docs/upgrade-research/personal-assistant-<date>.md

In deployed mode: present in-session only.

Phase 1.5: Obsolescence Screen

Using research findings from Phase 1 (especially 1A, 1B, and 1F), evaluate whether each skill, agent, and major component in Elle is still necessary.

Classification

For each skill and agent, assign one of:

RatingMeaningAction
ActivePlatform/model doesn't replicate this. Skill adds clear value.Proceed to structural audit in Phase 2
AugmentedPlatform/model handles the basics, but skill adds meaningful structure, guardrails, or workflow orchestration on top.Audit normally, but note what the platform handles natively
SupersededPlatform/model now does this natively with comparable quality. Skill adds marginal value over a direct prompt.Skip structural audit. Recommend removal in Phase 3 plan.

How to Evaluate

For each skill, answer these three questions:

  1. What does this skill do that a direct prompt to Claude cannot? If the answer is only "it saves typing a prompt" -- likely Superseded.

  2. Does this skill enforce a process, workflow, or multi-step structure? Process skills (TDD, debugging, code review) remain valuable even when the model can do each step -- the skill enforces discipline. Likely Active.

  3. Has the platform added a native feature that replaces this skill's core function? Example: Claude Code added native web search -> a "web research" skill that just wraps web search is Superseded. But a "competitor analysis" skill that orchestrates multiple searches into a structured report may be Augmented.

Output

Present results as a table:

ComponentTypeRatingRationale
[name]skill/agentActive/Augmented/Superseded[1-line reason]

If any component is rated Superseded, flag it for the user:

Obsolescence flag: [N] component(s) appear superseded by platform/model capabilities. These will appear in the "Recommend Removal" section of the upgrade plan. Review the rationale -- override to Active or Augmented if you disagree.

Proceed to Phase 2, skipping structural audit for Superseded components.

Phase 2: Audit

2A. Skill Inventory

For each skill in ${ELLE_ROOT}/skills/, read the SKILL.md and evaluate:

  • Frontmatter fields (follows latest conventions from Phase 1?)
  • Line count (warn if over 500)
  • Whether it uses references/ or scripts/ for progressive disclosure
  • Composition patterns (plugin:skill syntax used correctly?)
  • Hardcoded paths or stale assumptions
  • Obsolescence rating from Phase 1.5 (skip detailed audit for Superseded components)

2B. Architecture Audit

Check the deployed system state:

cat ${ELLE_ROOT}/hooks/hooks.json
ls -la ~/.claude/rules/elle-core.md
ls ~/.claude/.context/core/
cat ~/.claude/settings.json | python3 -c "import sys,json; d=json.load(sys.stdin); print(json.dumps(d.get('hooks',{}), indent=2))" 2>/dev/null

Verify:

  • SessionStart hooks registered (not UserPromptSubmit)
  • elle-core.md exists in rules/
  • No duplicate notification hooks between plugin and settings.json
  • Output style set correctly
  • All expected context files present

2C. Gap Analysis

Compare current state against Phase 1 research:

CategoryCheck
Skill structureFrontmatter follows latest conventions? Under 500 lines? Progressive disclosure?
DescriptionsTriggering descriptions specific enough per skill-creator guidance?
PatternsUses latest Claude Code features? No deprecated patterns?
CompositionFollows plugin:skill invocation syntax?
Hook designNon-blocking? SessionStart < 2 seconds? Uses additionalContext?
Plugin architectureUsing all beneficial plugin components (agents, MCP, output styles)?
System statePlatform capabilities and best practices references current?

2D. Reference Freshness

Compare ${CLAUDE_SKILL_DIR}/references/platform-capabilities.md and best-practices.md against research findings. Flag entries that are:

  • Outdated (platform has changed)
  • Missing (new capabilities not listed)
  • Wrong (deprecated patterns still listed as current)

2E. Full Plugin Inventory

Check all plugin components, not just skills:

echo "=== Skills ===" && ls ${ELLE_ROOT}/skills/
echo "=== Hooks ===" && cat ${ELLE_ROOT}/hooks/hooks.json 2>/dev/null
echo "=== Output Styles ===" && ls ${ELLE_ROOT}/output-styles/ 2>/dev/null
echo "=== Plugin.json ===" && cat ${ELLE_ROOT}/.claude-plugin/plugin.json
echo "=== Agents ===" && ls ${ELLE_ROOT}/agents/ 2>/dev/null || echo "No agents/ directory"

Evaluate:

  • Output styles: leveraging latest features? Under 120 lines?
  • Plugin.json: all available fields used correctly?
  • Missing components: would agents/ or MCP servers benefit Elle?
  • Structural patterns: anything other plugins do that Elle should adopt?

2F. System State Check

Read ${CLAUDE_SKILL_DIR}/references/platform-capabilities.md System State section:

  • Last evolve run date -- flag if > 60 days ago
  • Claude Code version at last audit -- compare against latest from Phase 1A
  • Elle version -- compare against plugin.json
  • Platform docs last fetched -- flag if > 60 days ago

If System State section is missing, flag as "first evolve run" and note that all findings are new.

Phase 3: Plan

Present a structured upgrade plan:

## Upgrade Plan: personal-assistant (Elle)

### Summary
- Current version: [from plugin.json]
- Proposed version: [with semver justification]
- Skills affected: N
- Reference files to update: N

### High Priority (Breaking/Deprecated)
1. [Change]
   - **Why**: [What's wrong or deprecated]
   - **What**: [Specific change]
   - **Risk**: [What could break]

### Superseded (Recommend Removal)
Components flagged as Superseded in Phase 1.5. Review before approving removal.

1. [Component name] ([type])
   - **What it does**: [1-line summary]
   - **What replaces it**: [platform feature or model capability]
   - **Migration**: [user-facing steps if any -- update docs, remove references]
   - **Risk**: [what's lost if removed]

### Medium Priority (New Features)
1. [Change]
   - **Why**: [What capability this enables]
   - **What**: [Specific change]

### Low Priority (Polish)
1. [Change]

### Not Recommended
- [Considered but rejected, and why]

For removed components in source mode:

  • Add CHANGELOG entry under "Removed"
  • Version bump: MINOR if user-invocable skill, PATCH if internal-only component
Wait for user approval before proceeding to Phase 4. The user may adjust priorities, skip items, or add their own.

Phase 4: Execute

Apply approved changes:

  1. One file at a time -- read the full file before editing
  2. Preserve intent -- upgrade patterns without changing what skills do
  3. Explain reasoning -- prefer explaining why over heavy-handed MUSTs
  4. Keep prompts lean -- remove things that aren't pulling their weight

Reference File Updates

Update ${CLAUDE_SKILL_DIR}/references/platform-capabilities.md and best-practices.md with findings from Phase 1. These files serve as "last known state" for future evolve runs.

Model Capabilities Update

Update the Model Capabilities table in ${CLAUDE_SKILL_DIR}/references/platform-capabilities.md with findings from Phase 1F. Add new capabilities, update proficiency levels, and revise skill design implications.

System State Update

After all changes are applied, update the System State section in ${CLAUDE_SKILL_DIR}/references/platform-capabilities.md:

FieldValue
Elle version[from plugin.json after bump]
Last evolve run[today's date]
Claude Code version at last audit[latest version from Phase 1A research]
Platform docs last fetched[today's date]
Model capabilities last assessed[today's date]

Version and Changelog (Source Mode Only)

After all changes:

  • Bump version in ${ELLE_ROOT}/.claude-plugin/plugin.json per semver
  • Update ${ELLE_ROOT}/CHANGELOG.md in Keep a Changelog format

Phase 5: Verify

Validation Checks

for skill in $(find ${ELLE_ROOT}/skills -name "SKILL.md"); do
  echo "=== $skill ==="
  wc -l "$skill"
  head -5 "$skill"
  echo ""
done
  1. Diff review (source mode) -- show git diff for user review
  2. Frontmatter check -- all skills have valid frontmatter with name and description
  3. Line count -- no SKILL.md over 500 lines
  4. Cross-reference check -- any plugin:skill references still valid
  5. Convention check -- changes follow CONVENTIONS.md

Deferred Findings

For recommendations the user deferred or rejected, log to ~/.claude/.context/core/improvements.md as Active Proposals:

### ENHANCEMENT evolve-deferred -- [Short description]
- **Evidence**: Evolve audit [date] -- [what was found]
- **Current behavior**: [what exists now]
- **Proposed change**: [what was recommended]
- **Status**: Deferred
- **Source**: Evolve audit

Final Summary

Report:

  • Changes made (with file paths)
  • Version bump applied (if source mode)
  • CHANGELOG entry (if source mode)
  • Reference files updated
  • Deferred items logged to improvements.md
  • Any manual follow-up needed

Migrate -- Version Upgrade System

This skill handles version-to-version upgrades using sequential, idempotent migration steps. Each version transition has a dedicated reference file containing Check/Action/Verify steps, making migrations safe to re-run on partial completions and easy to extend for future versions.

1. Version Detection

Current Installed Version

Primary method: Find the installed version directory.

ls ~/.claude/plugins/cache/ai-launchpad/personal-assistant/

List directories, find the highest version number, and read its .claude-plugin/plugin.json to get the version field.

Fallback fingerprinting (when plugin.json is not reliable):

SignalInferred Version
No ~/.claude/.context/ directoryNot installed -- tell user to run /personal-assistant:setup and stop
UserPromptSubmit in plugin hooks, no ~/.claude/rules/elle-core.mdv1.0.0
SessionStart in plugin hooks + elle-core.md exists, no ~/.claude/.context/core/improvements.mdv1.9.0
SessionStart + elle-core.md + improvements.md existsv1.10.0
Full v2 state (migrate skill exists in installed plugin)v2.0.0

Target Version

Read ${CLAUDE_PLUGIN_ROOT}/.claude-plugin/plugin.json to get the version of the plugin source being installed.

If current == target: report "Already current. Run /evolve to check for platform upgrades." and stop.

2. Migration Chain

List available migration files from ${CLAUDE_SKILL_DIR}/references/migrations/. Each file is named vX.Y.Z-to-vA.B.C.md.

Parse filenames to build an ordered chain from current version to target version.

Example: if current is v1.10.0 and target is v2.1.0, chain is: v1.10.0 -> v2.0.0, v2.0.0 -> v2.1.0.

For each migration in the chain, read its ## Summary section and present the plan:

Migration path: v1.10.0 -> v2.0.0 -> v2.1.0

Step 1 (v1.10.0 -> v2.0.0):
- Replaces UserPromptSubmit hook with native rules delivery
- ~95% token savings

Step 2 (v2.0.0 -> v2.1.0):
- [summary from file]

Proceed?

Wait for user confirmation before continuing.

3. Backup

Create a timestamped backup before making any changes:

mkdir -p ~/.claude/.context-backups/ && cp -r ~/.claude/.context/ ~/.claude/.context-backups/$(date +%Y%m%d-%H%M%S)/

Verify backup was created:

ls -la ~/.claude/.context-backups/

REQUIRED: DO NOT proceed if backup fails. This is a hard gate.

4. Execute Migration Chain

For each migration in the chain:

  1. Read the migration reference file from ${CLAUDE_SKILL_DIR}/references/migrations/
  2. For each step in the ## Steps section:
    • Run the Check command -- if it exits 0, the step is already done, skip it
    • Run the Action command
    • Run the Verify command -- if it fails, stop immediately and report the failure
  3. After each migration file completes, report: "Migration vX.Y.Z -> vA.B.C complete. N steps executed, M skipped (already done)."

If any step fails:

  • Stop immediately
  • Report which step failed and the error
  • Provide restore instructions: cp -r ~/.claude/.context-backups/[timestamp]/ ~/.claude/.context/

5. Verify and Report

After all migrations complete, verify the final state:

ls -la ~/.claude/rules/elle-core.md
ls ~/.claude/.context/core/

Present final report:

Migration Complete!

Path: vX.Y.Z -> ... -> vA.B.C
Backup: ~/.claude/.context-backups/[timestamp]/
Steps executed: N
Steps skipped (already done): M

Your data: 100% preserved. All personal context untouched.

If rules-affecting changes were made (rules/, elle-core.md, context files), suggest running /sync-context.

6. Migration File Format

Each file at references/migrations/vX.Y.Z-to-vA.B.C.md follows this format:

# Migration: vX.Y.Z -> vA.B.C

## Summary
- [1-3 bullet points describing what this migration does]

## Breaking Changes
- [List any breaking changes, or "None"]

## Steps

### 1. [Step name]
**Check:** `[shell command -- if exits 0, skip this step]`
**Action:** `[shell command to execute]`
**Verify:** `[shell command -- must exit 0 to continue]`

Each step MUST have all three fields (Check, Action, Verify). The Check field makes steps idempotent -- safe to re-run on partially completed migrations.

Onboarding — Get to Know the User

This command runs a guided conversation to populate Elle's context system with information about the user. Run this:

  • After initial setup (if skipped during /personal-assistant:setup)
  • Anytime to update or expand your context
  • When you want Elle to know you better

Before Starting

Check if context system exists:

ls ~/.claude/.context/

If directory doesn't exist: Run /personal-assistant:setup first.

Onboarding Approach

Be warm and conversational — this is getting to know someone, not an interrogation. Ask follow-up questions naturally. After each topic section, **immediately write** the learned context to the appropriate file.

Start with:

"I'd love to learn more about you so I can be genuinely helpful. Mind if I ask a few questions? We can skip anything you'd rather not share."


Topics to Cover

1. Identity (write to ~/.claude/.context/core/identity.md)

Who they are:

  • "What should I call you?"
  • "Tell me about what you do for work."
  • "What's your life like outside of work? What matters to you?"

Goals & Aspirations:

  • "What are you trying to achieve this year — personally or professionally?"
  • "Any big dreams or long-term goals?"

Current Challenges:

  • "What's hard right now? Any frustrations or obstacles?"
  • "What would make your life easier?"

2. Key People (write to ~/.claude/.context/core/relationships.md)

Important relationships:

  • "Who are the important people in your life I should know about?"
  • For each person mentioned: name, relationship, relevant context
  • "Anyone at work I should know about? (boss, key collaborators, reports)"

3. Preferences (write to ~/.claude/.context/core/preferences.md)

Communication style:

  • "When I give you information, do you prefer quick bullet points or more detailed explanations?"
  • "When you need help deciding something, do you want options to choose from, or should I just recommend what I think is best?"

Tools & Systems:

  • "What tools, apps, or systems do you use regularly?"
  • "Any particular way you like to organize things?"

Working style:

  • "When are you most productive? Morning person or night owl?"
  • "How do you like to approach big tasks — dive in or plan first?"

4. Projects & Commitments (write to ~/.claude/.context/core/projects.md)

What they're working on:

  • "What projects are you actively working on right now?"
  • For each: name, where it lives (folder, Notion, Google Drive, etc.), current status

Life projects too:

  • "Any personal projects? Travel planning, home stuff, learning something new?"

5. Current Focus (write to ~/.claude/.context/core/session.md)

Right now:

  • "What's on your mind this week?"
  • "Anything coming up I should keep track of? Deadlines, events, decisions?"

6. Important Dates & Triggers (write to ~/.claude/.context/core/triggers.md)

Recurring & upcoming:

  • "Any important dates I should remember? Birthdays, anniversaries, deadlines?"
  • "Any regular check-ins or routines you'd want me to prompt you about?"

After Each Section

Write the learned information to the appropriate context file immediately:

  • Use the structure defined in each template
  • Replace placeholder text with actual content
  • Keep entries concise but meaningful

Wrapping Up

After covering the topics, summarize what you learned:

"Thanks for sharing all of that! Here's what I've learned about you: [brief summary]. I'll use this to be more helpful going forward. You can always update this by running /personal-assistant:onboard again or just telling me things as we work together."

Let them know:

  • Context updates happen via /update-context or /retrospective
  • They can run this command anytime to update their profile
  • They can also just mention things naturally and you'll remember

Sync Rules

After onboarding, regenerate elle-core.md to reflect the new context:

"Let me sync your context to elle-core.md so future sessions have your info loaded automatically."

Run /sync-context (or invoke the script directly).

Retrospective

Overview

A meta skill that helps Elle actively improve over time. Captures friction from working sessions, routes findings to the correct context file, and closes the loop on past proposals.

Core Principle: Only log what the user confirms. Observable friction is the only valid signal — never guess or infer problems that didn't surface.

When to Use

Use this skill when:

  • User triggers /retrospective at end of a session
  • User corrects Claude's output mid-session
  • User asks Claude to redo work
  • User expresses frustration or dissatisfaction
  • Same topic required 3+ back-and-forth rounds without resolution
  • User overrides Claude's approach ("Don't do it that way", "Skip that step")

Do NOT use when:

  • Normal iterative refinement ("Make the font bigger" is collaboration, not friction)
  • User is exploring options (asking for alternatives is not a correction)
  • User changes their mind about direction (that's new input, not a mistake)

Two Modes

Mode 1: Real-Time Friction Capture (Passive)

When you detect a friction signal mid-session, do NOT interrupt the workflow. Mentally note:

  1. What skill was active (or what task was being performed)
  2. What the user expected vs what Claude produced
  3. The user's actual words (the correction)
  4. Root cause category: wrong output, missed requirement, unnecessary step, wrong skill invoked, or skill gap

Hold these notes in working memory. Do not write to disk until the retrospective.

Friction Signals

SignalExample
User asks to redo"No, redo this", "Try again", "That's not what I meant"
User corrects output"Actually it should be X", "Change this to Y"
User expresses frustration"This isn't right", "You keep doing X", "I already told you"
Excessive back-and-forth3+ rounds on the same topic without resolution
User overrides approach"Don't do it that way", "Skip that step", "Just do X"

Mode 2: Interactive Retrospective (Active)

Triggered by user via /retrospective. Execute all steps in order.

Step 1: Scan conversation for friction

Review the full session. Identify every instance where a friction signal occurred. Include both:

  • Friction moments captured in real-time (Mode 1)
  • Friction moments found on retrospective review (hindsight)
Step 2: Classify and route each friction moment

For each friction moment, walk through this decision tree in order. The tree is ordered by scope — cross-project corrections first (most impactful), then project-specific knowledge, then skill improvements (which need pattern validation before acting on):

1. Is this a correction about Claude's behavior?
   YES → rules.md (cross-project, immediate)

2. Is this a user preference Claude didn't know?
   YES → preferences.md (cross-project, replace)

3. Is this a workflow/process the user follows?
   YES → workflows.md (cross-project)

4. Is this specific to this project/codebase?
   YES → auto memory MEMORY.md (project-scoped)

5. Is this a skill deficiency or gap?
   → Check improvements.md for prior occurrences
   → 0 prior: friction note in improvements.md Friction Log
   → 1+ prior: promote to/update Active Proposals in improvements.md

Classify each finding into one of these categories with its routing target:

CategoryDescriptionDestination
Behavioral CorrectionClaude did something the user corrected~/.claude/.context/core/rules.md
Preference DiscoveredUser has a preference Claude didn't know~/.claude/.context/core/preferences.md
Workflow CapturedUser follows a process Claude should know~/.claude/.context/core/workflows.md
Project-SpecificKnowledge specific to this codebase/projectAuto memory MEMORY.md
Skill Friction (1st)Skill issue, no prior occurrences~/.claude/.context/core/improvements.md Friction Log
Skill Friction (2nd+)Skill issue, matches prior friction~/.claude/.context/core/improvements.md Active Proposals

Also identify: which skill was active, root cause in 1-2 sentences.

Step 3: Prioritize findings
  • Rank by impact (time wasted, output quality, user frustration level)
  • Select top 5 maximum — forces prioritization, prevents fatigue
  • Allow up to 7 if findings span 4+ different destinations
  • If two findings share the same root cause, merge them
  • Drop low-impact items
Step 4: Present findings interactively

For each finding (one at a time), present:

  1. What happened: Quote the user's actual words
  2. Category: Which of the 6 categories
  3. Root cause: Why it happened (1-2 sentences)
  4. Proposed action: What to write and where (show the destination file)

Ask the user: confirm, reject, or refine. Only confirmed findings proceed to writing.

Step 5: Check existing files before writing

Before writing anything, read ALL potential destinations:

  • ~/.claude/.context/core/rules.md
  • ~/.claude/.context/core/preferences.md
  • ~/.claude/.context/core/workflows.md
  • ~/.claude/.context/core/improvements.md
  • Project auto memory MEMORY.md

Check for:

  • Duplicates: Skip if already captured
  • Contradictions: Present both to user, ask which is correct
  • Context-update overlap: Check what was already captured this session by context-update — skip duplicates
  • Line count: If improvements.md exceeds 100 lines, flag for consolidation before adding

If the context system is not initialized (~/.claude/.context/ doesn't exist), fall back to MEMORY.md only and suggest running /personal-assistant:setup.

Step 6: Write confirmed findings

Route each confirmed finding to its classified destination with format appropriate to that file:

rules.md (for Behavioral Corrections):

- [RULE]: [Actionable imperative — what to always/never do]
  - Source: Retrospective [date] — [brief friction context]

After writing to rules.md or preferences.md: Prompt the user: "Rules/preferences changed. Run /sync-context to update elle-core.md?"

preferences.md (for Preferences Discovered): Replace the relevant preference entry, or add a new one under the appropriate section. Follow the file's existing format.

workflows.md (for Workflows Captured): Add under the appropriate section following the file's existing format.

MEMORY.md (for Project-Specific findings):

## [Category]: [Short imperative description]
- [Actionable note, 1 line]
- [Evidence: what friction triggered this]

Rules: 1-3 bullet points max per entry. Include friction evidence.

improvements.md Friction Log (for Skill Friction, 1st occurrence): Add a row to the Friction Log table:

| [Date] | [Project] | [Skill/Area] | [Friction Summary] | 1 |

improvements.md Active Proposals (for Skill Friction, 2nd+ occurrences):

### [ENHANCEMENT|NEW SKILL] skill-name — Short description
- **Evidence**: [Friction moments that motivated this, with dates]
- **Projects**: [Which projects encountered this]
- **Current behavior**: [What happens now]
- **Proposed change**: [What should change]
- **Affected section**: [Which part of the SKILL.md or system]
- **Status**: Proposed
- **Promoted**: [Date]

Third-party skills (superpowers, external plugins): Log friction notes in improvements.md for pattern tracking, but mark proposals with "External skill — workaround via rules.md" and add a corresponding rule for the immediate workaround.

Step 7: Verify applied proposals

Check ~/.claude/.context/core/improvements.md for proposals with status Applied.

For each:

  • Scan the current session for friction related to that proposal
  • If no recurrence observed in this session, note it (after 2-3 sessions without recurrence, mark as Verified and move to Applied & Verified section)
  • If friction recurred, update status to "Needs Revision" and create a follow-up note
Step 8: Journal and summary

Write session summary to ~/.claude/.context/core/journal.md (append at TOP, newest first).

Show the user:

  • How many findings captured vs rejected
  • What was written and to which files (quoted)
  • Any proposals verified or flagged for revision
  • Any pending Active Proposals from previous sessions worth reviewing now

If no friction was found: report "Clean session — nothing to capture" and exit.

Common Mistakes and Why They Matter

Over-reporting kills trust. If you dump 10 findings on the user, they'll stop confirming any of them. Cap at 5 (up to 7 only when spanning 4+ destinations) and prioritize ruthlessly — the user needs to feel each finding is worth their time.

Writing without confirmation breaks the social contract. The retrospective works because the user trusts that nothing gets written without their say-so. If you silently write mid-session or skip confirmation, the user loses trust in the entire context system.

Misrouting creates invisible debt. The routing tree exists because each context file has a different scope and lifecycle:

  • Behavioral corrections in MEMORY.md get lost when the project ends — they belong in rules.md because they apply everywhere
  • Preferences in improvements.md clutter the improvement tracker — they belong in preferences.md where they get applied immediately
  • Skill proposals in project-scoped memory/skill-proposals.md can't aggregate cross-project patterns — they belong in improvements.md

Premature proposals waste energy. A single friction moment could be a fluke. The friction log exists to collect first occurrences cheaply — only promote to Active Proposals when the same root cause surfaces 2+ times, which signals a real pattern worth investing in.

Duplicating context-update work creates noise. The context-update process may have already captured corrections or preferences from this session. Check before writing to avoid contradictory or redundant entries.

Confusing iteration with friction undermines accuracy. "Make the font bigger" is collaboration. "You keep ignoring what I said" is friction. The distinction matters — logging normal refinement as friction inflates the signal and desensitizes the system.

Memory Management

  • Before writing, check all destination files for duplicates and contradictions
  • If improvements.md exceeds 100 lines, flag for consolidation before adding new entries
  • Proposals in improvements.md marked Verified can be pruned after 3 months
  • Friction Log entries that have been promoted to Active Proposals can be removed
  • improvements.md is cross-project — friction from all projects aggregates here, enabling pattern detection

Relationship to Other Skills

skill-creator:skill-creator         → Guides skill creation (assistant)
superpowers:writing-skills          → Tests and deploys skills (TDD)
/retrospective                      → Identifies what needs improving (feedback loop)
/update-context                     → Handles routine context updates (avoid duplication)
/sync-context                       → Regenerates elle-core.md after rule changes

This skill completes the skill lifecycle: create → test → deploy → observe → improve.

Personal Assistant Setup (v2)

Set up Elle with native rules delivery, context system, and default Claude Code settings.

Step 1: Set Default Settings

Communicate with the user the exact settings that will be set and ask the user if they want to selectively disable any of them. The Personal Assistant output style will turn Claude Code into a personal assistant with deep contextual knowledge and proactive behavior.

Read current settings:

cat ~/.claude/settings.json

If the file doesn't exist or is empty, create it with the content below. If the file exists, merge the fields below into the existing settings (you MUST preserve other settings).

{
  "outputStyle": "personal-assistant:Personal Assistant",
  "statusLine": {
    "type": "command",
    "command": "INPUT=$(cat); STYLE_NAME=$(echo \"$INPUT\" | jq -r '.output_style.name // \"default\"'); STYLE_PLUGIN=$(echo \"$INPUT\" | jq -r '.output_style.plugin // \"\"'); MODEL=$(echo \"$INPUT\" | jq -r '.model.display_name // \"default\"'); STYLE_DISPLAY=\"$STYLE_NAME\"; PLUGINS=$(ls -1d ~/.claude/plugins/marketplaces/*/ 2>/dev/null | wc -l | tr -d ' '); TOOLS=$(uv tool list 2>/dev/null | grep -c ' v[0-9]' || echo 0); CC_MCPS=$(cat ~/.claude/mcp.json 2>/dev/null | jq '.mcpServers | length // 0' || echo 0); PROJ_MCPS=$(cat .mcp.json 2>/dev/null | jq '.mcpServers | length // 0' || echo 0); MCPL_MCPS=$(mcpl list 2>/dev/null | grep -c '^[[:space:]]*\\[' || echo 0); MCPS=$((CC_MCPS + PROJ_MCPS + MCPL_MCPS)); if [ \"$CC_MCPS\" -eq \"$MCPL_MCPS\" ]; then MCPS=$((CC_MCPS + PROJ_MCPS)); fi; COST=$(echo \"$INPUT\" | jq -r '.cost.total_cost_usd // 0'); TIME=$(echo \"$INPUT\" | jq -r '.cost.total_duration_ms // 0'); if [ \"$TIME\" -lt 60000 ]; then SECS=$((TIME / 1000)); TIME_DISPLAY=\"${SECS}s\"; elif [ \"$TIME\" -lt 3600000 ]; then MINS=$((TIME / 60000)); SECS=$(((TIME % 60000) / 1000)); TIME_DISPLAY=\"${MINS}m ${SECS}s\"; else HOURS=$((TIME / 3600000)); MINS=$(((TIME % 3600000) / 60000)); TIME_DISPLAY=\"${HOURS}h ${MINS}m\"; fi; printf \"%s | %s\\n%s Plugins | %s UV | %s MCPs\\n\\$%.2f | %s\" \"$STYLE_DISPLAY\" \"$MODEL\" \"$PLUGINS\" \"$TOOLS\" \"$MCPS\" \"$COST\" \"$TIME_DISPLAY\""
  }
}
You **MUST** preserve other settings in the `settings.json` file. Only update/add the fields specified above.

Dedup Notification Hooks

Check if the user's ~/.claude/settings.json already has Stop or Notification sound hooks:

cat ~/.claude/settings.json | python3 -c "
import sys, json
d = json.load(sys.stdin)
hooks = d.get('hooks', {})
has_stop = bool(hooks.get('Stop'))
has_notif = bool(hooks.get('Notification'))
print(f'Stop hooks: {has_stop}, Notification hooks: {has_notif}')
"

If the user already has Stop and/or Notification sound hooks in settings.json, the plugin's hooks.json will also register them -- this causes duplicate sounds. Inform the user and offer to remove the duplicates from settings.json (the plugin hooks.json will handle them).

Step 2: Initialize Context System

Check if context already exists

ls ~/.claude/.context/ 2>/dev/null
  • If the directory exists: Context is already set up. Do NOT overwrite it. CRITICAL: Do NOT proceed with the copy if the directory already exists!
  • If the directory doesn't exist: Proceed with setup below.

Fresh Install (only if directory doesn't exist)

cp -r ${CLAUDE_PLUGIN_ROOT}/context-template/ ~/.claude/.context/

Verify

ls ~/.claude/.context/

You should see: CLAUDE.md, context-update.md, core/

Step 3: Generate elle-core.md

Create the rules directory and generate the derived rules file:

mkdir -p ~/.claude/rules
uv run python ${CLAUDE_PLUGIN_ROOT}/skills/sync-context/scripts/sync_context.py

Verify

cat ~/.claude/rules/elle-core.md

You should see a compact file with Identity, Communication Preferences, Rules, Active Projects, and Loading Full Context sections.

Step 4: Onboarding

After technical setup completes, transition to onboarding:

"Now that Elle is set up, I'd love to get to know you better so I can be truly helpful. Would you like to spend a few minutes telling me about yourself?"

If YES: Run /personal-assistant:onboard, which will populate context files. After onboarding, run /sync-context to update elle-core.md with the new information.

If NO: Let them know they can run /personal-assistant:onboard anytime, then skip to "After Setup".

After Setup

Let the user know:

  • Elle is now set up and personalized
  • Context is loaded natively via ~/.claude/rules/elle-core.md (no per-message overhead)
  • SessionStart hook checks for upcoming events proactively
  • Context survives compaction automatically
  • Run /sync-context after significant context changes to keep rules current
  • Run /context-health periodically to audit data quality
  • Run /evolve after Claude Code updates to check for new capabilities

Sync Context

Regenerate ~/.claude/rules/elle-core.md from source files in ~/.claude/.context/core/.

What It Does

  1. Reads identity.md, preferences.md, rules.md, projects.md
  2. Generates a compact derived file (~100 lines)
  3. Writes to ~/.claude/rules/elle-core.md
  4. Reports diff of what changed

Run the Script

uv run python ${CLAUDE_SKILL_DIR}/scripts/sync_context.py

After Running

Read the generated file and report what changed:

cat ~/.claude/rules/elle-core.md

Summarize:

  • Number of rules synced
  • Number of active projects listed
  • Whether identity/preferences sections were populated
  • Any warnings (empty sections, missing source files)

When to Run

  • After /update-context changes rules, preferences, or identity
  • After /upgrade completes
  • After manual edits to context files
  • When elle-core.md feels out of sync with your actual context

Context Update

Scan the current conversation and update Elle's context system.

Prerequisites

Check that the context system has been initialized:

ls ~/.claude/.context/

If not, run /personal-assistant:setup first.

Update Flow

1. Read update instructions

Read ~/.claude/.context/context-update.md for the full update philosophy.

2. Scan conversation

Review the current conversation for:

  • New facts about the user (identity, relationships)
  • New preferences or workflow patterns
  • Corrections to Claude's behavior (rules)
  • Project status changes
  • Important dates or deadlines (triggers)
  • Session context updates

3. Classify and route

For each finding, determine the destination file:

TypeDestination
Identity info~/.claude/.context/core/identity.md
Preferences~/.claude/.context/core/preferences.md
Corrections~/.claude/.context/core/rules.md
Workflows~/.claude/.context/core/workflows.md
Relationships~/.claude/.context/core/relationships.md
Dates/deadlines~/.claude/.context/core/triggers.md
Project changes~/.claude/.context/core/projects.md
Session state~/.claude/.context/core/session.md

4. Write confirmed updates

Write updates to the appropriate files. Follow each file's update policy (see context-update.md).

5. Auto-sync

If any of these files were updated:

  • rules.md
  • preferences.md
  • identity.md
  • projects.md

Automatically run the sync-context script to regenerate elle-core.md:

uv run python ${CLAUDE_PLUGIN_ROOT}/skills/sync-context/scripts/sync_context.py

Report what changed in the sync.

6. Summary

Briefly summarize what was updated and which files were modified.

Sponsors

Details

Marketplace
kenneth-liao/ai-launchpad-marketplace
Source
personal-assistant
Category
Community

More from kenneth-liao/ai-launchpad-marketplace

All 5