@jesdi/skills 0.0.1 → 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jesdi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jesdi/skills",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "jesdi's agent skills (content package consumed by @jesdi/skills-cli)",
   "license": "MIT",
   "repository": {
@@ -12,13 +12,6 @@
     "skills",
     "skills-manifest.json"
   ],
-  "workspaces": [
-    "cli"
-  ],
-  "scripts": {
-    "test": "vitest run",
-    "generate-manifest": "tsx scripts/generate-manifest.ts"
-  },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "gray-matter": "^4.0.3",
@@ -28,5 +21,9 @@
   },
   "engines": {
     "node": ">=20"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "generate-manifest": "tsx scripts/generate-manifest.ts"
   }
-}
+}

package/skills/backlog/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: backlog
+description: >-
+  Manage a GitHub-Issues-backed backlog and a Projects-v2 work graph via five
+  verbs. Use when the user wants to CAPTURE an idea/research thread ("add to
+  backlog", "capture this", "note this idea", "log a task"), TRIAGE the inbox
+  ("triage the backlog", "score the inbox"), see what to work on NEXT ("what's
+  next", "what should I work on", "ranked backlog", "next actionable task"),
+  LAND a finished item ("mark done", "close out #N"), or SETUP the board the
+  first time. Ranks open issues by impact÷effort, respecting `Blocked by:`
+  edges, so only actionable work surfaces.
+---
+
+# backlog — capture + ranked work graph on GitHub
+
+Two needs, one substrate: a frictionless **capture** inbox (loose issues labelled
+`inbox`) and a typed, dependency-aware **work graph** (one user-owned Project v2
+with Impact / Effort / Area / Status). The verbs below operate on both.
+
+**Dispatch on the user's intent:**
+
+| Intent | Verb |
+|--------|------|
+| "add this idea", "capture", "note this" | `capture` |
+| "triage the inbox", "score these" | `triage` |
+| "what's next", "ranked backlog" | `next` |
+| "I'm starting #N", beginning work on an issue | `start` |
+| "mark #N done", "close it out" | `land` |
+| first-time board creation | `setup` |
+
+All exact commands live in `references/graphql.md`. Board IDs come from the
+**consuming project's** `.backlog/project-meta.json` (created by `setup`, found
+by walking up from the current directory). That file is a **static schema
+pointer** — project/field/option IDs only, *not* issue state (Impact/Effort/
+Status live on the GitHub board and `rank.py` fetches them live). Because the IDs
+are non-secret constants that change only on re-provision, the file is
+**committed in the consuming repo** and shared across every branch/worktree;
+`project-meta.example.json` is the shape reference. Reads use the existing `gh`
+login; **writes need the one-time `gh auth refresh -s project`** (Projects v2 is
+not in the default `repo` scope).
+
+`<owner>`, `<repo>`, `<projectNumber>` below all come from that
+`.backlog/project-meta.json`.
+
+## `setup` — create the board once (idempotent)
+
+Run when `.backlog/project-meta.json` is absent or the board is being
+(re)provisioned. Reconciles rather than duplicates — re-running after adding a
+field is safe. Writes into the **project's** `.backlog/` directory, not the skill
+dir.
+
+1. Ensure the `project` scope: `gh auth status`; if Projects calls 403, run
+   `gh auth refresh -s project`.
+2. Follow `references/graphql.md` → **Setup**: create the Project, link the repo,
+   add the four fields, create the `inbox` label. On a brand-new board the `Area`
+   single-select is created with the generic default options
+   `feature,bug,infra,docs,research`. If any step reports "already exists", treat
+   it as done and continue. Projects that want different Areas edit the option set
+   on the board (GitHub UI) and re-run `setup` to reconcile the IDs.
+3. Discover IDs: `gh project view … --format json` (project id) and
+   `gh project field-list … --format json` (field + option ids).
+4. Build `.backlog/project-meta.json` from that discovery using
+   `meta.build_project_meta`. Run from the skill directory (so `import meta`
+   resolves), writing to the project's `.backlog/` (create it if missing):
+
+   ```bash
+   mkdir -p "$PROJECT_ROOT/.backlog"
+   gh project view <projectNumber> --owner <owner> --format json > /tmp/proj.json
+   gh project field-list <projectNumber> --owner <owner> --format json > /tmp/fields.json
+   python3 - "$PROJECT_ROOT/.backlog/project-meta.json" <<'PY'
+   import json, sys, meta
+   proj = json.load(open("/tmp/proj.json"))
+   fields = json.load(open("/tmp/fields.json"))
+   out = meta.build_project_meta(
+       "<owner>", "<repo>",
+       proj["number"], proj["id"], fields)
+   json.dump(out, open(sys.argv[1], "w"), indent=2)
+   print("wrote", sys.argv[1])
+   PY
+   ```
+
+5. Confirm every field + option id in `.backlog/project-meta.json` is non-empty,
+   then commit the real file (non-secret schema pointer). Report the Project URL.
+
+6. **Built-in workflows (UI-only — no API exists; ask the user to click):**
+   at `https://github.com/users/<owner>/projects/<projectNumber>/workflows`
+   enable:
+   - *Auto-add to project*: repo `<repo>`, filter `is:issue is:open`
+   - *Item added to project*: issues → `Status: Inbox`
+   - *Item closed*: issues → `Status: Done`
+   - *Item reopened*: issues → `Status: Ready`
+   These make the board self-maintaining; `land` is only an escape hatch.
+
+## `land <issue#>` — verify closed + Done (escape hatch)
+
+Closing and Done are **automatic**: a PR merged with `Closes #N` closes the
+issue, and the board's "Item closed" built-in workflow sets `Status: Done`.
+`land` only verifies and repairs:
+
+1. `gh issue view N --repo <repo> --json state` — if not `CLOSED`, close it:
+   `gh issue close N --repo <repo>`.
+2. Check board status (`gh project item-list … --jq` per graphql.md → Land);
+   if not `Done` after ~1 min (workflows are async), set it via `item-edit`.
+3. Report: closed + Done, noting whether automation handled it or you repaired.
+
+## `start <N>` — claim an issue (check-and-claim)
+
+Run when beginning work on an issue — worktree setup time is the natural
+moment. The claim signal is the board Status column and nothing else: humans
+claim by dragging the card to "In progress"; agents run this verb.
+
+1. Read the item id + current status live (graphql.md → Start).
+2. If status is already `In progress` → **abort**: report the issue is
+   already claimed and offer `next` for an alternative. Not an atomic lock —
+   good enough for one human + a few agents.
+3. Otherwise set `Status: In progress` via `item-edit`.
+4. `start --release <N>`: same lookup, set `Status: Ready` (abandon a claim).
+
+## `capture <idea>` — file an inbox issue (frictionless)
+
+Reuse the **dedup discipline** from the `file-bug-issue` skill, but take the
+*idea* path — no reproduction scaffolding.
+
+1. Shape a concise, specific title from the idea (e.g. "Cache batch
+   responses per ticker", not "caching").
+2. Dedup: `gh issue list --repo <repo> --state open --search "<distinctive terms>" --json number,title,url`.
+   If a genuine duplicate exists, add the new angle as a comment instead of a new
+   issue and report which. Different-but-related → create new and cross-link `#N`.
+3. Otherwise create it (see `references/graphql.md` → Capture): `--label inbox`,
+   body = the idea as-is (one loose sentence is fine; no required structure).
+4. Report the new issue URL. If mid-task, treat as a side-quest and return.
+
+## `triage` — turn inbox issues into scored graph nodes
+
+1. List the inbox: `gh issue list --repo <repo> --state open --label inbox --json number,title,url,body`.
+2. For each, present title + body and ask whether to promote (skip = leave in inbox).
+3. For a promoted issue, gather `Impact` (1–5), `Effort` (1–5), `Area` (**pick one
+   from the options present in `.backlog/project-meta.json`** → `fields.Area.options`),
+   and optional blockers.
+4. Apply, in order, the `references/graphql.md` → Triage commands:
+   add to project → set Impact/Effort (`--number`) → set
+   `Score` = round(Impact ÷ Effort, 1) (`--number`) → set Area +
+   `Status: Ready` (`--single-select-option-id`) → append `Blocked by: #…`
+   to the body if any → `--remove-label inbox`.
+5. After each, confirm it is now triaged (fields set, `inbox` gone). Report a
+   summary of promoted vs. left-in-inbox.
+
+## `next` — ranked, dependency-aware view (read-only)
+
+Runs the pure engine; makes no writes. Run **from the project root** (so the cwd
+walk-up finds `.backlog/project-meta.json`); do **not** `cd` into the skill dir:
+
+```bash
+python3 .claude/skills/backlog/rank.py
+```
+
+(Use whichever agent-skills path the store symlinked the skill into — e.g.
+`.agents/skills/backlog/rank.py`. The key is that the working directory stays at
+or below the repo root so `rank.py` can walk up to `.backlog/`.)
+
+`rank.py` pulls Project items + issue bodies via `gh`, parses `Blocked by:`
+edges, drops closed/`Done` blockers, and prints:
+
+- **Available** issues ranked by Impact÷Effort (unscored sort last, flagged
+  `[needs triage]`).
+- **Blocked** issues, unranked, annotated with what they wait on.
+
+Present the table as-is. If the user asks "why isn't #N at the top", point at its
+score or its blockers from the output. This in-memory ranking is the reason the
+skill exists over a bare `gh issue list`.

package/skills/backlog/meta.py

@@ -0,0 +1,18 @@
+"""Pure builder for project-meta.json from `gh project field-list` output. Stdlib only."""
+
+
+def build_project_meta(owner, repo, project_number, project_id, fields_json):
+    fields = {}
+    for field in fields_json.get("fields", []):
+        entry = {"id": field["id"]}
+        options = field.get("options")
+        if options:
+            entry["options"] = {opt["name"]: opt["id"] for opt in options}
+        fields[field["name"]] = entry
+    return {
+        "owner": owner,
+        "repo": repo,
+        "projectNumber": project_number,
+        "projectId": project_id,
+        "fields": fields,
+    }

package/skills/backlog/project-meta.example.json

@@ -0,0 +1,19 @@
+{
+  "owner": "<owner>",
+  "repo": "<owner>/<repo>",
+  "projectNumber": 0,
+  "projectId": "PVT_REPLACE_ME",
+  "fields": {
+    "Status": {
+      "id": "PVTSSF_REPLACE",
+      "options": {"Inbox": "...", "Ready": "...", "In progress": "...", "Done": "..."}
+    },
+    "Impact": {"id": "PVTF_REPLACE"},
+    "Effort": {"id": "PVTF_REPLACE"},
+    "Score": {"id": "PVTF_REPLACE"},
+    "Area": {
+      "id": "PVTSSF_REPLACE",
+      "options": {"feature": "...", "bug": "...", "infra": "...", "docs": "...", "research": "..."}
+    }
+  }
+}

package/skills/backlog/rank.py

@@ -0,0 +1,186 @@
+"""Pure ranking engine for `backlog next`. Stdlib only — no third-party deps."""
+import json
+import os
+import re
+import subprocess
+
+_BLOCKED_LINE = re.compile(r"^\s*Blocked by:\s*(.+)$", re.IGNORECASE | re.MULTILINE)
+_ISSUE_REF = re.compile(r"#(\d+)")
+
+
+def parse_blocked_by(body):
+    """Return sorted, unique issue numbers from every `Blocked by: #a, #b` line."""
+    if not body:
+        return []
+    nums = set()
+    for line in _BLOCKED_LINE.finditer(body):
+        for ref in _ISSUE_REF.findall(line.group(1)):
+            nums.add(int(ref))
+    return sorted(nums)
+
+
+def _as_int(value):
+    if value is None or value == "":
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def merge_sources(project_items, issue_rows):
+    """Join Project field values (item-list) with issue bodies/state (issue list)."""
+    bodies = {row["number"]: row for row in issue_rows}
+    merged = []
+    for item in project_items:
+        content = item.get("content") or {}
+        number = content.get("number")
+        if number is None:
+            continue  # draft item (no linked issue) — not part of the work graph
+        row = bodies.get(number, {})
+        merged.append({
+            "number": number,
+            "title": content.get("title", ""),
+            "url": content.get("url", ""),
+            "state": (row.get("state") or "OPEN").upper(),
+            "body": row.get("body") or "",
+            "status": item.get("status"),
+            "impact": _as_int(item.get("impact")),
+            "effort": _as_int(item.get("effort")),
+            "area": item.get("area"),
+        })
+    return merged
+
+
+def _blocker_satisfied(blocker):
+    return blocker["state"] == "CLOSED" or blocker.get("status") == "Done"
+
+
+def blockers_of(issue, by_number):
+    """Unsatisfied blocker numbers. Unknown blockers are dropped (mistyped-# tolerance)."""
+    waiting = []
+    for number in parse_blocked_by(issue["body"]):
+        blocker = by_number.get(number)
+        if blocker is None:
+            continue  # dropped edge
+        if not _blocker_satisfied(blocker):
+            waiting.append(number)
+    return waiting
+
+
+def is_available(issue, by_number):
+    return not blockers_of(issue, by_number)
+
+
+def score(issue):
+    impact, effort = issue.get("impact"), issue.get("effort")
+    if impact is None or effort is None or effort == 0:
+        return None
+    return impact / effort
+
+
+def _sort_key(issue):
+    value = score(issue)
+    return (
+        0 if value is not None else 1,   # scored issues first
+        -(value or 0.0),                 # higher score first
+        -(issue.get("impact") or 0),     # tiebreak: higher impact
+        issue["number"],                 # stable, deterministic
+    )
+
+
+def rank_issues(issues):
+    by_number = {i["number"]: i for i in issues}
+    candidates = [
+        i for i in issues
+        if i["state"] != "CLOSED" and i.get("status") != "Done"
+    ]
+    in_progress = [i for i in candidates if i.get("status") == "In progress"]
+    actionable = [i for i in candidates if i.get("status") != "In progress"]
+    available, blocked = [], []
+    for issue in actionable:
+        (available if is_available(issue, by_number) else blocked).append(issue)
+    available.sort(key=_sort_key)
+    blocked.sort(key=lambda i: i["number"])
+    in_progress.sort(key=lambda i: i["number"])
+    return {
+        "available": available,
+        "blocked": blocked,
+        "in_progress": in_progress,
+        "by_number": by_number,
+    }
+
+
+def render(result):
+    lines = []
+    if result["in_progress"]:
+        lines.append("In progress (claimed):")
+        for issue in result["in_progress"]:
+            lines.append(f"  #{issue['number']} {issue['title']}")
+        lines.append("")
+    lines += [
+        "Rank  Score  Issue                                   Area",
+        "----  -----  --------------------------------------  ----------",
+    ]
+    for idx, issue in enumerate(result["available"], start=1):
+        value = score(issue)
+        score_str = f"{value:.2f}" if value is not None else "  — "
+        flag = "" if value is not None else "  [needs triage]"
+        label = f"#{issue['number']} {issue['title']}"[:38].ljust(38)
+        area = (issue.get("area") or "-")
+        lines.append(f"{idx:>4}  {score_str:>5}  {label}  {area:<10}{flag}")
+
+    if result["blocked"]:
+        lines.append("")
+        lines.append("Blocked (not actionable yet):")
+        for issue in result["blocked"]:
+            waits = ", ".join(f"#{n}" for n in blockers_of(issue, result["by_number"]))
+            lines.append(f"  #{issue['number']} {issue['title']}  — waiting on {waits}")
+    return "\n".join(lines)
+
+
+def _gh_json(args):
+    completed = subprocess.run(args, capture_output=True, text=True, check=True)
+    return json.loads(completed.stdout)
+
+
+def main(owner, project_number, repo):
+    payload = _gh_json([
+        "gh", "project", "item-list", str(project_number),
+        "--owner", owner, "--format", "json", "--limit", "200",
+    ])
+    project_items = payload.get("items", [])
+    issue_rows = _gh_json([
+        "gh", "issue", "list", "--repo", repo, "--state", "all",
+        "--limit", "500", "--json", "number,body,state",
+    ])
+    issues = merge_sources(project_items, issue_rows)
+    print(render(rank_issues(issues)))
+
+
+def find_project_meta(start=None):
+    """Walk up from `start` (default cwd) to the nearest `.backlog/project-meta.json`.
+
+    Returns its absolute path. Raises FileNotFoundError with an actionable
+    message if no ancestor directory contains one.
+    """
+    origin = os.path.abspath(start or os.getcwd())
+    directory = origin
+    while True:
+        candidate = os.path.join(directory, ".backlog", "project-meta.json")
+        if os.path.isfile(candidate):
+            return candidate
+        parent = os.path.dirname(directory)
+        if parent == directory:  # reached the filesystem root
+            raise FileNotFoundError(
+                f"No .backlog/project-meta.json found walking up from {origin}. "
+                "Run `backlog setup` to provision the board and write it."
+            )
+        directory = parent
+
+
+if __name__ == "__main__":
+    config_path = find_project_meta()
+    with open(config_path) as handle:
+        meta = json.load(handle)
+    main(meta["owner"], meta["projectNumber"], meta["repo"])

package/skills/backlog/references/graphql.md

@@ -0,0 +1,121 @@
+# backlog — gh command reference
+
+All `<placeholders>` come from `.backlog/project-meta.json` unless noted:
+`<owner>`, `<repo>` (`owner/name`), `<projectNumber>`, `<projectId>`,
+`<fields.*.id>`, `<fields.*.options.*>`.
+
+## One-time auth (writes need the `project` scope)
+
+```bash
+gh auth status                     # confirm login
+gh auth refresh -s project         # add Projects-v2 write scope (one-time)
+```
+
+## Setup — create the board (idempotent; skip a step if it already exists)
+
+```bash
+# 1. Create the user-owned Project v2 (prints its number + URL)
+gh project create --owner <owner> --title "<Project Title> Backlog"
+
+# 2. Link it to the repo
+gh project link <projectNumber> --owner <owner> --repo <repo>
+
+# 3. Add fields (single-select options are comma-separated, order preserved)
+gh project field-create <projectNumber> --owner <owner> --name "Status" \
+  --data-type SINGLE_SELECT --single-select-options "Inbox,Ready,In progress,Done"
+gh project field-create <projectNumber> --owner <owner> --name "Impact" --data-type NUMBER
+gh project field-create <projectNumber> --owner <owner> --name "Effort" --data-type NUMBER
+gh project field-create <projectNumber> --owner <owner> --name "Score" --data-type NUMBER
+gh project field-create <projectNumber> --owner <owner> --name "Area" \
+  --data-type SINGLE_SELECT \
+  --single-select-options "feature,bug,infra,docs,research"
+
+# 4. Create the inbox label on the repo
+gh label create inbox --repo <repo> \
+  --description "Un-triaged capture" --color BFD4F2 || true
+
+# 5. Discover IDs to build .backlog/project-meta.json
+gh project view <projectNumber> --owner <owner> --format json   # -> id (projectId)
+gh project field-list <projectNumber> --owner <owner> --format json   # -> field + option ids
+```
+
+Reconcile note: `gh project field-create` errors if the field already exists —
+treat "already exists" as success. Projects that want a different Area taxonomy
+edit the option set on the GitHub board and re-run `setup`, which re-discovers the
+IDs into `.backlog/project-meta.json`.
+
+## Capture — file an inbox issue
+
+```bash
+gh issue create --repo <repo> \
+  --title "<concise idea title>" --label inbox \
+  --body "<one loose sentence is fine>"
+```
+
+## Triage — promote an inbox issue to a graph node
+
+```bash
+# Add issue to the project (prints the item id; capture it)
+gh project item-add <projectNumber> --owner <owner> --url <issueUrl>
+
+# Set number fields
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Impact.id> --number <1-5>
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Effort.id> --number <1-5>
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Score.id> --number <round(impact/effort, 1)>
+
+# Set single-selects (use the option id from .backlog/project-meta.json)
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Area.id> --single-select-option-id <fields.Area.options[area]>
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Status.id> --single-select-option-id <fields.Status.options.Ready>
+
+# Record blocking edges (append a line; keep any existing body)
+gh issue edit <number> --repo <repo> --body "<body>\n\nBlocked by: #<a>, #<b>"
+
+# Drop the inbox label
+gh issue edit <number> --repo <repo> --remove-label inbox
+```
+
+## Sub-issues (native parent/child) — GraphQL, no field IDs needed
+
+```bash
+# Resolve issue node IDs (<repoName> is the repo without the owner/ prefix)
+gh api graphql -f query='query($owner:String!,$repo:String!,$n:Int!){
+  repository(owner:$owner,name:$repo){issue(number:$n){id}}}' \
+  -F owner=<owner> -F repo=<repoName> -F n=<parentNumber>
+
+# Attach child to parent
+gh api graphql -f query='mutation($parent:ID!,$child:ID!){
+  addSubIssue(input:{issueId:$parent,subIssueId:$child}){issue{number}}}' \
+  -F parent=<parentNodeId> -F child=<childNodeId>
+```
+
+## Land — verify closed + Done (escape hatch; automation normally does this)
+
+```bash
+gh issue view <number> --repo <repo> --json state --jq .state
+gh project item-list <projectNumber> --owner <owner> --format json \
+  --jq '.items[] | select(.content.number==<number>) | {id, status}'
+# repair only if needed:
+gh issue close <number> --repo <repo>
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Status.id> --single-select-option-id <fields.Status.options.Done>
+```
+
+## Start — check-and-claim
+
+```bash
+# 1. Item id + live status
+gh project item-list <projectNumber> --owner <owner> --format json \
+  --jq '.items[] | select(.content.number==<number>) | {id, status}'
+# 2. If status == "In progress": abort (already claimed).
+# 3. Claim:
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Status.id> --single-select-option-id <fields.Status.options["In progress"]>
+# --release: set Ready instead
+gh project item-edit --project-id <projectId> --id <itemId> \
+  --field-id <fields.Status.id> --single-select-option-id <fields.Status.options.Ready>
+```

package/skills/backlog/test_meta.py

@@ -0,0 +1,21 @@
+import meta
+
+
+def test_build_project_meta_maps_fields_and_options():
+    fields_json = {"fields": [
+        {"id": "F_status", "name": "Status", "type": "ProjectV2SingleSelectField",
+         "options": [{"id": "o_inbox", "name": "Inbox"}, {"id": "o_ready", "name": "Ready"}]},
+        {"id": "F_impact", "name": "Impact", "type": "ProjectV2Field"},
+        {"id": "F_area", "name": "Area", "type": "ProjectV2SingleSelectField",
+         "options": [{"id": "o_feat", "name": "feature"}]},
+    ]}
+    out = meta.build_project_meta("acme", "acme/widget", 7, "PVT_x", fields_json)
+    assert out["owner"] == "acme"
+    assert out["repo"] == "acme/widget"
+    assert out["projectNumber"] == 7
+    assert out["projectId"] == "PVT_x"
+    assert out["fields"]["Status"]["id"] == "F_status"
+    assert out["fields"]["Status"]["options"]["Ready"] == "o_ready"
+    assert out["fields"]["Impact"]["id"] == "F_impact"
+    assert "options" not in out["fields"]["Impact"]
+    assert out["fields"]["Area"]["options"]["feature"] == "o_feat"

package/skills/backlog/test_rank.py

@@ -0,0 +1,214 @@
+import rank
+
+
+def test_parse_blocked_by_basic():
+    assert rank.parse_blocked_by("Blocked by: #12, #34") == [12, 34]
+
+
+def test_parse_blocked_by_case_insensitive_and_multiline():
+    body = "Some idea.\n\nblocked BY: #5\nMore text\nBlocked by: #5, #9"
+    assert rank.parse_blocked_by(body) == [5, 9]  # deduped + sorted
+
+
+def test_parse_blocked_by_none_and_empty():
+    assert rank.parse_blocked_by(None) == []
+    assert rank.parse_blocked_by("no blockers here") == []
+
+
+def test_merge_sources_joins_fields_and_bodies():
+    project_items = [
+        {"content": {"number": 12, "title": "Add X", "url": "u/12"},
+         "status": "Ready", "impact": 4, "effort": 2, "area": "feature"},
+        {"content": {"number": 34, "title": "Do Y", "url": "u/34"}},  # untriaged, no fields
+        {"title": "a draft note"},  # draft item, no content -> skipped
+    ]
+    issue_rows = [
+        {"number": 12, "body": "Blocked by: #34", "state": "open"},
+        {"number": 34, "body": "loose idea", "state": "open"},
+    ]
+    out = rank.merge_sources(project_items, issue_rows)
+    assert [i["number"] for i in out] == [12, 34]
+    twelve = out[0]
+    assert twelve["state"] == "OPEN"
+    assert twelve["impact"] == 4 and twelve["effort"] == 2
+    assert twelve["area"] == "feature" and twelve["status"] == "Ready"
+    assert twelve["body"] == "Blocked by: #34"
+    thirtyfour = out[1]
+    assert thirtyfour["impact"] is None and thirtyfour["status"] is None
+
+
+def test_merge_sources_missing_body_row_defaults_open_empty():
+    out = rank.merge_sources(
+        [{"content": {"number": 7, "title": "T", "url": "u/7"}, "impact": 3, "effort": 1}],
+        [],  # no matching issue row
+    )
+    assert out[0]["state"] == "OPEN" and out[0]["body"] == ""
+
+
+def _issue(number, body="", state="OPEN", status=None):
+    return {"number": number, "title": f"i{number}", "url": "", "state": state,
+            "body": body, "status": status, "impact": None, "effort": None, "area": None}
+
+
+def test_availability_and_blockers():
+    a = _issue(1, body="Blocked by: #2, #3, #4")
+    by_number = {
+        1: a,
+        2: _issue(2, state="CLOSED"),          # satisfied — closed
+        3: _issue(3, state="OPEN", status="Done"),  # satisfied — Status Done
+        4: _issue(4, state="OPEN", status="Ready"),  # NOT satisfied — still open/active
+    }
+    assert rank.is_available(a, by_number) is False
+    assert rank.blockers_of(a, by_number) == [4]
+
+
+def test_available_when_no_blockers():
+    a = _issue(1, body="just an idea")
+    assert rank.is_available(a, {1: a}) is True
+    assert rank.blockers_of(a, {1: a}) == []
+
+
+def test_unknown_blocker_is_dropped_edge():
+    a = _issue(1, body="Blocked by: #999")  # #999 not in the graph
+    assert rank.is_available(a, {1: a}) is True   # dropped, not blocking
+    assert rank.blockers_of(a, {1: a}) == []
+
+
+def _scored(number, impact, effort, body="", state="OPEN", status="Ready"):
+    return {"number": number, "title": f"i{number}", "url": "", "state": state,
+            "body": body, "status": status, "impact": impact, "effort": effort, "area": None}
+
+
+def test_score_ratio_and_unscored():
+    assert rank.score(_scored(1, 4, 2)) == 2.0
+    assert rank.score(_scored(1, None, 2)) is None
+    assert rank.score(_scored(1, 4, None)) is None
+    assert rank.score(_scored(1, 4, 0)) is None  # guard divide-by-zero
+
+
+def test_rank_orders_available_and_separates_blocked_and_done():
+    issues = [
+        _scored(1, 2, 2),                       # score 1.0
+        _scored(2, 5, 1),                       # score 5.0  -> rank 1
+        _scored(3, None, None),                 # unscored -> last, needs triage
+        _scored(4, 9, 1, body="Blocked by: #2"),  # blocked (2 is open/Ready)
+        _scored(5, 4, 1, status="Done"),        # Done -> excluded entirely
+    ]
+    result = rank.rank_issues(issues)
+    assert [i["number"] for i in result["available"]] == [2, 1, 3]
+    assert [i["number"] for i in result["blocked"]] == [4]
+    assert 5 not in [i["number"] for i in result["available"] + result["blocked"]]
+
+
+def test_rank_excludes_closed():
+    issues = [_scored(1, 3, 1, state="CLOSED"), _scored(2, 1, 1)]
+    result = rank.rank_issues(issues)
+    assert [i["number"] for i in result["available"]] == [2]
+
+
+def test_render_contains_ranks_scores_flags_and_blocked_reason():
+    issues = [
+        _scored(2, 5, 1),                          # score 5.00, rank 1
+        _scored(3, None, None),                    # needs triage
+        _scored(4, 9, 1, body="Blocked by: #2"),   # blocked on #2
+    ]
+    text = rank.render(rank.rank_issues(issues))
+    assert "#2 i2" in text
+    assert "5.00" in text
+    assert "[needs triage]" in text
+    assert "Blocked" in text and "waiting on #2" in text
+
+
+def test_render_no_blocked_section_when_none_blocked():
+    text = rank.render(rank.rank_issues([_scored(1, 2, 1)]))
+    assert "Blocked" not in text
+
+
+def test_rank_separates_in_progress_claimed():
+    issues = [
+        _scored(1, 2, 2),                            # score 1.0, available
+        _scored(2, 5, 1, status="In progress"),      # claimed -> never recommended
+    ]
+    result = rank.rank_issues(issues)
+    assert [i["number"] for i in result["available"]] == [1]
+    assert [i["number"] for i in result["in_progress"]] == [2]
+    assert result["blocked"] == []
+
+
+def test_in_progress_with_blockers_goes_to_claimed_not_blocked():
+    issues = [
+        _scored(1, 3, 1),
+        _scored(2, 4, 1, status="In progress", body="Blocked by: #1"),
+    ]
+    result = rank.rank_issues(issues)
+    assert [i["number"] for i in result["in_progress"]] == [2]
+    assert result["blocked"] == []
+
+
+def test_in_progress_item_still_blocks_its_dependents():
+    # A claimed blocker is not yet Done -> dependents stay blocked.
+    issues = [
+        _scored(1, 3, 1, status="In progress"),
+        _scored(2, 4, 1, body="Blocked by: #1"),
+    ]
+    result = rank.rank_issues(issues)
+    assert [i["number"] for i in result["blocked"]] == [2]
+    assert [i["number"] for i in result["in_progress"]] == [1]
+
+
+def test_render_shows_claimed_section_first():
+    issues = [_scored(1, 2, 1), _scored(2, 5, 1, status="In progress")]
+    text = rank.render(rank.rank_issues(issues))
+    assert text.startswith("In progress (claimed):")
+    assert "#2 i2" in text
+
+
+def test_render_no_claimed_section_when_none_in_progress():
+    text = rank.render(rank.rank_issues([_scored(1, 2, 1)]))
+    assert "claimed" not in text
+
+
+import os
+
+import pytest
+
+
+def test_find_project_meta_in_cwd(tmp_path, monkeypatch):
+    backlog = tmp_path / ".backlog"
+    backlog.mkdir()
+    meta_file = backlog / "project-meta.json"
+    meta_file.write_text("{}")
+    monkeypatch.chdir(tmp_path)
+    assert rank.find_project_meta() == str(meta_file)
+
+
+def test_find_project_meta_walks_up_from_subdir(tmp_path, monkeypatch):
+    backlog = tmp_path / ".backlog"
+    backlog.mkdir()
+    meta_file = backlog / "project-meta.json"
+    meta_file.write_text("{}")
+    nested = tmp_path / "backend" / "deep"
+    nested.mkdir(parents=True)
+    monkeypatch.chdir(nested)
+    assert rank.find_project_meta() == str(meta_file)
+
+
+def test_find_project_meta_nearest_ancestor_wins(tmp_path, monkeypatch):
+    outer = tmp_path / ".backlog"
+    outer.mkdir()
+    (outer / "project-meta.json").write_text("{}")
+    inner_root = tmp_path / "sub"
+    inner_backlog = inner_root / ".backlog"
+    inner_backlog.mkdir(parents=True)
+    inner_meta = inner_backlog / "project-meta.json"
+    inner_meta.write_text("{}")
+    monkeypatch.chdir(inner_root)
+    assert rank.find_project_meta() == str(inner_meta)
+
+
+def test_find_project_meta_errors_clearly_when_absent(tmp_path, monkeypatch):
+    monkeypatch.chdir(tmp_path)
+    with pytest.raises(FileNotFoundError) as exc:
+        rank.find_project_meta()
+    assert ".backlog/project-meta.json" in str(exc.value)
+    assert "backlog setup" in str(exc.value)

package/skills/pr-visual-diff/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: pr-visual-diff
+description: Capture before/after screenshots of UI views with Playwright and embed them in a PR. Use this skill whenever creating or preparing a pull request that touches frontend code (components, views, styles, layout, Tailwind classes) — even if the user just says "open a PR" or "create the PR" after UI work, and especially if they mention screenshots, visual diff, before/after, or "show what changed". Also use when the user asks to add screenshots to an existing PR.
+---
+
+# PR Visual Diff
+
+Produce before/after screenshots of the views affected by a branch's frontend
+changes, commit them on the PR branch, and embed them in the PR body. Reviewers
+should see what changed visually without checking out the branch.
+
+The approach leans on the project's existing Playwright e2e harness with the
+**API mocked**: because the data is stubbed and identical across both runs, any
+pixel difference between "before" and "after" is caused by the code change
+alone — that's the property that makes the comparison trustworthy. Never
+screenshot against a live backend for this purpose.
+
+Because every project wires this differently, the skill **discovers** the
+project's setup once and caches it, then reuses the cache on later runs.
+
+## Step 0. Load or build the per-project config
+
+The config cache lives beside this skill at
+`<skill-dir>/pr-visual-diff.<slug>.json`, where `<slug>` is the target repo's
+directory name. It is gitignored — local to this machine. Ensure the cache file is ignored in the `.gitignore` of the repo where you install the skill directory (add an entry like `pr-visual-diff.*.json` if it isn't already).
+
+- **If the cache exists**, read it and skip to "When NOT to run the capture".
+  If it says `{"supported": false}`, tell the user this project has no
+  mocked-API harness and create a plain PR (see Preconditions), then stop.
+- **If it does not exist**, run the discovery pass below to build it.
+
+### Discovery pass (first run only)
+
+Inspect the target repo and record these values, then write them to the cache
+file as JSON:
+
+| Key | How to find it |
+|---|---|
+| `frontendDir` | the dir holding the app + its `src/` (repo root or a subdir like `frontend/`) |
+| `e2eDir`, `specsDir` | the Playwright spec/support tree (look for `playwright.config.*`, a `specs/` dir) |
+| `authFixtureImport`, `authFixtureName`, `authedPageProp` | the support file exporting a `test` fixture that seeds auth; note its import path, the exported name, and the authed-page property (e.g. `authenticatedPage`) |
+| `mockHelperImport`, `mockHelperName` | the helper that stubs `/api` routes with fixture data; its import path + exported name |
+| `port` | the `webServer` port in the Playwright config |
+| `deviceProjects` | the config's `projects` (default to a desktop + a mobile project) |
+| `baseBranch` | the repo's default branch (`main`/`master`; `git symbolic-ref refs/remotes/origin/HEAD`) |
+| `packageManager` | infer from lockfile: `pnpm-lock.yaml`→pnpm, `package-lock.json`→npm, `yarn.lock`→yarn, `bun.lockb`→bun |
+| `screenshotDir` | default `docs/pr-screenshots` |
+| `spinnerSelector` | the app's loading-indicator selector (search for a spinner/`role="status"`/`aria-busy` component) |
+
+### Preconditions gate
+
+The discovery pass is also the gate. **If there is no Playwright e2e harness
+that mocks the API** (no mock helper, or no Playwright at all), write
+`{ "supported": false, "reason": "<why>" }` to the cache, tell the user that a
+trustworthy before/after diff isn't possible here (unmocked data would differ
+between runs for reasons other than the code change), and **create a plain PR
+instead** — no screenshots. Then stop.
+
+## When NOT to run the capture
+
+If `git diff --name-only $(git merge-base <baseBranch> HEAD)...HEAD` shows no
+changes under `<frontendDir>/src/`, there is nothing visual to diff — create the
+PR normally and say so. Test-only, docs-only, or backend-only diffs don't need
+screenshots.
+
+## Always run the capture in a subagent
+
+Steps 2–6 (writing the spec, capturing, **reading every PNG back to eyeball
+it**, committing, embedding) MUST run inside a single dispatched subagent — not
+in the main context. Reading screenshots back is this skill's dominant token
+cost, and those image bytes are worthless to the main thread; keeping them in a
+subagent's throwaway context is the whole savings, with no loss of verification.
+
+Main context does only: step 1 (map the diff, get the user's go-ahead), then
+dispatch a subagent with the plan and the config values. The subagent returns a
+compact report: the committed screenshot paths + pinned URLs, the PR-body
+markdown, and any views it flagged. The main context creates/edits the PR from
+that report — it never reads a PNG.
+
+## Workflow
+
+### 1. Map the diff to views, then get the user's go-ahead
+
+List changed files against the merge base (`git merge-base <baseBranch> HEAD`).
+For each changed component, trace upward (imports → page/route component → route
+path) to find the route(s) where it renders, and note any interaction needed to
+make it visible (open a modal, select a tab). Classify each view as **changed**
+(existed at the merge base) or **new** (introduced by this branch) — new ones
+get an after-only shot.
+
+This capture is heavy (temp worktree, two Playwright passes, a commit pushed to
+the branch, PR body rewritten). ALWAYS confirm with AskUserQuestion before
+running any of it. The question must cover **both** (a) whether to run the whole
+before/after capture at all, and (b) that it will commit the screenshots and
+embed them in the PR. Include the proposed plan: which routes/states, and which
+device projects — default to the config's `deviceProjects`; add more only when
+the change is layout-sensitive. If they decline, create the PR normally and stop.
+
+### 2. Write the capture spec
+
+Copy `references/capture-spec-template.ts` from this skill into
+`<specsDir>/__pr-capture__.spec.ts` and substitute the `__PVD_*__` markers from
+the config:
+
+- `__PVD_AUTH_FIXTURE_IMPORT__` → `authFixtureImport` (and, if the fixture isn't
+  named `test`, adjust the `import { <authFixtureName> as test }` accordingly)
+- `__PVD_MOCK_HELPER_IMPORT__` → `mockHelperImport` (and `mockHelperName` if not
+  `mockApi`)
+- `__PVD_SPINNER_SELECTOR__` → `spinnerSelector`
+- the `{ authenticatedPage: page }` destructure → `{ <authedPageProp>: page }`
+
+Then fill in the `VIEWS` array. This file is scaffolding: never commit it, and
+delete it when done (it lives in the specs dir, so a forgotten copy would run in
+every future e2e invocation).
+
+### 3. Capture "after" (current branch)
+
+From `<frontendDir>`. First make sure nothing is listening on `<port>`
+(`lsof -nP -i :<port>`) and kill any stray server there: if the Playwright
+config has `reuseExistingServer` on locally, a leftover server from another
+worktree would be silently reused and you'd screenshot the *wrong code*.
+
+```bash
+PR_SHOT_DIR=<scratchpad>/after PR_SHOT_LABEL=after \
+  <packageManager> exec playwright test <specsDir>/__pr-capture__.spec.ts \
+  --project=<deviceProject> [--project=<deviceProject>...]
+```
+
+Playwright boots its own server and tears it down. The template pins
+`deviceScaleFactor: 1` and asserts no spinner is left on screen, so a
+raced/under-mocked view fails the test instead of producing a misleading shot.
+That assertion is a backstop, not a substitute for looking: the subagent still
+Reads each PNG after capture — an empty state, error toast, or wrong content
+passes the spinner check but is still wrong. On a genuine failure, fix the spec
+(add mock stubs, a wait for a stable element, or correct the spinner selector)
+rather than shipping a bad screenshot.
+
+### 4. Capture "before" (merge base, temp worktree)
+
+A "before" shot only makes sense for views that already existed. If a view is
+introduced by this branch, capture only its "after" shot and present it as
+**New** (step 6). If *every* captured view is new, skip this whole step.
+
+For views that did exist, reconstruct the pre-change app from git:
+
+```bash
+BASE=$(git merge-base <baseBranch> HEAD)
+git worktree add <scratchpad>/pr-before-shots "$BASE"
+cd <scratchpad>/pr-before-shots/<frontendDir> && <packageManager> install
+```
+
+Copy the same filled `__pr-capture__.spec.ts` into that worktree's specs dir,
+then run the same command with `PR_SHOT_DIR=<scratchpad>/before
+PR_SHOT_LABEL=before`. Run it sequentially after the "after" pass — both configs
+use `<port>`.
+
+Edge cases:
+- A route that doesn't exist at the base (new view): skip it and label it
+  **New** in the PR table.
+- The e2e helpers (auth fixture, mock helper) missing or different at the base:
+  adapt the spec copy to what exists there; the goal is the same rendered view,
+  not identical spec code.
+- `<packageManager> install` failing on a native binding: rerun once; if it
+  persists, report it rather than screenshotting a broken build.
+
+Remove the worktree when done:
+`git worktree remove --force <scratchpad>/pr-before-shots` (`--force` because
+install left untracked artifacts).
+
+### 5. Commit the images on the PR branch
+
+```
+<screenshotDir>/<branch-slug>/<view>--<project>--{before|after}.png
+```
+
+`<branch-slug>` = branch name with `/` → `-`. Keep only the shots you'll
+reference. Commit them, delete the temp spec, and push.
+
+### 6. Embed in the PR body
+
+After pushing, pin image URLs to the exact commit so they keep rendering after
+later force-pushes or branch deletion:
+
+```bash
+SHA=$(git rev-parse HEAD)
+REPO=$(gh repo view --json nameWithOwner -q .nameWithOwner)
+# → https://github.com/$REPO/blob/$SHA/<screenshotDir>/<slug>/<file>.png?raw=true
+```
+
+Per view, one table. Put **Before on the left and After on the right** (one
+device per row) so a reviewer sees the original and changed component side by
+side:
+
+```markdown
+### <View name> (`/route`)
+
+| | Before | After |
+|---|---|---|
+| **Desktop** | ![](<blob-url>?raw=true) | ![](<blob-url>?raw=true) |
+| **Mobile** | ![](<blob-url>?raw=true) | ![](<blob-url>?raw=true) |
+```
+
+If the repo is private, GitHub's image proxy may refuse to inline blob URLs in
+the PR body. Add a one-line note under the tables linking to the
+`<screenshotDir>/<slug>/` directory on the branch as a fallback — the images
+always render in the Files-changed tab and in blob view for authenticated
+viewers.
+
+The subagent's job ends here: it has pushed the commit and produced the PR-body
+markdown, and returns both. The **main context** creates (or edits) the PR with
+that body, then opens it (`gh pr view --web`) so the user can confirm the embeds
+render.
+
+For a **new** view there is no Before, so put a **New view** label in the left
+cell instead of an image:
+
+```markdown
+| | Before | After |
+|---|---|---|
+| **Desktop** | _New view_ | ![](<blob-url>?raw=true) |
+| **Mobile** | _New view_ | ![](<blob-url>?raw=true) |
+```
+
+## Adding shots to an existing PR
+
+Same flow; the only differences: diff against the PR's base branch
+(`gh pr view --json baseRefName`) instead of `<baseBranch>`, and edit the body
+with `gh pr edit --body-file` instead of creating.

package/skills/pr-visual-diff/references/capture-spec-template.ts

@@ -0,0 +1,82 @@
+/**
+ * pr-visual-diff capture spec — TEMPORARY SCAFFOLDING, never commit.
+ *
+ * This is a template. Before running, substitute every __PVD_*__ marker below
+ * with the value from this project's discovery cache
+ * (<skill-dir>/pr-visual-diff.<slug>.json). The markers exist because
+ * each project wires its Playwright auth fixture and API mock differently.
+ *
+ * Copy the filled result to <specsDir>/__pr-capture__.spec.ts, then run:
+ *
+ *   PR_SHOT_DIR=<abs-out-dir> PR_SHOT_LABEL=after \
+ *     <packageManager> exec playwright test <specsDir>/__pr-capture__.spec.ts \
+ *     --project=<deviceProject> [--project=<deviceProject>...]
+ *
+ * Delete the copy when done — anything left in the specs dir runs on every e2e pass.
+ */
+import { expect, type Page } from '@playwright/test';
+// __PVD_AUTH_IMPORT__: import the project's test fixture.
+// From config: import { <authFixtureName> } from '<authFixtureImport>'
+import { test } from '__PVD_AUTH_FIXTURE_IMPORT__';
+// __PVD_MOCK_IMPORT__: import the project's API-mock helper.
+// From config: import { <mockHelperName> } from '<mockHelperImport>'
+import { mockApi } from '__PVD_MOCK_HELPER_IMPORT__';
+
+const OUT = process.env.PR_SHOT_DIR;
+const LABEL = process.env.PR_SHOT_LABEL ?? 'after';
+if (!OUT) throw new Error('PR_SHOT_DIR must be set to an absolute output directory');
+
+// Selector for this app's loading indicator. From config: <spinnerSelector>.
+const SPINNER = '__PVD_SPINNER_SELECTOR__';
+
+// Pin device-pixel-ratio to 1 for every project. Device descriptors (iPhone 14,
+// Pixel 7, iPad) default to DPR 2-3, producing PNGs 4-9x larger for zero review
+// value — and those bytes land in the main context when the shots get read back.
+test.use({ deviceScaleFactor: 1 });
+
+interface View {
+  /** Slug used in the filename, e.g. 'dashboard' or 'add-position-modal'. */
+  name: string;
+  /** Route to open, e.g. '/dashboard'. */
+  path: string;
+  /** Optional interactions to reach the state (open a modal, pick a tab…). */
+  prepare?: (page: Page) => Promise<void>;
+  /** Full-page scroll capture (default) vs just the viewport. */
+  fullPage?: boolean;
+}
+
+const VIEWS: View[] = [
+  // { name: 'dashboard', path: '/dashboard' },
+  // {
+  //   name: 'add-position-modal',
+  //   path: '/',
+  //   prepare: async (page) => {
+  //     await page.getByRole('button', { name: /add symbol/i }).click();
+  //     await page.getByRole('dialog').waitFor();
+  //   },
+  // },
+];
+
+for (const view of VIEWS) {
+  // __PVD_PAGE_PROP__: destructure the project's authed-page fixture prop.
+  // From config: { <authedPageProp>: page }
+  test(`pr-capture: ${view.name}`, async ({ authenticatedPage: page }, testInfo) => {
+    await mockApi(page);
+    await page.goto(view.path);
+    await page.waitForLoadState('networkidle');
+    await view.prepare?.(page);
+    // Guard against shipping a misleading shot: a spinner still on screen means
+    // the mock is missing an endpoint or prepare() raced the render. Fail loudly
+    // here instead of committing a loading-state PNG.
+    await expect(
+      page.locator(SPINNER),
+      `${view.name}: a spinner is still visible — fix the mock/prepare before capturing`,
+    ).toHaveCount(0);
+    await page.screenshot({
+      path: `${OUT}/${view.name}--${testInfo.project.name}--${LABEL}.png`,
+      fullPage: view.fullPage ?? true,
+      animations: 'disabled',
+      caret: 'hide',
+    });
+  });
+}

package/skills-manifest.json

@@ -1,7 +1,13 @@
 {
   "schemaVersion": 1,
-  "generatedAt": "2026-07-14T10:05:20.198Z",
+  "generatedAt": "2026-07-16T10:07:19.685Z",
   "skills": [
+    {
+      "name": "backlog",
+      "version": "0.1.0",
+      "hash": "sha256-ac26c0313981666dfc143bb6eabbf603e0b02111c13ea543e1c86c2900e40559",
+      "description": "Manage a GitHub-Issues-backed backlog and a Projects-v2 work graph via five verbs. Use when the user wants to CAPTURE an idea/research thread (\"add to backlog\", \"capture this\", \"note this idea\", \"log a task\"), TRIAGE the inbox (\"triage the backlog\", \"score the inbox\"), see what to work on NEXT (\"what's next\", \"what should I work on\", \"ranked backlog\", \"next actionable task\"), LAND a finished item (\"mark done\", \"close out #N\"), or SETUP the board the first time. Ranks open issues by impact÷effort, respecting `Blocked by:` edges, so only actionable work surfaces."
+    },
     {
       "name": "branch-audit",
       "version": "0.1.0",
@@ -25,6 +31,12 @@
       "version": "0.1.0",
       "hash": "sha256-916ea397cd74d91c4b6060672088b9c54353c915b98bcaef3514815694842e5a",
       "description": "Minimal example skill proving the distribution pipeline works. Responds to \"test my skills setup\" by confirming the skill is loaded."
+    },
+    {
+      "name": "pr-visual-diff",
+      "version": "0.1.0",
+      "hash": "sha256-4e386dd175a34e55e89e0e29e37f5d0afd927560b7e3ba4c5f3ef482fb73f722",
+      "description": "Capture before/after screenshots of UI views with Playwright and embed them in a PR. Use this skill whenever creating or preparing a pull request that touches frontend code (components, views, styles, layout, Tailwind classes) — even if the user just says \"open a PR\" or \"create the PR\" after UI work, and especially if they mention screenshots, visual diff, before/after, or \"show what changed\". Also use when the user asks to add screenshots to an existing PR."
     }
   ]
 }