skillscout-cli 0.2.0__tar.gz → 0.3.0__tar.gz

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: skillscout-cli
-Version: 0.2.0
-Summary: Keep your agent's skills current: weekly discovery, upstream diffs, safety scans, pinned installs
+Version: 0.3.0
+Summary: Keep your agent's skills current for each kind of work you do: weekly index, personas, scans, pinned installs
 Author: Akshit Gupta
 License-Expression: MIT
 Project-URL: Homepage, https://akshit9162.github.io/skillscout
 Project-URL: Source, https://github.com/akshit9162/skillscout
 Project-URL: Issues, https://github.com/akshit9162/skillscout/issues
 Project-URL: Report, https://akshit9162.github.io/skillscout/report.html
-Keywords: claude,claude-code,agent-skills,security,supply-chain,llm
+Keywords: claude,claude-code,agent-skills,personas,subagents,security,supply-chain,llm
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -34,6 +34,7 @@ Dynamic: license-file
   <a href="https://akshit9162.github.io/skillscout">Website</a> &ensp;·&ensp;
   <a href="https://akshit9162.github.io/skillscout/report.html">Report: what's inside 6,726 skills</a> &ensp;·&ensp;
   <a href="#install">Install</a> &ensp;·&ensp;
+  <a href="#personas">Personas</a> &ensp;·&ensp;
   <a href="#a-week-with-skillscout">A week with it</a> &ensp;·&ensp;
   <a href="#how-it-works">How it works</a> &ensp;·&ensp;
   <a href="#what-gets-flagged">What gets flagged</a>
@@ -47,7 +48,7 @@ Dynamic: license-file
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/akshit9162/skillscout/main/docs/assets/demo.svg" width="760" alt="Terminal demo: discover finds 216 recommended skills with 89 flagged high-risk; a high-risk skill is refused without --accept-risk; a low-risk one installs pinned to a commit" />
+  <img src="https://raw.githubusercontent.com/akshit9162/skillscout/main/docs/assets/demo.svg" width="760" alt="Terminal demo: init drafts keywords from one line; persona add creates a brand persona; discover scores 23,865 skills with a section for the brand persona; persona build writes its agent; claude --agent brand starts it" />
 </p>
 
 ```bash
@@ -60,28 +61,68 @@ AI tooling moves weekly. New skills, plugins and agent workflows land on GitHub
 installed keep changing upstream, and last month's best practice is already stale. Nobody has time to
 watch hundreds of repos.
 
-**skillscout keeps your agent current.** Once a week it checks the skill ecosystem against what *you*
-work on, tells you what's new and worth having, and shows you exactly what changed in the skills you
-already use.
+**skillscout keeps your agent current, for each kind of work you do.** Every week a shared index of every
+public skill it can find (23,865 from 1,092 repos at the last build) is rebuilt. skillscout scores it on your
+machine against what *you* work on, tells you what's new and worth having, and shows you exactly what
+changed in the skills you already use.
+
+You probably don't do one kind of work. Coding on Monday, a landing page on Tuesday, investor emails on
+Friday. So skillscout keeps **personas**: one per kind of work, each with its own search and its own Claude
+Code agent, loaded with the best skills for that work and kept up to date as better ones appear.
 
 Keeping up fast is only useful if it's safe. A skill is a set of instructions your agent follows
 **with your permissions**, so skillscout scans every file for dangerous patterns, installs nothing without
 your approval, pins each install to an exact commit, and re-scans every update before it can replace anything.
 
-In one run over the public ecosystem it found **6,726 skills in 95 repos**. 198 had at least one high-risk flag,
+In a hand-checked run on 27 Oct 2026 over **6,726 skills in 95 repos**, 198 had at least one high-risk flag,
 mostly `sudo` and `curl | sh` install steps, plus prompt-injection-style text and hidden Unicode.
 The [report](https://akshit9162.github.io/skillscout/report.html) reads every one of the scariest flags: they were defenders.
 
 It's a zero-dependency Python CLI, and it also ships as a skill, so your agent can run the whole loop for you
 and still ask before every install.
 
+## Personas
+
+A persona is one side of your work, in your words. skillscout doesn't ship any: yours might be "builder",
+"brand" and "outreach", someone else's "trading" and "thesis".
+
+```text
+You     "set up personas for me"           (in Claude Code, with the plugin)
+Agent   reads your recent sessions on this machine, with your OK (skillscout history)
+        → proposes: builder · brand · outreach, each with the sessions it came from
+You     keep brand and builder, rename outreach to launches
+Agent   skillscout persona add brand --about "D2C marketing: ad copy, landing pages, Instagram reels"
+        → keywords drafted from terms skills actually use: instagram reels, ad copy, landing pages...
+        skillscout discover                → a "For your brand work" section in the report
+        skillscout persona build brand     → ~/.claude/agents/brand.md, skills: copy, landing-page-design, script...
+You     claude --agent brand
+```
+
+From then on, each weekly report has a section per persona, and `persona build` swaps in a better skill when
+one arrives (after you've read and approved it). `persona build` only ever rewrites the agent's `skills:` list:
+its prompt, tone, tools, model and memory are yours.
+
+The CLI works without the agent too:
+
+```sh
+skillscout persona add brand --about "D2C marketing: ad copy, landing pages, Instagram reels"
+skillscout persona list            # keywords, best installed skills, what's worth installing
+skillscout persona build --all     # write or update ~/.claude/agents/<name>.md
+```
+
+**Your history stays on your machine.** `skillscout history` reads `~/.claude/projects` only when you run it,
+keeps only what you typed (no tool output, no pasted blocks, no links) and sends nothing anywhere. Grouping
+sessions into personas is left to you or the agent in your own session: counting words can't tell short chat
+messages apart reliably, and a wrong persona is worse than none.
+
 ## A week with skillscout
 
 Example session (counts vary week to week):
 
 ```text
 Monday 10:00   skillscout discover --notify     (weekly, via schedule)
-               → "4 new, 23 recommended, 11 flagged high-risk"
+               → "23 recommended for you (4 new this run), 11 relevant but flagged high-risk"
+               → plus a section per persona: "For your brand work", "For your builder work"
 You            skillscout show github/awesome-copilot:eval-driven-dev
                → flags with file:line, the full SKILL.md, overlaps with what you have
 You            skillscout approve eval-driven-dev   → copied, pinned to its commit
@@ -98,17 +139,18 @@ claude plugin marketplace add akshit9162/skillscout
 claude plugin install skillscout@skillscout
 ```
 
-Then ask: *"find me skills for my Python and React work"*. The agent installs the CLI, runs the search,
+Then ask: *"find me skills for my Python and React work"*, or *"set up personas for me"*. The agent installs the CLI, runs the search,
 summarises the report and shows you each skill's flags before asking to install it.
 
 ### As a CLI
 
 ```sh
 pipx install skillscout-cli     # or: uv tool install skillscout-cli
-skillscout init                                              # writes ~/.skillscout/profile.toml
+skillscout init --about "backend in Python, code review, RL evals, Postgres"
 ```
 
-Edit `[keywords]` in `~/.skillscout/profile.toml` with the words from your own work, then:
+`init` writes `~/.skillscout/profile.toml` and drafts `[keywords]` from your line, using only terms that skills
+actually use. Check them, then:
 
 ```sh
 skillscout discover          # score this week's index; writes ~/.skillscout/reports/<date>.md
@@ -167,6 +209,11 @@ High-risk skills need `--accept-risk`, which the bundled skill tells the agent n
 | `skillscout approve <id> [--update] [--accept-risk] [--to DIR]` | Install and pin. `--to`, or `dir` under `[install]` in your profile, installs into another agent's skills folder |
 | `skillscout installed` · `skillscout remove <id>` · `skillscout rollback <id>` | Pinned skills · uninstall · undo the last update |
 | `skillscout updates` | Diff pinned skills against upstream |
