@peppermint-mcp/wizard 0.1.3 → 0.2.2

package/dist/cli.js

@@ -128,20 +128,28 @@ import { promisify as promisify2 } from "util";
 var exec2 = promisify2(execFile2);
 async function detectCodex() {
   let version;
+  const warnings = [];
   try {
     const { stdout } = await exec2("codex", ["--version"], { timeout: 5e3 });
     version = stdout.trim().split("\n")[0];
   } catch {
     return null;
   }
+  let alreadyInstalled = false;
+  try {
+    const { stdout } = await exec2("codex", ["mcp", "list"], { timeout: 1e4 });
+    alreadyInstalled = stdout.includes("peppermint-memory") || stdout.includes("peppermint");
+  } catch {
+    warnings.push("Could not check existing MCP config");
+  }
   return {
     id: "codex",
     name: "Codex CLI",
     version,
     installMethod: "cli",
-    alreadyInstalled: false,
+    alreadyInstalled,
     needsRestart: false,
-    warnings: []
+    warnings
   };
 }
 
@@ -259,7 +267,7 @@ async function createApiKey(serverBase2, accessToken) {
   return data.raw_key;
 }
 function waitForCallback(port, expectedState) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const timeout = setTimeout(() => {
       server.close();
       reject(new Error("Authentication timed out (5 minutes). Please try again."));
@@ -301,15 +309,15 @@ function waitForCallback(port, expectedState) {
       );
       clearTimeout(timeout);
       server.close();
-      resolve({ code });
+      resolve2({ code });
     });
     server.listen(port, "127.0.0.1");
   });
 }
 async function authenticateWithBrowser(serverBase2) {
   const tempServer = createServer();
-  await new Promise((resolve) => {
-    tempServer.listen(0, "127.0.0.1", () => resolve());
+  await new Promise((resolve2) => {
+    tempServer.listen(0, "127.0.0.1", () => resolve2());
   });
   const port = tempServer.address().port;
   tempServer.close();
@@ -722,6 +730,129 @@ function checkHostConfig(hostId, configPath) {
   }
 }
 
+// src/skills/index.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync7,
+  mkdirSync as mkdirSync4,
+  readdirSync,
+  rmSync,
+  statSync
+} from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname3, join as join7, resolve } from "path";
+import { fileURLToPath } from "url";
+var __dirname = dirname3(fileURLToPath(import.meta.url));
+var LEGACY_SKILLS = [
+  "peppermint-recall",
+  "peppermint-capture",
+  "peppermint-ask-twin"
+];
+function getSkillsBundlePath() {
+  return resolve(__dirname, "..", "skills-bundle", "peppermint");
+}
+function getTargetPath() {
+  return join7(homedir7(), ".claude", "skills", "peppermint");
+}
+function copyDirRecursive(src, dest) {
+  mkdirSync4(dest, { recursive: true });
+  for (const entry of readdirSync(src)) {
+    const srcPath = join7(src, entry);
+    const destPath = join7(dest, entry);
+    if (statSync(srcPath).isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      copyFileSync2(srcPath, destPath);
+    }
+  }
+}
+function removeLegacySkills(dryRun) {
+  const removed = [];
+  const skillsDir = join7(homedir7(), ".claude", "skills");
+  for (const name of LEGACY_SKILLS) {
+    const path = join7(skillsDir, name);
+    if (existsSync7(path)) {
+      if (!dryRun) {
+        rmSync(path, { recursive: true, force: true });
+      }
+      removed.push(name);
+    }
+  }
+  return removed;
+}
+function installSkills(dryRun) {
+  const bundlePath = getSkillsBundlePath();
+  const targetPath = getTargetPath();
+  const alreadyExists = existsSync7(join7(targetPath, "SKILL.md"));
+  if (!existsSync7(bundlePath)) {
+    return { installed: false, updated: false, targetPath, error: "Skills bundle not found in package" };
+  }
+  if (dryRun) {
+    return { installed: true, updated: alreadyExists, targetPath };
+  }
+  try {
+    if (existsSync7(targetPath)) {
+      rmSync(targetPath, { recursive: true, force: true });
+    }
+    copyDirRecursive(bundlePath, targetPath);
+    return { installed: true, updated: alreadyExists, targetPath };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to install skills";
+    return { installed: false, updated: false, targetPath, error: message };
+  }
+}
+
+// src/skills/permissions.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname4, join as join8 } from "path";
+import * as jsonc5 from "jsonc-parser";
+var REQUIRED_PERMISSIONS = [
+  "mcp__peppermint-memory__search",
+  "mcp__peppermint-memory__get",
+  "mcp__peppermint-memory__discover_tools",
+  "mcp__peppermint-memory__ask_twin",
+  "mcp__peppermint-memory__query_integration",
+  "mcp__peppermint-memory__create_memory",
+  "mcp__peppermint-memory__create_fact",
+  "mcp__peppermint-memory__update_memory"
+];
+function getSettingsPath() {
+  return join8(homedir8(), ".claude", "settings.json");
+}
+function installPermissions(dryRun) {
+  const settingsPath = getSettingsPath();
+  try {
+    let content = "";
+    if (existsSync8(settingsPath)) {
+      content = readFileSync7(settingsPath, "utf-8");
+    }
+    const parsed = content ? jsonc5.parse(content) : {};
+    const existingAllow = parsed?.permissions?.allow || [];
+    const toAdd = REQUIRED_PERMISSIONS.filter((p2) => !existingAllow.includes(p2));
+    if (toAdd.length === 0) {
+      return { added: [] };
+    }
+    if (dryRun) {
+      return { added: toAdd };
+    }
+    const newAllow = [...existingAllow, ...toAdd];
+    const edits = jsonc5.modify(content, ["permissions", "allow"], newAllow, {
+      formattingOptions: { tabSize: 2, insertSpaces: true }
+    });
+    const updated = jsonc5.applyEdits(content, edits);
+    const dir = dirname4(settingsPath);
+    if (!existsSync8(dir)) {
+      mkdirSync5(dir, { recursive: true });
+    }
+    writeFileSync4(settingsPath, updated, "utf-8");
+    return { added: toAdd };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Failed to update permissions";
+    return { added: [], error: message };
+  }
+}
+
 // src/cli.ts
 var DEFAULT_SERVER = "https://api.peppermint.com/mcp/";
 function serverBase(serverUrl) {
@@ -832,6 +963,28 @@ Check your internet connection and try again.`
     p.log.info(`  ${icon} ${host.name}  ${pc.dim(result.message)}`);
     results.push({ host, result });
   }
+  const hasClaudeHost = hosts.some(
+    (h) => h.id === "claude-code" || h.id === "claude-desktop"
+  );
+  if (hasClaudeHost) {
+    const removed = removeLegacySkills(options.dryRun);
+    if (removed.length > 0) {
+      p.log.info(`  ${pc.green("\u2713")} Removed legacy skills: ${pc.dim(removed.join(", "))}`);
+    }
+    const skillResult = installSkills(options.dryRun);
+    if (skillResult.installed) {
+      const verb = skillResult.updated ? "Updated" : "Installed";
+      p.log.info(`  ${pc.green("\u2713")} ${verb} Peppermint skill  ${pc.dim(skillResult.targetPath)}`);
+    } else if (skillResult.error) {
+      p.log.info(`  ${pc.red("\u2717")} Skill install failed: ${pc.dim(skillResult.error)}`);
+    }
+    const permsResult = installPermissions(options.dryRun);
+    if (permsResult.error) {
+      p.log.info(`  ${pc.red("\u2717")} Permissions: ${pc.dim(permsResult.error)}`);
+    } else if (permsResult.added.length > 0) {
+      p.log.info(`  ${pc.green("\u2713")} Added ${permsResult.added.length} tool permissions to Claude Code settings`);
+    }
+  }
   if (options.verify && !options.dryRun) {
     p.log.step("Verifying...");
     for (const { host } of results) {
@@ -843,9 +996,7 @@ Check your internet connection and try again.`
   const needRestart = results.filter((r) => r.result.needsRestart);
   const failed = results.filter((r) => !r.result.success);
   p.outro(
-    failed.length > 0 ? pc.red(`${failed.length} host(s) failed. Check the output above.`) : needRestart.length > 0 ? pc.green("Done!") + pc.dim(
-      ` Restart ${needRestart.map((r) => r.host.name).join(", ")} to finish.`
-    ) : pc.green("Done! Peppermint MCP is ready.")
+    failed.length > 0 ? pc.red(`${failed.length} host(s) failed. Check the output above.`) : hasClaudeHost ? pc.green("Done!") + (needRestart.length > 0 ? pc.dim(` Restart ${needRestart.map((r) => r.host.name).join(", ")} to finish.`) : "") + "\n\n  " + pc.cyan("Peppermint skill installed. Start a new Claude Code session and type") + "\n  " + pc.cyan("@pep or /peppermint to begin onboarding.") : needRestart.length > 0 ? pc.green("Done!") + pc.dim(` Restart ${needRestart.map((r) => r.host.name).join(", ")} to finish.`) : pc.green("Done! Peppermint MCP is ready.")
   );
   if (failed.length > 0) process.exit(2);
 }

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@peppermint-mcp/wizard",
-  "version": "0.1.3",
+  "version": "0.2.2",
   "description": "One-command installer for Peppermint MCP across AI coding hosts",
   "type": "module",
   "bin": {
     "peppermint-mcp-wizard": "dist/cli.js"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "skills-bundle/"
   ],
   "scripts": {
     "build": "tsup",

package/skills-bundle/peppermint/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: peppermint
+description: Peppermint memory companion — onboarding, @pep queries, passive capture.
+when_to_trigger: |
+  - User types `@pep <...>` or `/peppermint <...>`
+  - User states a durable preference, rule, or identity claim
+  - User asks about prior work, past decisions, or historical context
+  - User references a teammate's work or asks what someone else is doing
+allowed-tools:
+  - mcp__peppermint-memory__search
+  - mcp__peppermint-memory__get
+  - mcp__peppermint-memory__discover_tools
+  - mcp__peppermint-memory__create_memory
+  - mcp__peppermint-memory__create_fact
+  - mcp__peppermint-memory__update_memory
+  - mcp__peppermint-memory__ask_twin
+  - mcp__peppermint-memory__query_integration
+  - Read
+  - Write
+  - Edit
+---
+
+# Peppermint companion skill
+
+You are an assistant with access to Peppermint — a persistent memory system that captures what the user sees, hears, reads, and works on across their devices. Peppermint stores memories, facts, daily summaries, and integration data (Linear, Asana, Slack, Google Workspace, GitHub).
+
+This skill handles three modes: **onboarding** (first run), **@pep queries** (daily use), and **passive capture** (background).
+
+## 0. Host detection
+
+Detect the host environment:
+- If the user has `~/.claude/CLAUDE.md` or you're running inside Claude Code → **claude-code**
+- If you detect Codex CLI markers → **codex**
+- If you detect Gemini markers → **gemini**
+- Otherwise → **unknown**
+
+For v1, only **claude-code** gets the full onboarding flow. All hosts get `@pep` queries and passive capture.
+
+---
+
+## 1. Onboarding (claude-code only)
+
+### 1.1 Detection — should onboarding run?
+
+Check two signals:
+1. **Server signal:** `search(query="onboarded claude-code", scope="facts", limit=1)` — look for a `skill_state` fact with subject `claude-code`
+2. **File signal:** Check if `~/.claude/CLAUDE.md` contains `<!-- peppermint:onboarded`
+
+| Server fact | File exists | Action |
+|---|---|---|
+| Missing | Missing | Run full onboarding |
+| Present | Present | Skip — print "Peppermint is connected. Use @pep to query your memory." |
+| One missing | One present | Warn about inconsistent state, run onboarding |
+
+### 1.2 Onboarding flow
+
+1. **Greet:** "Setting up Peppermint memory sync for Claude Code."
+
+2. **Parse host memory files:**
+   - Read `~/.claude/CLAUDE.md` (global)
+   - Glob `~/.claude/projects/*/memory/*.md` (project memories)
+   - Extract structured claims using the parse-claims sub-prompt (see `prompts/parse-claims.md`)
+   - Each claim becomes: `{content, inferred_family, confidence}`
+
+3. **Diff against Peppermint graph:**
+   - For each batch of 10 claims, call `search(query=<claim>, scope="facts", limit=3)` in parallel
+   - Categorize each claim using the diff-categorize sub-prompt (see `prompts/diff-categorize.md`)
+   - Categories: ADD (new to Peppermint), UPDATE (refines existing), ADD-to-host (exists in Peppermint but not host), CONFLICT (contradicts), SKIP (trivial/duplicate)
+
+4. **Present summary with top-3 examples per category:**
+   ```
+   Found 23 claims in your Claude Code memory.
+
+   New to Peppermint (8):
+   - "Prefers mental-model-first explanations"
+   - "Uses uv for Python package management"
+   - "Working on Peppermint MCP server architecture"
+   ... and 5 more
+
+   Already in Peppermint (12): synced
+   Conflicts (1): "Role: CTO" vs Peppermint fact "Role: Co-founder & CTO"
+   To add to Claude Code (2): ...
+   ```
+
+5. **Confirm:** Ask "Want me to sync these? I'll save the new claims to Peppermint and update your identity core." Accept freeform confirmation.
+
+6. **Commit:**
+   - Save ADD claims as facts: `create_fact(content=..., fact_family=..., fact_subject=...)`
+   - Save UPDATE claims as facts (upsert behavior)
+   - Resolve CONFLICTs per user instruction
+   - Append the identity core to `~/.claude/CLAUDE.md` inside a marker fence (see identity-core template). If a previous `<!-- peppermint:onboarded` block exists, replace it in-place. This ensures the identity is always in Claude Code's context window.
+   - Save onboarding marker: `create_fact(content="onboarded v=1 date=<today>", fact_family="skill_state", fact_subject="claude-code")`
+
+7. **Post-onboarding training block:**
+   ```
+   ## How to use Peppermint from here on
+
+   **@pep <question>** — Pull memory into a decision in flight. This is the daily driver.
+   Examples: "@pep what was decided about the auth middleware?", "@pep what's PEP-371 status?"
+
+   **@pep ask <teammate> <question>** — Ask a teammate's digital twin.
+   Their twin answers from their memories. They're notified when their twin is queried.
+   Example: "@pep ask Sabrina what's the status of the PII layer fix?"
+
+   **@pep refresh** — Re-sync your identity core when things drift.
+
+   Peppermint also runs passively — it captures durable preferences and decisions
+   you state during normal work, without you having to invoke it.
+   ```
+
+8. **5-section reinforcement summary:** Generate using `prompts/reinforcement.md` and display as a sanity check. Ask "Does this look right?"
+
+---
+
+## 2. @pep handler
+
+Users invoke this via `@pep <question>`, `/peppermint <question>`, or natural language that references prior work/decisions.
+
+### 2.1 Self-query (default): route through ask_twin
+
+For any `@pep <question>` that isn't a sub-command:
+
+1. Call `ask_twin(person="me", question="<the question>", context="<last 3-5 conversation turns if available>")`
+2. This routes through the **exact same pipeline** as the Slack twin:
+   - 7 parallel backend queries (memories, facts, summaries, integrations, routines)
+   - 8-turn agentic Gemini tool loop with 11 tools
+   - Privacy domain filtering
+   - All attribution/commitment/identity rules
+3. Strip the `[<name>'s Twin]` header from the response (self-queries don't need it)
+4. Present the response directly to the user
+
+**Context passing:** When the user has been in a multi-turn conversation before invoking `@pep`, include the last 3-5 turns as the `context` parameter. This helps the twin understand references like "tell me more about that" or "what about the other option?"
+
+### 2.2 Sub-commands
+
+**`@pep ask <person> <question>`**
+1. Call `ask_twin(person="<person>", question="<question>", context="<conversation context>")`
+2. Present with `[<person>'s Twin]` header
+3. **Pass through near-verbatim** — the twin's response already follows attribution/commitment rules. Do NOT:
+   - Add commitments ("they'll get back to you")
+   - Re-attribute ("the team confirmed" when the twin said "Sabrina confirmed")
+   - Re-synthesize or editorialize
+4. On error (twin declined, user not found, no context), show the specific error message from the tool
+
+**`@pep refresh`**
+1. Re-run the onboarding flow (§1.2) without the detection step
+2. Replace the `<!-- peppermint:onboarded ... -->` block in `~/.claude/CLAUDE.md` with the new identity core
+3. Update the `skill_state` fact with new date
+
+**`@pep status`**
+1. Call `get(kind="stats")` for memory stats
+2. Call `search(query="connected", scope="facts", limit=5)` for integration status
+3. Report: memory count, date range, connected integrations, last sync time
+
+---
+
+## 3. Passive capture
+
+During normal conversation (not `@pep` invocations), watch for signals that the user stated something durable. Capture it silently.
+
+### 3.1 Four-signal detection
+
+A statement is worth capturing when ALL of these are true:
+1. **Durable:** Would still be true next week (not "I'm debugging this right now")
+2. **First-person:** The user is stating their own preference/decision/rule (not quoting someone)
+3. **New or contradictory:** Not already captured in Peppermint (quick `search` check)
+4. **Non-trivial:** Would change how an agent assists them ("I prefer TypeScript" yes; "I like coffee" no)
+
+### 3.2 Don't capture list
+
+Never capture:
+- One-off debugging statements ("this variable is null")
+- Emotional reactions ("this is frustrating")
+- Questions the user is asking (they're seeking info, not stating facts)
+- Code snippets or terminal output
+- Anything about family, hobbies, entertainment, health, or personal life
+
+### 3.3 Capture action
+
+When a capturable signal is detected:
+1. Activate the capture pack: `discover_tools(activate=["capture"])`
+2. Determine if it's a new fact or memory:
+   - **Facts** (durable identity/preference/role): `create_fact(content=..., fact_family=..., fact_subject=...)`
+   - **Memories** (decisions, commitments, project context): `create_memory(content=..., tags=[...], importance=0.7)`
+3. If contradicting an existing fact: note inline — "Updated your preference from X to Y in Peppermint."
+4. If new: capture silently (no notification to user)
+
+### 3.4 Budget
+
+- Max 1 capture per conversation turn
+- Max 15 captures per session
+- If budget exhausted, stop watching (don't queue)
+
+---
+
+## 4. Error handling
+
+| Error | Action |
+|---|---|
+| MCP server unreachable | Print "Peppermint is offline — memory features unavailable this session." Disable capture for the session. |
+| `ask_twin` returns decline | Print "[person]'s twin doesn't have enough context to answer that right now." |
+| `ask_twin` user not found | Print "No one matching '[person]' found in your organization." |
+| `ask_twin` no org | Print "You need to be part of an organization to query teammates' twins." |
+| `search` returns empty | Answer from conversation context alone, note "No relevant memories found in Peppermint." |
+| Onboarding — < 10 facts | Run onboarding but note: "Your Peppermint memory is still building up. The more you use your devices with Peppermint running, the richer your memory gets." |

package/skills-bundle/peppermint/identity-core.md

@@ -0,0 +1,55 @@
+# Identity core template
+
+This template is used by the Peppermint skill to generate the identity core block
+appended to `~/.claude/CLAUDE.md`. The skill fills in each section from the user's
+Peppermint fact graph, wraps it in marker fences, and appends it to CLAUDE.md
+(or replaces an existing block on refresh).
+
+## Output format
+
+```markdown
+<!-- peppermint:onboarded v=1 date=YYYY-MM-DD -->
+## Peppermint identity core
+
+### Who you are at work
+- Role: {current_role fact}
+- Company: {current_employer fact}
+- Department: {department fact}
+- Expertise: {expertise facts, comma-separated}
+
+### How you work
+- {preference facts — tools, languages, workflows}
+- {routine facts — daily patterns, work hours}
+
+### Who you work with
+- {team_membership facts — direct collaborators, max 5}
+- {reporting_structure facts}
+
+### What you're working on
+- {current_work facts, max 5 most recent}
+- {project_assignments facts}
+- {current_blocker facts if any}
+
+### Rules and preferences
+- {preference facts that are rules — "always do X", "never do Y"}
+- {identity facts that constrain behavior}
+<!-- peppermint:end -->
+```
+
+## Token budget
+
+Target: 500-800 tokens. Hard cap: 800 tokens.
+
+### Priority cuts (when over budget)
+
+1. Cut oldest "What you're working on" items (keep max 5)
+2. Cut collaborators beyond top 5
+3. Cut lowest-frequency rules/preferences
+4. Cut department/reporting_structure if space is tight
+
+### Work-relevance test
+
+For each fact, ask: "Would knowing this change the agent's advice on a coding task?"
+
+**Include:** role, tools, languages, frameworks, team, active projects, coding preferences, communication style
+**Exclude:** family, hobbies, entertainment, health, food preferences, personal life

package/skills-bundle/peppermint/prompts/diff-categorize.md

@@ -0,0 +1,41 @@
+# Diff and categorize claims against Peppermint graph
+
+Given a set of claims extracted from host memory files and the Peppermint search results for each, categorize what action to take.
+
+## Input
+
+For each claim, you receive:
+- The claim: `{content, inferred_family, confidence}`
+- Search results from Peppermint: 0-3 matching facts with content and similarity
+
+## Categories
+
+- **ADD** — Claim is new. No matching fact in Peppermint. Save it.
+- **UPDATE** — Claim refines or updates an existing Peppermint fact (same topic, newer/more specific info). Save as update.
+- **ADD-to-host** — Peppermint has this fact but the host memory file doesn't. Note for the user (don't auto-write to host files).
+- **CONFLICT** — Claim contradicts a Peppermint fact (e.g., different role, different preference). Flag for user resolution.
+- **SKIP** — Claim is a near-duplicate of an existing fact, or too low-confidence to act on.
+
+## Rules
+
+1. **Semantic matching, not string matching.** "Uses TypeScript" and "Prefers TypeScript for new projects" are the same fact (SKIP or UPDATE depending on specificity).
+
+2. **Recency wins for current_work, current_blocker, project_assignments.** If the claim is more recent than the Peppermint fact, categorize as UPDATE.
+
+3. **CONFLICTs require genuine contradiction.** "CTO" vs "Co-founder & CTO" is not a conflict — it's an UPDATE (more specific). "CTO" vs "VP Engineering" IS a conflict.
+
+4. **Low-confidence claims:** If `confidence=low` and there's no matching Peppermint fact, categorize as SKIP (don't pollute the graph with weak signals).
+
+5. **ADD-to-host is informational only.** The skill doesn't auto-write to CLAUDE.md or project memory files. It just tells the user "Peppermint knows X that your Claude Code memory doesn't."
+
+## Output
+
+For each claim, output:
+```json
+{
+  "claim": "...",
+  "category": "ADD | UPDATE | ADD-to-host | CONFLICT | SKIP",
+  "reason": "one-line explanation",
+  "matching_fact_id": "uuid or null"
+}
+```

package/skills-bundle/peppermint/prompts/parse-claims.md

@@ -0,0 +1,59 @@
+# Parse claims from host memory files
+
+Given the content of a user's memory file (CLAUDE.md, project memory, etc.), extract structured claims about the user.
+
+## Input
+
+The raw text content of one or more memory files.
+
+## Output
+
+A JSON array of claims:
+```json
+[
+  {
+    "content": "Prefers TypeScript over JavaScript for new projects",
+    "inferred_family": "preference",
+    "confidence": "high"
+  },
+  {
+    "content": "Currently working on Peppermint MCP server architecture",
+    "inferred_family": "current_work",
+    "confidence": "medium"
+  }
+]
+```
+
+## Rules
+
+1. **Extract only durable claims** — skip ephemeral task notes, debugging context, and conversation-specific instructions.
+
+2. **Map to fact families:**
+   - `identity` — who the user is (name, background, education)
+   - `preference` — how they like things done (tools, patterns, styles, rules)
+   - `routine` — recurring patterns (daily standup time, review process)
+   - `current_work` — what they're actively building/fixing
+   - `current_employer` — company name
+   - `current_role` — job title
+   - `current_blocker` — things blocking progress
+   - `team_membership` — direct collaborators
+   - `reporting_structure` — who reports to whom
+   - `department` — organizational unit
+   - `expertise` — skills and domain knowledge
+   - `project_assignments` — projects they're on
+
+3. **Confidence levels:**
+   - `high` — explicitly stated ("I prefer X", "Always use Y")
+   - `medium` — strongly implied by context (listed in preferences section)
+   - `low` — weakly implied (mentioned once in passing)
+
+4. **Skip these:**
+   - Code snippets and command examples (these are documentation, not claims)
+   - Tool configuration details (file paths, API endpoints)
+   - Instructions to the AI that aren't about the user ("don't use emojis" is a preference; "respond in JSON" is a formatting instruction)
+
+5. **Normalize:** Write claims as standalone sentences that make sense without the source file context.
+
+6. **Deduplicate:** If the same fact appears multiple times across files, emit it once with the highest confidence.
+
+7. **Work-relevance filter:** Would knowing this change the agent's advice on a work task? If no, skip it. Family, hobbies, entertainment, health, and personal life are always excluded.

package/skills-bundle/peppermint/prompts/reinforcement.md

@@ -0,0 +1,50 @@
+# Generate 5-section reinforcement summary
+
+After onboarding, generate a human-readable summary of what Peppermint knows about the user. This serves as a sanity check — the user reviews it and corrects anything wrong.
+
+## Input
+
+The user's Peppermint facts, organized by family. Fetched via:
+- `search(query="identity role employer", scope="facts", limit=20)`
+- `search(query="preference routine workflow", scope="facts", limit=20)`
+- `search(query="team collaborator manager", scope="facts", limit=20)`
+- `search(query="current work project blocker", scope="facts", limit=20)`
+
+## Output format
+
+```
+Here's what Peppermint knows about you:
+
+**Who you are at work**
+[Role, company, department, expertise — 2-4 bullets]
+
+**How you work**
+[Tools, languages, workflows, patterns — 3-5 bullets]
+
+**Who you work with**
+[Key collaborators, team, reporting — 2-4 bullets]
+
+**What you're working on**
+[Active projects, current focus — 2-5 bullets]
+
+**Rules and preferences**
+[Coding style, communication preferences, hard rules — 2-5 bullets]
+
+Does this look right? Tell me if anything is wrong or missing.
+```
+
+## Rules
+
+1. **Natural language, not raw facts.** Don't say "fact_family: preference, content: uses uv". Say "You use uv for Python package management."
+
+2. **Group related facts.** If there are 3 facts about Python tooling, combine them into one bullet.
+
+3. **Prioritize by work relevance.** Lead each section with the most impactful facts.
+
+4. **Cap each section at 5 bullets.** If more facts exist, pick the highest-value ones.
+
+5. **Work-relevance filter.** Exclude family, hobbies, entertainment, health. If a fact slipped through, drop it silently.
+
+6. **Acknowledge gaps.** If a section is empty (e.g., no team_membership facts), say "Not enough data yet — this section will fill in as Peppermint learns more."
+
+7. **Tone:** Direct, professional, second-person ("You work at...", "Your team includes..."). Not formal, not casual.