# Lore > SpecStory Lore - mine your SpecStory coding histories (any agent - Claude Code, Codex, Cursor, Gemini, and more) into a persistent corpus, surface your reproducible workflows with corroborated evidence, and interactively forge the chosen ones into skills installed across all your agent harnesses. Use when the user wants to turn past AI coding sessions into reusable skills, asks "what could I make… - **Type:** Skill - **Install:** `agentstack add skill-specstoryai-getspecstory-lore` - **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior - **Seller:** [specstoryai](https://agentstack.voostack.com/s/specstoryai) - **Installs:** 0 - **Category:** [Developer Tools](https://agentstack.voostack.com/c/developer-tools) - **Latest version:** 0.1.0 - **License:** Apache-2.0 - **Upstream author:** [specstoryai](https://github.com/specstoryai) - **Source:** https://github.com/specstoryai/getspecstory/tree/dev/lore - **Website:** https://specstory.com/ ## Install ```sh agentstack add skill-specstoryai-getspecstory-lore ``` Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent. ## About # Lore Your sessions are your lore. This skill turns a user's real coding history into installed skills. A deterministic engine (`scripts/mine-skills.mjs`) parses their SpecStory transcripts - from **every agent** SpecStory captures (Claude Code, Codex CLI, Cursor CLI, Gemini CLI, Factory Droid, DeepSeek, Antigravity, ...) - into a persistent corpus of **beats**, and returns corroborated candidates. You - the calling agent, whichever harness you are - supply all judgment: name them, discard the generic ones, and interactively forge the good ones into `SKILL.md` packages grounded in the user's own commands. The engine does the retrieval and counting; **you do the synthesis.** Do not try to read raw transcripts yourself - they can be hundreds of thousands of lines. Run the engine and work from its output. This skill is **harness-portable** (agentskills.io format). Where it names a specific tool (e.g. `AskUserQuestion`), treat that as "use your harness's equivalent; fall back to plain chat." **Voice:** when narrating to the user, talk about *mining their lore* and *skill candidates* - e.g. "I'll mine your lore here in for skill candidates." Reserve the word **forge** for the final act only: creating the skills the user selected (Step 4). Never describe mining, judging, or candidates as "forge-…" anything. ## OUTPUT CONTRACT - three LAWS, read before emitting anything to the user **Named failure mode #1 (2026-06-09, BearClaude run):** the agent indexed, deep-mined four skills, then jumped straight to AskUserQuestion with bare option labels - ZERO dossiers rendered in chat. The user declined every question because they had nothing to judge by. The entire mining run was wasted. **Named failure mode #2 (2026-06-09, BearClaude run, SAME DAY, fresh session, LAWs in effect):** the agent narrated phases correctly, did verification reads, then asked again with NO dossier message - its last message before the question was process narration ("CodeMirrorBundle is alive in today's repo…") - and the question text falsely claimed "dossiers above". Lesson: a *felt* self-check is not a check. Compliance must be MECHANICAL: the sentinel line below is the check, not your impression. **Named failure mode #3 (2026-06-10, teammate's machine, Opus 4.8, plan-mode path):** the agent DID use plan-mode curation but presented a THIN plan - skill names and skip reasons with the dossiers summarized away - so the user approved a forge they never saw the evidence for. The plan UI makes skipping the *display step* impossible, not skipping the *content*. Lesson: the plan body must BE the engine's `plan render` artifact (Step 3), which embeds every card verbatim and ends with the LAW 1 sentinel. In Claude Code this is now HOOK-ENFORCED: a PreToolUse hook in this skill's frontmatter denies any `ExitPlanMode` whose plan is not that artifact. **LAW 1 - DOSSIERS BEFORE CANDIDATE QUESTIONS, PROVEN BY SENTINEL.** This law governs **candidate decisions** - any prompt where the user chooses which skills to forge, skip, or update. (Navigation questions like the Step 0.25 guided start, or scope confirmations, are exempt - they decide nothing about candidates.) Before any candidate prompt you must emit one chat message that contains a full dossier block (`### …`, per Step 3) for EVERY candidate, and that message must END with this exact line: ``` === dossiers above: N === ``` where N equals the number of candidates you are about to offer. At the moment of asking, the check is mechanical: *"Does a prior message of mine end with `=== dossiers above: N ===` and does N match my option count?"* No sentinel → you have not rendered dossiers, whatever you remember - STOP and write them. Process narration between tool calls does NOT count; interim notes do NOT count. **The strongest form of LAW 1 is plan-style curation (Claude Code, see Step 3): present the dossiers AS the plan via `ExitPlanMode` - then showing the evidence and asking for the decision are the same act, and skipping the display is structurally impossible.** But the plan only enforces that *something* is shown, not *what* (failure mode #3): the plan body must embed the engine-rendered dossier cards verbatim and end with the sentinel, same mechanical check as chat. The sentinel path alone is the fallback for harnesses without plan mode. **LAW 2 - RENDER THE ENGINE'S VISUALS VERBATIM, IN A REAL MESSAGE.** After the report, you must emit a user-facing mining summary MESSAGE (tool output alone does not count - the user should not need to expand collapsed tool results). It opens with the engine's `📜 lore · …` badge line and ends with the `` block, both verbatim. The same rule covers every PASS-THROUGH block the engine emits (STATUS, THEMES, DOSSIERS). Going tool → tool → question with no synthesis message in between is failure mode #2. **LAW 3 - NARRATE PHASES.** Before every long-running engine or deep-mine call, emit one short status line so the window always shows what is happening: `📜 indexing BearClaude (253 sessions)…`, `📜 deep-mining 4 clusters (this runs subagents; a few minutes)…`, `📜 checking the forged-skill registry…`. Never leave the user staring at a silent tool call. ## What makes a candidate skill-worthy A reproducible skill is a behavior that **recurs, is regular, and has a clear trigger**. The engine scores for recurrence/span/recency/specificity/outcomes; you apply the judgment it cannot: - **Keep it** when the procedure is distinctive and specific to how this user/project works (e.g. `supabase link → supabase db → supabase migration`, `gh run watch` CI-watching, "write a comprehensive commit", "fix git divergence against origin/main", a read-only diagnosis). - **Discard it** when it is generic to all coding and carries no project-specific procedure (e.g. bare `git status → git diff`, a lone "yes"/"do 1,2,3" confirmation). High session counts alone do not make a skill - ubiquity is not a trigger. In **cross-project mode** the engine splits candidates into **PORTABLE** (recurs across ≥2 projects) and **PROJECT-SPECIFIC** (one project). Portability is the strongest signal of a real transferable skill: forge PORTABLE ones to the personal canonical dir and PROJECT-SPECIFIC ones into that repo. **Authorship (shared repos):** committed histories carry their session owner - the engine attributes every session (git add-author > home-dir sniff > machine user) and candidates show `👥 N authors` when several people exhibit the behavior. Use it: - **Multi-author candidate** = a TEAM practice, the strongest forge signal of all - propose it at project scope (committed `.claude/skills`) so the whole team benefits. - **Single-author, and it's the current user** = personal candidate, personal scope. - **Single-author, a TEAMMATE's** = say so plainly in the dossier ("mined from Jake's sessions") and recommend team scope or checking with them before forging it as the user's own practice. Never present a teammate's workflow as the user's. - **Privacy:** teammate names may appear in team-scoped (committed) skills; scrub them from personal-scope skills. Note on the evidence: every command candidate comes from an actually-executed shell `` block (detected by the provider-set `data-tool-type="shell"` attribute, so it works for Bash, Shell, run_shell_command, exec_command, and every other provider's runner). It is real agent activity, not a pasted example. Single-line commands (inline backtick or in the tool ``) and multi-line ```bash blocks are read alike. ## Process ### Step 0 - Locate the history directory(ies) Default to `.specstory/history` in the current project - but **check for nested histories first** (monorepos keep them in sub-packages too): ```zsh find . -type d -path '*/.specstory/history' -not -path '*/node_modules/*' 2>/dev/null | head ``` If more than one shows up, use `--scan .` (any-depth discovery, includes the root's own history). For **cross-project trends** across sibling repos, pass several `--dir` flags, one `--projects `, or `--scan `. If no history exists anywhere, tell them SpecStory records sessions and stop. ### Step 0.25 - Guided start (when invoked with NO arguments) A bare `/lore` means the user wants to be walked through it. Ask ONE structured question round (`AskUserQuestion` with three questions; plain numbered lists on harnesses without it), then proceed - do not make them learn the argument grammar: 1. **Scope** (header "Scope"): "This project (Recommended)" → cwd history, auto-`--scan .` if nested histories exist · "All my repos under a folder" → ask which parent, then `--scan ` · "Just the existing corpus" → skip indexing, report on `~/.specstory/lore.db` directly. 2. **Window** (header "Window"): "All time (Recommended)" · "Last 30 days" → `--days 30` · "Last 90 days" → `--days 90`. 3. **Goal** (header "Goal"): "Find & forge skills (Recommended)" → full pipeline · "Just show me candidates" → stop after dossiers, no forging · "Status / what has Lore done" → run `status` and render it verbatim (LAW 2), nothing else · "Reset my lore" → confirm, then `reset`. This is a navigation question, not a candidate decision - LAW 1 does not apply to it. After the answers, echo the resolved interpretation in one line (per Step 0.5) and run. If the user typed ANY arguments, skip this step entirely and interpret them via Step 0.5. ### Step 0.5 - Interpret the user's input Map what the user typed to engine flags / process modes. If they gave nothing, Step 0.25 already collected the choices. | User says | Do | |---|---| | a path, "this project", nothing | `--dir ` (default `.specstory/history`); if nested histories exist, `--scan .` | | "across my projects in ~/code", "compare A and B" | `--projects ` or repeated `--dir` (cross-project mode) | | "find all histories in here", monorepo with sub-package histories | `--scan ` (any depth, root's own history included) | | "last 30 days", "since April" | `--days N` | | "only the frequent ones", "did it 10+ times" | raise `--min-sessions N` | | "just runbooks", "only command procedures" | `--kind cmd` (or `runbook` for cmd+task+corr) | | "only how I work", "just meta-skills" | `--kind meta` | | "about supabase", "migration skills", "focus on X" | `--filter ` | | "just show me candidates", "don't forge", "dry run" | run engine + synthesize (Steps 1–2b), then STOP - skip curate/forge | | "status", "what have you done", "what's in my lore" | `status` - render the pass-through view verbatim | | "what skills do I have", "show my skills", "list my forged skills" | `skills` - the installed-skills inventory (lore-forged with registry health + every other skill found in the harness dirs, with what each does); render verbatim (LAW 2) | | "show me the last plan", "recall the candidates", "pick up where we left off" | `plan last` - re-renders the most recent saved plan against the current corpus; continue at Step 3 curation (no re-mining, no re-judging) | | "reset my lore", "start fresh", "wipe everything" | `reset` (destructive: deletes the corpus, dossier cache, and forged registry - CONFIRM with the user first; add `--and-skills` only if they explicitly want forged skill files removed too) | | "forge them all", "skip the questions" | still confirm scope once, but you may batch - do not silently write without any confirmation | Echo back the resolved interpretation in one line before running (e.g. "Mining ~/code cross-project, last 60 days, command runbooks about supabase"). ### Step 1 - Index, then report (two engine commands) The engine keeps the user's lore at `~/.specstory/lore.db` (override with `--db`). It segments every session into **beats** (intent → agent method → outcome, where the outcome label comes from the user's NEXT reply: approval = success, steering correction = corrected). Indexing is incremental - unchanged sessions are skipped, so re-running is cheap. Transcripts from ALL agents accumulate into the same lore; each session is tagged with its agent (claude-code, codex-cli, cursor-cli, ...). ```zsh # 1. index (repeat --dir per project, or --projects to scan many repos) node "/scripts/mine-skills.mjs" index --dir node "/scripts/mine-skills.mjs" index --projects # 2. report candidates (filters: --days, --min-sessions, --top, --kind cmd,task,meta,corr, --filter ) node "/scripts/mine-skills.mjs" report --min-sessions 3 --top 10 ``` (Legacy one-shot `--dir` without a subcommand does index + report together.) The report is wrapped in `` markers - raw evidence for you, not the user (`--emit=json` for structured output). It has four sections; **read CORROBORATED first**: - **CORROBORATED** - intent × procedure pairs co-occurring in the *same beats*, with outcome rates. These are pre-verified deep-skill seeds: the user *asked* for X and the agent *did* Y, repeatedly. - **RUNBOOKS** - executed command procedures (single-channel). - **INTENTS** - recurring prompt task-types (single-channel). - **META-SKILLS** - ways-of-working detectors. Each evidence line carries `path:line [outcome] intent=… cmds=…` - an beat you can open directly. **Re-running is safe and expected.** Indexing is idempotent: unchanged sessions are skipped (fingerprint = size + mtime + parser version); new sessions are appended; grown/edited sessions are replaced whole; engine upgrades re-parse the whole corpus automatically (one-time). `--force` re-indexes everything; `prune` drops sessions whose transcript files no longer exist and flags duplicate project identities (e.g. a repo that later gained a git remote and thus a new `git_id`). Run `prune` if the user has deleted or reorganized histories. ### Step 2 - Synthesize candidate skills From the evidence block, produce a shortlist of real skill proposals. For each kept candidate: - **name** - a kebab verb-phrase (e.g. `verify-go-changes`, `comprehensive-commit`, `fix-git-divergence`). - **description (the trigger)** - a one-line "Use when…" matched to how the behavior actually shows up in the evidence quotes. This is the most important field; it is what makes the skill discoverable. - **procedure** - the steps, taken from the user's real command sequence or task shape. Do not invent steps; ground them in the evidence. Open the cited `path:line` refs (read the file at that span) if you need to confirm the exact commands before writing them into a skill. - **kind** - runbook (a command procedure / task type) or meta-skill (a way of working). - **scope** - personal (canonical `~/.agents/skills`, fanned out to all harnesses) or project (`/.claude/skills` or the repo's equivalent, committed for the team). Discard generic and weak candidates explicitly; tell the user what you dropped and why. **Skill-level idempotency - consult the registry first.** Lore remembers what it has already forged and what the user has declined. Before proposing anything, run: ```zsh node "/scripts/mine-skills.mjs" forged check --emit json ``` and obey each row's `recommendation`: - `up-to-date` - the forged skill's cluster is unchanged: exclude it from candidates entirely. - `update: N new corrected beat(s), sessions A→B` - the evidence grew materially since forging: propose an **update to the existing skill** (deep-mine the cluster, diff the new failure modes / steps into the installed SKILL.md), never a duplicate. - `update-carefully (user hand-edited the file)` - same, but present the diff and let the user apply; do not overwrite their edits. - `suppress: user declined...` - do NOT re-propose; mention it only in the discard list ("declined previously, evidence unchanged"). - `re-engage: evidence grew materially since the user declined` - you MAY re-propose, saying exactly what changed since they said no. - `orphaned` - the skill file was deleted; offer to re-forge or forget it. Also `ls ~/.agents/skills/` for skills NOT authored by Lore (no registry row) - match those by name and skip duplicates. Re-running /lore today, tomorrow, o … ## Source & license This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code. - **Author:** [specstoryai](https://github.com/specstoryai) - **Source:** [specstoryai/getspecstory](https://github.com/specstoryai/getspecstory) - **License:** Apache-2.0 - **Homepage:** https://specstory.com/ Install and usage instructions live in the source repository linked above. ## Pricing - **Free** — Free ## Security capabilities Automated source analysis of v0.1.0 — what this tool can access: - **Network access:** no - **Filesystem access:** no - **Shell / process execution:** no - **Environment & secrets:** no - **Dynamic code execution:** no *"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.* ## Versions - **0.1.0** — security scan: passed — Imported from the upstream source. ## Links - Listing page: https://agentstack.voostack.com/l/skill-specstoryai-getspecstory-lore - Seller: https://agentstack.voostack.com/s/specstoryai - Browse the marketplace: https://agentstack.voostack.com/browse --- Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.