+| `skillscout init [--about "..."]` | Write the profile; `--about` drafts your keywords from one line |
+| `skillscout history [--days N]` | A local digest of your recent Claude Code sessions, to draft personas from |
+| `skillscout persona add <name> --about "..." [--keywords "a=3,b=2"]` | Add a persona; keywords drafted from the line unless given |
+| `skillscout persona list` | Each persona: keywords, best installed skills, what's worth installing |
+| `skillscout persona build <name> \| --all [--dry-run]` | Write `~/.claude/agents/<name>.md`, or update only its `skills:` list |
 | `skillscout schedule` | Set up weekly discovery: launchd on macOS, a systemd timer on Linux (cron line without systemd), a `schtasks` command on Windows. It prints the one command that turns it on |
 
 With the index, `discover` makes no GitHub API calls at all. For `--local` and `index`, set `GITHUB_TOKEN`, or just be logged in with the GitHub CLI (`gh auth login`), for higher API rate limits (5,000 requests an hour instead of 60). Following lists costs one lookup per linked repo: up to 1,500 a run with a token, 40 without; links not yet checked go first, so later runs reach the rest. A token is optional: without it, a rate limit means waiting rather than failing. A weekly run with few upstream changes takes about 25 seconds; the first run takes a few minutes. Scheduled jobs don't see your shell's environment, so add the token to the job if you want it there.
@@ -177,6 +224,7 @@ With the index, `discover` makes no GitHub API calls at all. For `--local` and `
 - Relevance is keyword matching against your profile, not semantic search. Tune the weights.
 - The scanner is pattern rules, deliberately: a skill is text written to steer a model, so a model judging it can be steered by it. The rules make you read; they don't decide.
 - Every installed skill's description loads into every agent session. Keep the total to a few dozen.
+- A persona's `skills:` load in full when its agent starts. `max_skills` (default 5) keeps that small.
 
 ## Development
 

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/README.md

@@ -6,6 +6,7 @@
   <a href="https://akshit9162.github.io/skillscout">Website</a> &ensp;·&ensp;
   <a href="https://akshit9162.github.io/skillscout/report.html">Report: what's inside 6,726 skills</a> &ensp;·&ensp;
   <a href="#install">Install</a> &ensp;·&ensp;
+  <a href="#personas">Personas</a> &ensp;·&ensp;
   <a href="#a-week-with-skillscout">A week with it</a> &ensp;·&ensp;
   <a href="#how-it-works">How it works</a> &ensp;·&ensp;
   <a href="#what-gets-flagged">What gets flagged</a>
@@ -19,7 +20,7 @@
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/akshit9162/skillscout/main/docs/assets/demo.svg" width="760" alt="Terminal demo: discover finds 216 recommended skills with 89 flagged high-risk; a high-risk skill is refused without --accept-risk; a low-risk one installs pinned to a commit" />
+  <img src="https://raw.githubusercontent.com/akshit9162/skillscout/main/docs/assets/demo.svg" width="760" alt="Terminal demo: init drafts keywords from one line; persona add creates a brand persona; discover scores 23,865 skills with a section for the brand persona; persona build writes its agent; claude --agent brand starts it" />
 </p>
 
 ```bash
@@ -32,28 +33,68 @@ AI tooling moves weekly. New skills, plugins and agent workflows land on GitHub
 installed keep changing upstream, and last month's best practice is already stale. Nobody has time to
 watch hundreds of repos.
 
-**skillscout keeps your agent current.** Once a week it checks the skill ecosystem against what *you*
-work on, tells you what's new and worth having, and shows you exactly what changed in the skills you
-already use.
+**skillscout keeps your agent current, for each kind of work you do.** Every week a shared index of every
+public skill it can find (23,865 from 1,092 repos at the last build) is rebuilt. skillscout scores it on your
+machine against what *you* work on, tells you what's new and worth having, and shows you exactly what
+changed in the skills you already use.
+
+You probably don't do one kind of work. Coding on Monday, a landing page on Tuesday, investor emails on
+Friday. So skillscout keeps **personas**: one per kind of work, each with its own search and its own Claude
+Code agent, loaded with the best skills for that work and kept up to date as better ones appear.
 
 Keeping up fast is only useful if it's safe. A skill is a set of instructions your agent follows
 **with your permissions**, so skillscout scans every file for dangerous patterns, installs nothing without
 your approval, pins each install to an exact commit, and re-scans every update before it can replace anything.
 
-In one run over the public ecosystem it found **6,726 skills in 95 repos**. 198 had at least one high-risk flag,
+In a hand-checked run on 27 Oct 2026 over **6,726 skills in 95 repos**, 198 had at least one high-risk flag,
 mostly `sudo` and `curl | sh` install steps, plus prompt-injection-style text and hidden Unicode.
 The [report](https://akshit9162.github.io/skillscout/report.html) reads every one of the scariest flags: they were defenders.
 
 It's a zero-dependency Python CLI, and it also ships as a skill, so your agent can run the whole loop for you
 and still ask before every install.
 
+## Personas
+
+A persona is one side of your work, in your words. skillscout doesn't ship any: yours might be "builder",
+"brand" and "outreach", someone else's "trading" and "thesis".
+
+```text
+You     "set up personas for me"           (in Claude Code, with the plugin)
+Agent   reads your recent sessions on this machine, with your OK (skillscout history)
+        → proposes: builder · brand · outreach, each with the sessions it came from
+You     keep brand and builder, rename outreach to launches
+Agent   skillscout persona add brand --about "D2C marketing: ad copy, landing pages, Instagram reels"
+        → keywords drafted from terms skills actually use: instagram reels, ad copy, landing pages...
+        skillscout discover                → a "For your brand work" section in the report
+        skillscout persona build brand     → ~/.claude/agents/brand.md, skills: copy, landing-page-design, script...
+You     claude --agent brand
+```
+
+From then on, each weekly report has a section per persona, and `persona build` swaps in a better skill when
+one arrives (after you've read and approved it). `persona build` only ever rewrites the agent's `skills:` list:
+its prompt, tone, tools, model and memory are yours.
+
+The CLI works without the agent too:
+
+```sh
+skillscout persona add brand --about "D2C marketing: ad copy, landing pages, Instagram reels"
+skillscout persona list            # keywords, best installed skills, what's worth installing
+skillscout persona build --all     # write or update ~/.claude/agents/<name>.md
+```
+
+**Your history stays on your machine.** `skillscout history` reads `~/.claude/projects` only when you run it,
+keeps only what you typed (no tool output, no pasted blocks, no links) and sends nothing anywhere. Grouping
+sessions into personas is left to you or the agent in your own session: counting words can't tell short chat
+messages apart reliably, and a wrong persona is worse than none.
+
 ## A week with skillscout
 
 Example session (counts vary week to week):
 
 ```text
 Monday 10:00   skillscout discover --notify     (weekly, via schedule)
-               → "4 new, 23 recommended, 11 flagged high-risk"
+               → "23 recommended for you (4 new this run), 11 relevant but flagged high-risk"
+               → plus a section per persona: "For your brand work", "For your builder work"
 You            skillscout show github/awesome-copilot:eval-driven-dev
                → flags with file:line, the full SKILL.md, overlaps with what you have
 You            skillscout approve eval-driven-dev   → copied, pinned to its commit
@@ -70,17 +111,18 @@ claude plugin marketplace add akshit9162/skillscout
 claude plugin install skillscout@skillscout
 ```
 
-Then ask: *"find me skills for my Python and React work"*. The agent installs the CLI, runs the search,
+Then ask: *"find me skills for my Python and React work"*, or *"set up personas for me"*. The agent installs the CLI, runs the search,
 summarises the report and shows you each skill's flags before asking to install it.
 
 ### As a CLI
 
 ```sh
 pipx install skillscout-cli     # or: uv tool install skillscout-cli
-skillscout init                                              # writes ~/.skillscout/profile.toml
+skillscout init --about "backend in Python, code review, RL evals, Postgres"
 ```
 
-Edit `[keywords]` in `~/.skillscout/profile.toml` with the words from your own work, then:
+`init` writes `~/.skillscout/profile.toml` and drafts `[keywords]` from your line, using only terms that skills
+actually use. Check them, then:
 
 ```sh
 skillscout discover          # score this week's index; writes ~/.skillscout/reports/<date>.md
@@ -139,6 +181,11 @@ High-risk skills need `--accept-risk`, which the bundled skill tells the agent n
 | `skillscout approve <id> [--update] [--accept-risk] [--to DIR]` | Install and pin. `--to`, or `dir` under `[install]` in your profile, installs into another agent's skills folder |
 | `skillscout installed` · `skillscout remove <id>` · `skillscout rollback <id>` | Pinned skills · uninstall · undo the last update |
 | `skillscout updates` | Diff pinned skills against upstream |
+| `skillscout init [--about "..."]` | Write the profile; `--about` drafts your keywords from one line |
+| `skillscout history [--days N]` | A local digest of your recent Claude Code sessions, to draft personas from |
+| `skillscout persona add <name> --about "..." [--keywords "a=3,b=2"]` | Add a persona; keywords drafted from the line unless given |
+| `skillscout persona list` | Each persona: keywords, best installed skills, what's worth installing |
+| `skillscout persona build <name> \| --all [--dry-run]` | Write `~/.claude/agents/<name>.md`, or update only its `skills:` list |
 | `skillscout schedule` | Set up weekly discovery: launchd on macOS, a systemd timer on Linux (cron line without systemd), a `schtasks` command on Windows. It prints the one command that turns it on |
 
 With the index, `discover` makes no GitHub API calls at all. For `--local` and `index`, set `GITHUB_TOKEN`, or just be logged in with the GitHub CLI (`gh auth login`), for higher API rate limits (5,000 requests an hour instead of 60). Following lists costs one lookup per linked repo: up to 1,500 a run with a token, 40 without; links not yet checked go first, so later runs reach the rest. A token is optional: without it, a rate limit means waiting rather than failing. A weekly run with few upstream changes takes about 25 seconds; the first run takes a few minutes. Scheduled jobs don't see your shell's environment, so add the token to the job if you want it there.
@@ -149,6 +196,7 @@ With the index, `discover` makes no GitHub API calls at all. For `--local` and `
 - Relevance is keyword matching against your profile, not semantic search. Tune the weights.
 - The scanner is pattern rules, deliberately: a skill is text written to steer a model, so a model judging it can be steered by it. The rules make you read; they don't decide.
 - Every installed skill's description loads into every agent session. Keep the total to a few dozen.
+- A persona's `skills:` load in full when its agent starts. `max_skills` (default 5) keeps that small.
 
 ## Development
 

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skillscout-cli"
-version = "0.2.0"
-description = "Keep your agent's skills current: weekly discovery, upstream diffs, safety scans, pinned installs"
+version = "0.3.0"
+description = "Keep your agent's skills current for each kind of work you do: weekly index, personas, scans, pinned installs"
 requires-python = ">=3.11"
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [{ name = "Akshit Gupta" }]
-keywords = ["claude", "claude-code", "agent-skills", "security", "supply-chain", "llm"]
+keywords = ["claude", "claude-code", "agent-skills", "personas", "subagents", "security", "supply-chain", "llm"]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Environment :: Console",

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/skillscout/cli.py

@@ -7,7 +7,7 @@ import subprocess
 import sys
 from pathlib import Path
 
-from . import __doc__ as ABOUT, core, github, index, schedule
+from . import __doc__ as ABOUT, core, github, history, index, persona, schedule
 
 EXAMPLE = Path(__file__).resolve().parent / "profile.example.toml"
 USER_PROFILE = Path.home() / ".skillscout" / "profile.toml"
@@ -24,7 +24,8 @@ def main(argv: list[str] | None = None) -> None:
     p = argparse.ArgumentParser(prog="skillscout", description=ABOUT)
     p.add_argument("--profile", type=Path, default=None, help="default: ~/.skillscout/profile.toml, else the example")
     sub = p.add_subparsers(dest="cmd", required=True)
-    sub.add_parser("init", help="copy the example profile to ~/.skillscout/profile.toml")
+    it = sub.add_parser("init", help="write ~/.skillscout/profile.toml")
+    it.add_argument("--about", help="one line about your work; becomes your keywords (e.g. \"backend in Python, RL evals, Postgres\")")
     d = sub.add_parser("discover", help="score this week's shared index against your profile and write a report")
     d.add_argument("--local", action="store_true", help="crawl and scan GitHub on this machine instead of using the index")
     d.add_argument("--full", action="store_true", help="with --local: ignore caches, fetch every repo and re-scan every skill")
@@ -49,15 +50,40 @@ def main(argv: list[str] | None = None) -> None:
     sub.add_parser("installed", help="show pinned skills")
     sub.add_parser("updates", help="diff pinned skills against upstream; applies nothing")
     sub.add_parser("schedule", help="set up weekly discovery for this OS (you turn it on)")
+    hi = sub.add_parser("history", help="summarise your recent Claude Code sessions, read locally, to draft personas from")
+    hi.add_argument("--days", type=int, default=60)
+    pe = sub.add_parser("persona", help="kinds of work, each with its own keywords and an agent kept current")
+    psub = pe.add_subparsers(dest="action", required=True)
+    pa = psub.add_parser("add", help="add a persona from one line about that work")
+    pa.add_argument("name")
+    pa.add_argument("--about", required=True, help="what this side of your work is, in your words")
+    pa.add_argument("--keywords", help="instead of drafting them: \"cold email=4,investor update=3\"")
+    pa.add_argument("--agent", help="agent file name, if not the persona's name")
+    psub.add_parser("list", help="each persona, its keywords, and the installed skills that fit it")
+    pb = psub.add_parser("build", help="write or update the persona's agent in ~/.claude/agents (only its skills: list)")
+    pb.add_argument("name", nargs="?")
+    pb.add_argument("--all", action="store_true")
+    pb.add_argument("--dry-run", action="store_true")
     a = p.parse_args(argv)
 
     paths = core.Paths()
     if a.cmd == "init":
         if USER_PROFILE.exists():
             raise SystemExit(f"{USER_PROFILE} already exists")
+        text = EXAMPLE.read_text(encoding="utf-8")
+        if a.about:
+            kw = history.keywords_from(a.about, vocabulary(core.load_profile(EXAMPLE), paths))
+            if not kw:
+                raise SystemExit("none of those words appear in skill descriptions; try more specific ones")
+            head, rest = text.split("[keywords]\n", 1)
+            lines = rest.splitlines(keepends=True)
+            keep = next(i for i, line in enumerate(lines) if not line.startswith('"') and line.strip())
+            tail = "".join(lines[keep:])
+            text = head + "[keywords]\n" + f"# drafted from: {a.about}\n" + "".join(f"{json.dumps(k)} = {v}\n" for k, v in kw.items()) + "\n" + tail
         USER_PROFILE.parent.mkdir(parents=True, exist_ok=True)
-        USER_PROFILE.write_text(EXAMPLE.read_text(encoding="utf-8"), encoding="utf-8")
-        print(f"wrote {USER_PROFILE}; edit [keywords] to match your work, then run `skillscout discover`")
+        USER_PROFILE.write_text(text, encoding="utf-8")
+        print(f"wrote {USER_PROFILE}; " + ("check the drafted [keywords]" if a.about else "edit [keywords] to match your work")
+              + ", then run `skillscout discover`")
         return
     profile = core.load_profile(a.profile or (USER_PROFILE if USER_PROFILE.exists() else EXAMPLE))
     if folder := getattr(a, "to", None) or profile.get("install", {}).get("dir"):
@@ -109,11 +135,70 @@ def main(argv: list[str] | None = None) -> None:
         for cid, commit, diff in found:
             print(f"\n=== {cid} -> {commit[:10]}\n{diff}")
         print(f"\n{len(found)} pinned skill(s) changed upstream." + (" Re-run `approve <id> --update` after reading the diff." if found else ""))
+    elif a.cmd == "history":
+        text = history.digest(history.episodes(days=a.days))
+        print(text or "no Claude Code history found in ~/.claude/projects")
+        print(f"(read from ~/.claude/projects on this machine, last {a.days} days; nothing is sent anywhere)")
+    elif a.cmd == "persona":
+        run_persona(a, profile, paths, cands)
     elif a.cmd == "schedule":
         files, message = schedule.here(paths.state)
         schedule.write(files)
         print(message)
 
 
+def vocabulary(profile: dict, paths: core.Paths) -> dict[str, int]:
+    """Terms skills use, from the cached index (downloaded first if there isn't one)."""
+    try:
+        if not paths.index.exists():
+            index.fetch(profile.get("index", {}).get("url") or index.URL, paths.index)
+        return history.vocabulary(index.load(paths.index)["skills"])
+    except index.Unavailable as e:
+        raise SystemExit(f"{e}\n(drafting keywords needs the skill index; or write them by hand)")
+
+
+def run_persona(a, profile: dict, paths: core.Paths, cands: list[dict]) -> None:
+    known = persona.personas(profile)
+    if a.action == "add":
+        if a.keywords:
+            kw = {k.strip(): int(v) for k, v in (pair.rsplit("=", 1) for pair in a.keywords.split(","))}
+        else:
+            kw = history.keywords_from(a.about, vocabulary(profile, paths))
+        path = a.profile or USER_PROFILE
+        if not path.exists():
+            raise SystemExit(f"no profile at {path}; run `skillscout init` first")
+        print(persona.add(path, a.name, a.about, kw, a.agent))
+        print(f"\nadded to {path}. Next: `skillscout discover`, then `skillscout persona build {a.name}`")
+        return
+    if not known:
+        raise SystemExit("no personas yet: add one with `skillscout persona add <name> --about \"...\"`")
+    installed = core.installed_skills(paths)
+    if a.action == "list":
+        for name, p in known.items():
+            fits = persona.fitting(installed, p["keywords"], p["max_skills"])
+            agent = paths.agents / f"{p['agent']}.md"
+            print(f"{name}: {p['description']}\n  keywords: {', '.join(p['keywords'])}\n"
+                  f"  agent: {agent}{'' if agent.exists() else ' (not built yet)'}\n"
+                  f"  best installed skills: {', '.join(n for n, _ in fits) or 'none fit yet'}")
+            pending = [c for c in cands if core.recommended(c, profile) and c.get("personas", {}).get(name, 0) >= 0.3][:3]
+            if pending:
+                print(f"  worth installing: {', '.join(c['id'] for c in pending)}")
+        return
+    names = list(known) if a.all else [a.name] if a.name in known else None
+    if not names:
+        raise SystemExit(f"name a persona ({', '.join(known)}) or pass --all")
+    for name in names:
+        p = known[name]
+        skills = [n for n, _ in persona.fitting(installed, p["keywords"], p["max_skills"])]
+        path = paths.agents / f"{p['agent']}.md"
+        if a.dry_run:
+            print(f"{path}: skills would be {', '.join(skills) or '(none fit yet)'}")
+            continue
+        what, added, dropped = persona.write_agent(path, p["agent"], p["description"], skills)
+        print(f"{what} {path}" + (f"; added {', '.join(added)}" if added else "") + (f"; dropped {', '.join(dropped)}" if dropped else "")
+              + ("" if added or dropped or what == "created" else "; skills unchanged"))
+    print("Start one with `claude --agent <name>`, or ask for it by name in any session.")
+
+
 if __name__ == "__main__":
     main()

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/skillscout/core.py

@@ -12,7 +12,7 @@ from pathlib import Path
 
 import os
 
-from . import github, index
+from . import github, index, persona
 from .scan import HIGH, RULES, scan, worst
 from .score import combined, conflicts, freshness, popularity, relevance
 from .skill import find_skills, parse_frontmatter, safe_name
@@ -26,6 +26,9 @@ PLUGIN_CACHE = HOME / ".claude" / "plugins" / "cache"
 class Paths:
     def __init__(self, state: Path = STATE, skills: Path = SKILLS_DIR, plugins: Path = PLUGIN_CACHE):
         self.state, self.skills, self.plugins = state, skills, plugins
+        claude = plugins.parent.parent                    # ~/.claude
+        self.agents = claude / "agents"
+        self.settings = claude / "settings.json"
         self.cache = state / "repos"
         self.candidates = state / "candidates.json"
         self.crawl = state / "crawl.json"     # the user-independent part of the last crawl (what the index publishes)
@@ -60,17 +63,26 @@ def digest(folder: Path) -> str:
 
 
 def installed_skills(paths: Paths) -> dict[str, str]:
-    """name -> description for user skills and plugin skills (plugin ones as `plugin:name`)."""
+    """name -> description for your skills and for skills of enabled plugins, which are named the way Claude
+    Code names them: `<plugin>:<skill>`. The plugin cache is laid out <marketplace>/<plugin>/<version>/..."""
+    try:
+        enabled = {k.split("@")[0] for k, on in json.loads(paths.settings.read_text(encoding="utf-8"))
+                   .get("enabledPlugins", {}).items() if on}
+    except (OSError, ValueError):
+        enabled = None                                    # no settings file: count every cached plugin
     out = {}
-    for root, prefix in ((paths.skills, ""), (paths.plugins, "plugin")):
+    for root, is_plugin in ((paths.skills, False), (paths.plugins, True)):
         if not root.exists():
             continue
         for md in root.rglob("SKILL.md"):
             if ".git" in md.parts or "node_modules" in md.parts:
                 continue
+            plugin = md.relative_to(root).parts[1] if is_plugin and len(md.relative_to(root).parts) > 2 else None
+            if is_plugin and (plugin is None or (enabled is not None and plugin not in enabled)):
+                continue
             meta = parse_frontmatter(md.read_text(encoding="utf-8", errors="ignore"))
             name = meta.get("name") or md.parent.name
-            out[f"{prefix}:{name}" if prefix else name] = meta.get("description", "")
+            out[f"{plugin}:{name}" if plugin else name] = meta.get("description", "")
     return out
 
 
@@ -238,10 +250,15 @@ def score(records: list[dict], profile: dict, paths: Paths) -> list[dict]:
     pinned = {(e["repo_id"], e["path"]) for e in locked.values() if e.get("repo_id")}
     previous = {c["id"] for c in _read(paths.candidates, [])}
     candidates = []
+    sets = persona.keyword_sets(profile)
     for r in records:
-        rel, hits = relevance(f"{r['name']} {r['description']}", profile["keywords"])
+        text = f"{r['name']} {r['description']}"
+        fit = {name: relevance(text, kw) for name, kw in sets.items()}
+        rel = max((f[0] for f in fit.values()), default=0.0)
+        hits = sorted({h for f in fit.values() for h in f[1]})
         candidates.append({
             **r, "trusted": r["repo"] in trusted, "relevance": round(rel, 3), "matched": hits,
+            "personas": {name: round(f[0], 3) for name, f in fit.items() if name and f[0] > 0},
             "score": combined(rel, popularity(r["stars"]), freshness(r["pushed_at"], now), r["repo"] in trusted),
             "conflicts": conflicts(r["name"], r["description"], installed, profile["scoring"]["overlap_at"]),
             "installed": r["id"] in locked or (r.get("repo_id"), r["path"]) in pinned, "new": r["id"] not in previous,
@@ -296,10 +313,12 @@ def report(candidates: list[dict], profile: dict, paths: Paths, top: int = 25) -
     rec = [c for c in candidates if recommended(c, profile)]
     flagged = [c for c in candidates if c["risk"] == HIGH and c["relevance"] > 0]
     new = [c for c in candidates if c["new"]]
-    summary = f"{len(new)} new, {len(rec)} recommended, {len(flagged)} flagged high-risk"
-    lines = [f"# Skill report {datetime.now():%Y-%m-%d}", "", summary, "", "## New since last run", ""]
     fresh = [c for c in rec if c["new"]]
-    if new and len(new) == len(candidates):
+    first = bool(new) and len(new) == len(candidates)
+    summary = (f"{len(rec)} recommended for you" + ("" if first else f" ({len(fresh)} new this run)")
+               + f", {len(flagged)} relevant but flagged high-risk; {len(candidates):,} skills checked")
+    lines = [f"# Skill report {datetime.now():%Y-%m-%d}", "", summary, "", "## New since last run", ""]
+    if first:
         lines.append("First run: everything is new. From the next run, this section lists only what appeared since.")
     elif fresh:
         lines += [f"- **`{c['id']}`** ({c['stars']}★, score {c['score']:.2f}): {c['description'][:140]}" for c in fresh[:top]]
@@ -310,6 +329,12 @@ def report(candidates: list[dict], profile: dict, paths: Paths, top: int = 25) -
     for c in rec[:top]:
         lines.append(f"| {c['score']:.2f} | `{c['id']}`{' 🆕' if c['new'] else ''} | {c['stars']} | {c['risk'] or 'none'} "
                      f"| {', '.join(c['matched'][:4])} | {c['description'][:110]} |")
+    for name in persona.personas(profile):
+        mine = sorted((c for c in rec if c["personas"].get(name, 0) >= profile["scoring"].get("min_relevance", 0.3)),
+                      key=lambda c: (-c["new"], -c["personas"][name], -c["score"]))[:8]
+        lines += ["", f"## For your {name} work", ""]
+        lines += [f"- `{c['id']}`{' 🆕' if c['new'] else ''} ({c['stars']}★): {c['description'][:120]}" for c in mine] \
+            or ["Nothing recommended yet; widen its keywords in your profile."]
     lines += ["", "Install one with `skillscout approve <id>` after reading it with `skillscout show <id>`.", "",
               "## Relevant but blocked", ""]
     for c in [c for c in candidates if c["relevance"] > 0 and not recommended(c, profile) and not c["installed"]][:top]:

skillscout_cli-0.3.0/skillscout/history.py

@@ -0,0 +1,153 @@
+"""Your Claude Code history, read on this machine only and only when you ask: a digest of what you've worked
+on, for you (or the agent in your session) to draft personas from, and keywords from a one-line description.
+
+Word counting can't group short chat messages into kinds of work reliably, so grouping is left to a reader
+who understands them; this module only gathers and condenses."""
+
+import json
+import math
+import re
+from collections import Counter
+from datetime import datetime
+from pathlib import Path
+
+from .score import STOP, WORD, stem
+
+HISTORY = Path.home() / ".claude" / "projects"
+GAP = 45 * 60                 # seconds of silence that start a new episode
+URL = re.compile(r"https?://\S+|www\.\S+")
+PASTE = re.compile(r"<pasted_content[^>]*>.*?</pasted_content[^>]*>", re.S)
+# Words that say nothing about the kind of work. Common topic words (`page`, `code`) aren't here: alone they're
+# too frequent to survive vocabulary(), but they must stay available for phrases like `landing page`.
+CHATTER = set("""make give can could would should also now just want need like please yes okay thanks thank
+    then there here what which why how does doing done did lets let get got put see look check run try use
+    using used new add added change changed fix fixed update updated same other more most much very really
+    still again first last next back way thing things something everything anything all every each one two
+    three good best better bad right wrong sure think know mean means said say tell told keep kept stop start
+    working show wrote
+    take didn don isn doesn wasn will been being have has had into onto over under about after before above
+    below between only well even ever never always too our ours their them they him her his she its
+    hello hey yeah dont doesnt cant wont whatever able
+    goes made makes gave given took actually maybe already help helps helping based specific various
+    http https www com org html url link links we my me up do so if at no go us am he ok oh hi""".split())
+CLAUSE = re.compile(r"[,.;:!?()\[\]/|]+|\s(?:and|or|for|with|in|on|of|to|the)\s")
+
+
+def episodes(root: Path = HISTORY, days: int | None = None) -> list[dict]:
+    """Your typed messages, grouped into episodes (same folder, no gap over 45 minutes), newest first:
+    {"folder", "start", "end", "messages", "title"}. Tool output, system text and pasted blocks are left out."""
+    since = datetime.now().timestamp() - days * 86400 if days else None
+    out = []
+    for f in sorted(root.glob("*/*.jsonl")):
+        title, mine, current = None, [], None
+        try:
+            lines = f.read_text(encoding="utf-8", errors="ignore").splitlines()
+        except OSError:
+            continue
+        for line in lines:
+            try:
+                d = json.loads(line)
+            except ValueError:
+                continue
+            if d.get("type") == "ai-title":
+                title = title or d.get("aiTitle")
+            if d.get("type") != "user" or d.get("isMeta"):
+                continue
+            text = typed(d.get("message", {}).get("content"))
+            when = _time(d.get("timestamp"))
+            if not text or (since and when and when < since):
+                continue
+            folder = d.get("cwd") or ""
+            if not current or current["folder"] != folder or (when and current["end"] and when - current["end"] > GAP):
+                current = {"folder": folder, "start": when, "end": when, "messages": [], "title": None}
+                mine.append(current)
+            current["messages"].append(text)
+            current["end"] = when or current["end"]
+        if mine and title:
+            mine[0]["title"] = title
+        out += mine
+    return sorted(out, key=lambda e: -(e["start"] or 0))
+
+
+def typed(content) -> str:
+    """The part of a user record you typed: not tool results, command wrappers, system notes or pastes."""
+    if isinstance(content, list):
+        content = " ".join(c.get("text", "") for c in content if isinstance(c, dict) and c.get("type") == "text")
+    if not isinstance(content, str):
+        return ""
+    text = " ".join(PASTE.sub(" ", URL.sub(" ", content)).split())
+    if not text or text.startswith(("<", "[Request interrupted", "Caveat:", "This session is being continued")):
+        return ""
+    return text[:300]
+
+
+def _time(stamp) -> float | None:
+    try:
+        return datetime.fromisoformat(stamp.replace("Z", "+00:00")).timestamp()
+    except (AttributeError, ValueError):
+        return None
+
+
+def digest(eps: list[dict], per_episode: int = 4, limit: int = 150) -> str:
+    """A compact plain-text summary to read or hand to the agent: one block per episode, short messages only."""
+    lines = []
+    for e in eps[:limit]:
+        when = datetime.fromtimestamp(e["start"]).strftime("%Y-%m-%d") if e["start"] else "?"
+        folder = Path(e["folder"]).name or "~"
+        head = f"## {when} · {folder}" + (f" · {e['title']}" if e["title"] else "") + f" · {len(e['messages'])} messages"
+        msgs = [m[:140] for m in e["messages"] if len(m.split()) >= 3][:per_episode]
+        if msgs:
+            lines += [head] + [f"- {m}" for m in msgs] + [""]
+    return "\n".join(lines)
+
+
+def vocabulary(records: list[dict], low: int = 3, high: float = 0.04) -> dict[str, int]:
+    """Terms (single words and two-word phrases) that skills use in their names and descriptions, with how
+    many skills use each. Kept: at least `low` skills (so a keyword can match something) and at most `high`
+    of them (`build`, `create` and the like match everything and so say nothing)."""
+    df = Counter()
+    for r in records:
+        df.update(set(terms(f"{r['name'].replace('-', ' ')} {r['description']}")))
+    cap = max(low, high * len(records))
+    return {t: n for t, n in df.items() if low <= n <= cap}
+
+
+def terms(text: str, surface: dict[str, str] | None = None) -> list[str]:
+    """Content words (plural folded to singular) and adjacent pairs within a clause. `surface`, if given,
+    collects each term's first spelling as written (`postgres`, not the folded `postgre`)."""
+    out = []
+    for clause in CLAUSE.split(f" {text.lower()} "):
+        words = []
+        for w in WORD.findall(clause):
+            if w in CHATTER or w in STOP or w.isdigit() or len(w) < 2:
+                continue
+            s = stem(w)
+            if s in CHATTER:
+                continue
+            words.append(s)
+            if surface is not None:
+                surface.setdefault(s, w)
+        out += words
+        for a, b in zip(words, words[1:]):
+            out.append(f"{a} {b}")
+            if surface is not None:
+                surface.setdefault(f"{a} {b}", f"{surface[a]} {surface[b]}")
+    return out
+
+
+def keywords_from(about: str, vocab: dict[str, int], k: int = 10) -> dict[str, int]:
+    """Profile keywords from a sentence about the work: its terms that skills also use, rarer ones weighted
+    higher (`meta ads` says more than `marketing`), a phrase preferred over its own words. Weights 1 to 4."""
+    surface: dict[str, str] = {}
+    found = [t for t in dict.fromkeys(terms(about, surface)) if t in vocab]
+    total = max(vocab.values(), default=1) / 0.04
+    scored = sorted(((t, math.log(total / vocab[t]) * (1.5 if " " in t else 1)) for t in found), key=lambda x: -x[1])
+    out: dict[str, float] = {}
+    for t, w in scored:
+        if any(t in o.split() for o in out):          # its phrase is already in
+            continue
+        out = {o: v for o, v in out.items() if o not in t.split()} | {t: w}
+        if len(out) == k:
+            break
+    hi = max(out.values(), default=1)
+    return {surface[t]: max(1, round(4 * w / hi)) for t, w in out.items()}

skillscout_cli-0.3.0/skillscout/persona.py

@@ -0,0 +1,98 @@
+"""Personas: named kinds of work, each with its own keywords and, optionally, a Claude Code agent whose
+`skills:` list skillscout keeps current. Everything else in the agent file is yours and is never touched."""
+
+import json
+import re
+from pathlib import Path
+
+from .score import relevance
+from .skill import parse_frontmatter
+
+NAME = re.compile(r"[a-z0-9][a-z0-9-]{0,39}")
+
+
+def personas(profile: dict) -> dict[str, dict]:
+    """name -> {"description", "keywords", "agent", "max_skills"} from the profile's [personas.*] tables."""
+    out = {}
+    for name, p in profile.get("personas", {}).items():
+        out[name] = {"description": p.get("description", ""), "keywords": p.get("keywords", {}),
+                     "agent": p.get("agent", name), "max_skills": p.get("max_skills", 5)}
+    return out
+
+
+def keyword_sets(profile: dict) -> dict[str, dict[str, float]]:
+    """Every keyword set to score against: the main [keywords] (as "") and each persona's."""
+    sets = {"": profile.get("keywords", {})} if profile.get("keywords") else {}
+    return sets | {n: p["keywords"] for n, p in personas(profile).items() if p["keywords"]}
+
+
+def add(profile_path: Path, name: str, description: str, keywords: dict[str, int], agent: str | None = None) -> str:
+    """Append a [personas.<name>] table to the profile file. Refuses a name that's taken."""
+    if not NAME.fullmatch(name):
+        raise SystemExit(f"persona names are lowercase letters, digits and dashes: {name!r}")
+    text = profile_path.read_text(encoding="utf-8")
+    if re.search(rf"^\[personas\.{re.escape(name)}\]", text, re.M):
+        raise SystemExit(f"{name} is already in {profile_path}; edit it there")
+    if not keywords:
+        raise SystemExit("no keywords: describe the work in more specific words, or pass --keywords")
+    block = [f"\n[personas.{name}]", f"description = {json.dumps(description)}"]
+    if agent and agent != name:
+        block.append(f"agent = {json.dumps(agent)}")
+    block += ["max_skills = 5", f"[personas.{name}.keywords]"] + [f"{json.dumps(k)} = {v}" for k, v in keywords.items()]
+    profile_path.write_text(text.rstrip("\n") + "\n" + "\n".join(block) + "\n", encoding="utf-8")
+    return "\n".join(block).strip()
+
+
+def fitting(installed: dict[str, str], keywords: dict[str, float], k: int, at: float = 0.2) -> list[tuple[str, float]]:
+    """The installed skills (name -> description) that best fit a keyword set, best first."""
+    scored = []
+    for name, desc in installed.items():
+        rel, _ = relevance(f"{name.split(':')[-1].replace('-', ' ')} {desc}", keywords)
+        if rel >= at:
+            scored.append((name, rel))
+    return sorted(scored, key=lambda x: (-x[1], x[0]))[:k]
+
+
+def write_agent(path: Path, name: str, description: str, skills: list[str]) -> tuple[str, list[str], list[str]]:
+    """Create the agent file, or replace only the `skills:` list in an existing one.
+    Returns (what happened, skills added, skills dropped)."""
+    if path.exists():
+        text = path.read_text(encoding="utf-8")
+        if not text.startswith("---"):
+            raise SystemExit(f"{path} has no frontmatter; add `---` blocks or remove the file")
+        end = text.index("\n---", 3)
+        head, body = text[: end], text[end:]
+        before = _skills(head)
+        head = _strip_skills(head).rstrip("\n") + "\n" + _skills_block(skills)
+        path.write_text(head.rstrip("\n") + body, encoding="utf-8")
+        return "updated", [s for s in skills if s not in before], [s for s in before if s not in skills]
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(f"""---
+name: {name}
+description: {json.dumps(description or f"The {name} side of my work")}
+{_skills_block(skills)}---
+
+{description}
+
+The skills listed above load when this agent starts; `skillscout persona build {name}` keeps that list
+current with the best installed skills for this work. Everything else in this file is yours to edit:
+role, tone, rules, tools, model.
+""", encoding="utf-8")
+    return "created", skills, []
+
+
+def _skills(head: str) -> list[str]:
+    m = re.search(r"^skills:[ \t]*\n((?:[ \t]+-.*\n?)*)", head + "\n", re.M)
+    if m:
+        return [line.strip()[1:].strip().strip("\"'") for line in m.group(1).splitlines() if line.strip()]
+    inline = parse_frontmatter(head + "\n---").get("skills", "")
+    return [s.strip().strip("\"'") for s in inline.strip("[]").split(",") if s.strip()]
+
+
+def _strip_skills(head: str) -> str:
+    head = re.sub(r"^skills:[ \t]*\n(?:[ \t]+-.*\n?)*", "", head + "\n", flags=re.M)
+    return re.sub(r"^skills:.*\n?", "", head, flags=re.M)
+
+
+def _skills_block(skills: list[str]) -> str:
+    return "skills:\n" + "".join(f"  - {s}\n" for s in skills) if skills else ""

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/skillscout/profile.example.toml

@@ -55,6 +55,18 @@ trusted = [
 "security" = 1
 "design" = 1
 
+# Personas: kinds of work, each with its own keywords and a Claude Code agent (~/.claude/agents/<name>.md)
+# whose skills: list `skillscout persona build <name>` keeps current. Add one with
+# `skillscout persona add <name> --about "what this work is"`, or by hand:
+#
+# [personas.brand]
+# description = "D2C brand marketing: ad copy, landing pages, Instagram reels"
+# max_skills = 5          # skills preloaded into the agent; each loads in full, so keep it small
+# [personas.brand.keywords]
+# "ad copy" = 4
+# "landing pages" = 3
+# "instagram" = 2
+
 [scoring]
 recommend_at = 0.45     # combined score needed to be recommended
 min_relevance = 0.3     # and at least this much keyword overlap with your work

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/skillscout_cli.egg-info/PKG-INFO

@@ -1,14 +1,14 @@
 Metadata-Version: 2.4
 Name: skillscout-cli
-Version: 0.2.0
-Summary: Keep your agent's skills current: weekly discovery, upstream diffs, safety scans, pinned installs
+Version: 0.3.0
+Summary: Keep your agent's skills current for each kind of work you do: weekly index, personas, scans, pinned installs
 Author: Akshit Gupta
 License-Expression: MIT
 Project-URL: Homepage, https://akshit9162.github.io/skillscout
 Project-URL: Source, https://github.com/akshit9162/skillscout
 Project-URL: Issues, https://github.com/akshit9162/skillscout/issues
 Project-URL: Report, https://akshit9162.github.io/skillscout/report.html
-Keywords: claude,claude-code,agent-skills,security,supply-chain,llm
+Keywords: claude,claude-code,agent-skills,personas,subagents,security,supply-chain,llm
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -34,6 +34,7 @@ Dynamic: license-file
   <a href="https://akshit9162.github.io/skillscout">Website</a> &ensp;·&ensp;
   <a href="https://akshit9162.github.io/skillscout/report.html">Report: what's inside 6,726 skills</a> &ensp;·&ensp;
   <a href="#install">Install</a> &ensp;·&ensp;
+  <a href="#personas">Personas</a> &ensp;·&ensp;
   <a href="#a-week-with-skillscout">A week with it</a> &ensp;·&ensp;
   <a href="#how-it-works">How it works</a> &ensp;·&ensp;
   <a href="#what-gets-flagged">What gets flagged</a>
@@ -47,7 +48,7 @@ Dynamic: license-file
 </p>
 
 <p align="center">
-  <img src="https://raw.githubusercontent.com/akshit9162/skillscout/main/docs/assets/demo.svg" width="760" alt="Terminal demo: discover finds 216 recommended skills with 89 flagged high-risk; a high-risk skill is refused without --accept-risk; a low-risk one installs pinned to a commit" />
+  <img src="https://raw.githubusercontent.com/akshit9162/skillscout/main/docs/assets/demo.svg" width="760" alt="Terminal demo: init drafts keywords from one line; persona add creates a brand persona; discover scores 23,865 skills with a section for the brand persona; persona build writes its agent; claude --agent brand starts it" />
 </p>
 
 ```bash
@@ -60,28 +61,68 @@ AI tooling moves weekly. New skills, plugins and agent workflows land on GitHub
 installed keep changing upstream, and last month's best practice is already stale. Nobody has time to
 watch hundreds of repos.
 
-**skillscout keeps your agent current.** Once a week it checks the skill ecosystem against what *you*
-work on, tells you what's new and worth having, and shows you exactly what changed in the skills you
-already use.
+**skillscout keeps your agent current, for each kind of work you do.** Every week a shared index of every
+public skill it can find (23,865 from 1,092 repos at the last build) is rebuilt. skillscout scores it on your
+machine against what *you* work on, tells you what's new and worth having, and shows you exactly what
+changed in the skills you already use.
+
+You probably don't do one kind of work. Coding on Monday, a landing page on Tuesday, investor emails on
+Friday. So skillscout keeps **personas**: one per kind of work, each with its own search and its own Claude
+Code agent, loaded with the best skills for that work and kept up to date as better ones appear.
 
 Keeping up fast is only useful if it's safe. A skill is a set of instructions your agent follows
 **with your permissions**, so skillscout scans every file for dangerous patterns, installs nothing without
 your approval, pins each install to an exact commit, and re-scans every update before it can replace anything.
 
-In one run over the public ecosystem it found **6,726 skills in 95 repos**. 198 had at least one high-risk flag,
+In a hand-checked run on 27 Oct 2026 over **6,726 skills in 95 repos**, 198 had at least one high-risk flag,
 mostly `sudo` and `curl | sh` install steps, plus prompt-injection-style text and hidden Unicode.
 The [report](https://akshit9162.github.io/skillscout/report.html) reads every one of the scariest flags: they were defenders.
 
 It's a zero-dependency Python CLI, and it also ships as a skill, so your agent can run the whole loop for you
 and still ask before every install.
 
+## Personas
+
+A persona is one side of your work, in your words. skillscout doesn't ship any: yours might be "builder",
+"brand" and "outreach", someone else's "trading" and "thesis".
+
+```text
+You     "set up personas for me"           (in Claude Code, with the plugin)
+Agent   reads your recent sessions on this machine, with your OK (skillscout history)
+        → proposes: builder · brand · outreach, each with the sessions it came from
+You     keep brand and builder, rename outreach to launches
+Agent   skillscout persona add brand --about "D2C marketing: ad copy, landing pages, Instagram reels"
+        → keywords drafted from terms skills actually use: instagram reels, ad copy, landing pages...
+        skillscout discover                → a "For your brand work" section in the report
+        skillscout persona build brand     → ~/.claude/agents/brand.md, skills: copy, landing-page-design, script...
+You     claude --agent brand
+```
+
+From then on, each weekly report has a section per persona, and `persona build` swaps in a better skill when
+one arrives (after you've read and approved it). `persona build` only ever rewrites the agent's `skills:` list:
+its prompt, tone, tools, model and memory are yours.
+
+The CLI works without the agent too:
+
+```sh
+skillscout persona add brand --about "D2C marketing: ad copy, landing pages, Instagram reels"
+skillscout persona list            # keywords, best installed skills, what's worth installing
+skillscout persona build --all     # write or update ~/.claude/agents/<name>.md
+```
+
+**Your history stays on your machine.** `skillscout history` reads `~/.claude/projects` only when you run it,
+keeps only what you typed (no tool output, no pasted blocks, no links) and sends nothing anywhere. Grouping
+sessions into personas is left to you or the agent in your own session: counting words can't tell short chat
+messages apart reliably, and a wrong persona is worse than none.
+
 ## A week with skillscout
 
 Example session (counts vary week to week):
 
 ```text
 Monday 10:00   skillscout discover --notify     (weekly, via schedule)
-               → "4 new, 23 recommended, 11 flagged high-risk"
+               → "23 recommended for you (4 new this run), 11 relevant but flagged high-risk"
+               → plus a section per persona: "For your brand work", "For your builder work"
 You            skillscout show github/awesome-copilot:eval-driven-dev
                → flags with file:line, the full SKILL.md, overlaps with what you have
 You            skillscout approve eval-driven-dev   → copied, pinned to its commit
@@ -98,17 +139,18 @@ claude plugin marketplace add akshit9162/skillscout
 claude plugin install skillscout@skillscout
 ```
 
-Then ask: *"find me skills for my Python and React work"*. The agent installs the CLI, runs the search,
+Then ask: *"find me skills for my Python and React work"*, or *"set up personas for me"*. The agent installs the CLI, runs the search,
 summarises the report and shows you each skill's flags before asking to install it.
 
 ### As a CLI
 
 ```sh
 pipx install skillscout-cli     # or: uv tool install skillscout-cli
-skillscout init                                              # writes ~/.skillscout/profile.toml
+skillscout init --about "backend in Python, code review, RL evals, Postgres"
 ```
 
-Edit `[keywords]` in `~/.skillscout/profile.toml` with the words from your own work, then:
+`init` writes `~/.skillscout/profile.toml` and drafts `[keywords]` from your line, using only terms that skills
+actually use. Check them, then:
 
 ```sh
 skillscout discover          # score this week's index; writes ~/.skillscout/reports/<date>.md
@@ -167,6 +209,11 @@ High-risk skills need `--accept-risk`, which the bundled skill tells the agent n
 | `skillscout approve <id> [--update] [--accept-risk] [--to DIR]` | Install and pin. `--to`, or `dir` under `[install]` in your profile, installs into another agent's skills folder |
 | `skillscout installed` · `skillscout remove <id>` · `skillscout rollback <id>` | Pinned skills · uninstall · undo the last update |
 | `skillscout updates` | Diff pinned skills against upstream |
+| `skillscout init [--about "..."]` | Write the profile; `--about` drafts your keywords from one line |
+| `skillscout history [--days N]` | A local digest of your recent Claude Code sessions, to draft personas from |
+| `skillscout persona add <name> --about "..." [--keywords "a=3,b=2"]` | Add a persona; keywords drafted from the line unless given |
+| `skillscout persona list` | Each persona: keywords, best installed skills, what's worth installing |
+| `skillscout persona build <name> \| --all [--dry-run]` | Write `~/.claude/agents/<name>.md`, or update only its `skills:` list |
 | `skillscout schedule` | Set up weekly discovery: launchd on macOS, a systemd timer on Linux (cron line without systemd), a `schtasks` command on Windows. It prints the one command that turns it on |
 
 With the index, `discover` makes no GitHub API calls at all. For `--local` and `index`, set `GITHUB_TOKEN`, or just be logged in with the GitHub CLI (`gh auth login`), for higher API rate limits (5,000 requests an hour instead of 60). Following lists costs one lookup per linked repo: up to 1,500 a run with a token, 40 without; links not yet checked go first, so later runs reach the rest. A token is optional: without it, a rate limit means waiting rather than failing. A weekly run with few upstream changes takes about 25 seconds; the first run takes a few minutes. Scheduled jobs don't see your shell's environment, so add the token to the job if you want it there.
@@ -177,6 +224,7 @@ With the index, `discover` makes no GitHub API calls at all. For `--local` and `
 - Relevance is keyword matching against your profile, not semantic search. Tune the weights.
 - The scanner is pattern rules, deliberately: a skill is text written to steer a model, so a model judging it can be steered by it. The rules make you read; they don't decide.
 - Every installed skill's description loads into every agent session. Keep the total to a few dozen.
+- A persona's `skills:` load in full when its agent starts. `max_skills` (default 5) keeps that small.
 
 ## Development
 

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/skillscout_cli.egg-info/SOURCES.txt

@@ -5,7 +5,9 @@ skillscout/__init__.py
 skillscout/cli.py
 skillscout/core.py
 skillscout/github.py
+skillscout/history.py
 skillscout/index.py
+skillscout/persona.py
 skillscout/profile.example.toml
 skillscout/scan.py
 skillscout/schedule.py

{skillscout_cli-0.2.0 → skillscout_cli-0.3.0}/tests/test_skillscout.py

@@ -128,7 +128,7 @@ def test_discover_ranks_flags_and_reports(env):
     assert by["cooking"]["relevance"] == 0
     out, summary = core.report(cands, PROFILE, paths)
     text = out.read_text(encoding="utf-8")
-    assert "me/good:gst-eval" in text and "pipes a download" in text and summary.startswith("3 new, 1 recommended, 1 flagged")
+    assert "me/good:gst-eval" in text and "pipes a download" in text and summary.startswith("1 recommended for you, 1 relevant but flagged")
     # second run: nothing is new
     assert not any(c["new"] for c in core.discover(PROFILE, paths, fetch=gh))
 
@@ -472,3 +472,97 @@ def test_index_verification_needs_a_github_release_and_gh(tmp_path, monkeypatch)
     monkeypatch.setattr(index.shutil, "which", lambda _: None)
     with pytest.raises(index.Unavailable, match="GitHub CLI"):
         index.verify(tmp_path / "i.json.gz", index.URL)
+
+
+def transcript(path: Path, records: list[dict]) -> None:
+    import json
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(json.dumps(r) for r in records) + "\n", encoding="utf-8")
+
+
+def said(text, when, cwd="/work/shop", **extra):
+    return {"type": "user", "cwd": cwd, "timestamp": when, "message": {"role": "user", "content": text}, **extra}
+
+
+def test_history_keeps_only_what_you_typed_and_splits_episodes(tmp_path):
+    from skillscout import history
+    transcript(tmp_path / "proj" / "s1.jsonl", [
+        {"type": "ai-title", "aiTitle": "Shop launch"},
+        said("write ad copy for the summer sale", "2026-10-01T10:00:00Z"),
+        said("<command-name>/clear</command-name>", "2026-10-01T10:01:00Z"),
+        said("noise", "2026-10-01T10:02:00Z", isMeta=True),
+        {"type": "user", "cwd": "/work/shop", "timestamp": "2026-10-01T10:03:00Z",
+         "message": {"content": [{"type": "tool_result", "content": "secret tool output"}]}},
+        said("see https://example.com/x and <pasted_content id=\"1\">pasted words</pasted_content id=\"1\"> now landing page", "2026-10-01T10:04:00Z"),
+        said("fix the failing postgres test", "2026-10-01T12:00:00Z"),               # two hours later
+        said("and the migration too", "2026-10-01T12:05:00Z", cwd="/work/api"),       # another folder
+    ])
+    eps = history.episodes(tmp_path)
+    assert [len(e["messages"]) for e in sorted(eps, key=lambda e: e["start"])] == [2, 1, 1]
+    first = min(eps, key=lambda e: e["start"])
+    assert first["title"] == "Shop launch" and first["messages"][1] == "see and now landing page"
+    text = history.digest(eps)
+    assert "secret tool output" not in text and "pasted words" not in text and "example.com" not in text
+    assert "· shop · Shop launch ·" in text
+
+
+def test_keywords_from_a_sentence_use_only_terms_skills_use(tmp_path):
+    from skillscout import history
+    records = [{"name": f"s{i}", "description": d} for i, d in enumerate(
+        ["write google ads copy"] * 3 + ["cold email sequences"] * 4 + ["postgres query tuning"] * 3 + ["landing pages"] * 3
+        + ["generic helper"] * 200)]
+    vocab = history.vocabulary(records)
+    kw = history.keywords_from("Google ads, cold email and Postgres; also knitting", vocab)
+    assert set(kw) == {"google ads", "cold email", "postgres"}      # phrases kept whole, across no comma
+    assert "knitting" not in kw and history.keywords_from("knitting", vocab) == {}
+
+
+def test_personas_are_added_scored_and_reported(env, tmp_path):
+    from skillscout import persona
+    paths, gh = env
+    prof = tmp_path / "profile.toml"
+    import tomllib
+    base = Path(core.__file__).with_name("profile.example.toml").read_text(encoding="utf-8")
+    prof.write_text(base, encoding="utf-8")
+    persona.add(prof, "taxes", "GST filing", {"gst": 4, "rl environment": 2})
+    with pytest.raises(SystemExit, match="already"):
+        persona.add(prof, "taxes", "again", {"gst": 1})
+    with pytest.raises(SystemExit, match="lowercase"):
+        persona.add(prof, "../x", "bad", {"gst": 1})
+    profile = core.load_profile(prof) | {"scoring": PROFILE["scoring"] | {"recommend_at": 0.2}}
+    assert persona.personas(profile)["taxes"]["keywords"] == {"gst": 4, "rl environment": 2}
+    cands = core.discover(profile, paths, fetch=gh)
+    gst = core.find(cands, "gst-eval")
+    assert gst["personas"]["taxes"] == 1.0 and gst["relevance"] == 1.0
+    assert "## For your taxes work" in core.report(cands, profile, paths)[0].read_text(encoding="utf-8")
+
+
+def test_agent_file_is_created_then_only_its_skills_change(tmp_path):
+    from skillscout import persona
+    path = tmp_path / "agents" / "brand.md"
+    assert persona.write_agent(path, "brand", "Ads and copy", ["copy", "seo"])[0] == "created"
+    text = path.read_text(encoding="utf-8")
+    assert text.startswith("---\nname: brand\n") and "  - copy\n  - seo\n" in text
+    path.write_text(text.replace("Ads and copy\n\nThe skills", "Ads and copy\n\nMY OWN RULES\n\nThe skills")
+                    .replace("name: brand\n", "name: brand\nmodel: opus\n"), encoding="utf-8")
+    what, added, dropped = persona.write_agent(path, "brand", "ignored now", ["copy", "viral"])
+    text = path.read_text(encoding="utf-8")
+    assert (what, added, dropped) == ("updated", ["viral"], ["seo"])
+    assert "MY OWN RULES" in text and "model: opus" in text and "  - viral\n" in text and "seo" not in text
+    path.write_text("---\nname: x\nskills: [a, b]\ntools: Read\n---\nbody\n", encoding="utf-8")   # inline list form
+    assert persona.write_agent(path, "x", "", ["b", "c"])[1:] == (["c"], ["a"])
+    assert path.read_text(encoding="utf-8") == "---\nname: x\ntools: Read\nskills:\n  - b\n  - c\n---\nbody\n"
+
+
+def test_plugin_skills_use_plugin_names_and_only_enabled_plugins(tmp_path):
+    import json
+    claude = tmp_path / ".claude"
+    paths = core.Paths(tmp_path / "state", claude / "skills", claude / "plugins" / "cache")
+    for plugin in ("marketing", "unused"):
+        md = paths.plugins / "market" / plugin / "1.0.0" / "skills" / "draft" / "SKILL.md"
+        md.parent.mkdir(parents=True)
+        md.write_text(skill_md("draft", f"{plugin} drafting"), encoding="utf-8")
+    (paths.skills / "copy").mkdir(parents=True)
+    (paths.skills / "copy" / "SKILL.md").write_text(skill_md("copy", "ad copy"), encoding="utf-8")
+    paths.settings.write_text(json.dumps({"enabledPlugins": {"marketing@market": True, "unused@market": False}}), encoding="utf-8")
+    assert core.installed_skills(paths) == {"copy": "ad copy", "marketing:draft": "marketing drafting"}