skilldrop-cli 1.0.1 → 1.1.0

package/packs/{solution-architect → core}/skills/context-graph/reference.md

@@ -30,6 +30,7 @@ Every `.md` file in them, recursively, is a record, except:
 | missing paths | a path that looks like the repository's (its first part is a top-level folder that exists) but doesn't exist |
 | moved | for a missing path, an existing sibling with a close name (`services/ledger-sync` → `services/ledger`), where the code may have gone |
 | commits | with `--git`: commits whose subject or body mentions the id, newest first, up to 20 |
+| drift | with `--git`, for a current record that governs a path: the commits that changed those paths since the record's date, newest first. When the record has no date, they count from when its file was first committed. Each has its author and whether it cites the record. Also gives the authors and their counts, the last change, and when the record file was last edited. Merges are left out |
 
 **Statuses, normalised:**
 
@@ -81,6 +82,11 @@ A file that isn't UTF-8 is skipped, with a note in the report.
     "date": "2025-03-02", "path": "docs/adr/0004-….md",
     "supersedes": [], "superseded_by": [], "amends": [], "cites": [], "cited_by": [],
     "governs": ["services/orders/"], "missing_paths": [], "commits": [],
+    "drift": {"since": "2025-03-02", "since_from": "record", "count": 3, "not_citing_record": 2,
+              "authors": [{"name": "Ben", "commits": 2}, {"name": "Ana", "commits": 1}],
+              "last_change": "2026-06-04", "record_last_edited": "2025-03-02",
+              "commits": [{"sha": "a1b2c3d", "date": "2026-06-04", "author": "Ben", "subject": "…",
+                           "cites_record": false}]},
     "successors": ["ADR-0009"], "successors_only_claimed_by_successor": ["ADR-0009"],
     "moved": {"services/kafka-bridge": ["services/bridge"]}
   }],
@@ -91,9 +97,31 @@ A file that isn't UTF-8 is skipped, with a note in the report.
 }
 ```
 
+`drift` is `null` without `--git`, and for a record that isn't current or governs no path.
+
 `successors` joins a record's own "superseded by" with every record that says it supersedes this
 one. The second list holds the ones only the newer record records.
 
+## Code changed since each decision (`--git`)
+
+The full report gains a table of the current decisions whose governed code has changed since
+they were made, most changed first:
+
+| Column | Meaning |
+|---|---|
+| Decided | the record's date; `*` when it has none and the date is when the record was first committed |
+| Commits since | commits to the governed paths since that date, merges left out |
+| Not citing it | how many of those don't mention the record's id: the changes made without reference to it |
+| By | the authors, with their counts, most first |
+| Last change | the newest of those commits |
+| Record last edited | the last commit to the record file itself |
+
+`--why` adds a "Changed since" line under each current decision, and `--record` lists up to 10
+of the commits. The Markdown table shows 15 rows; `--json` has them all.
+
+A commit to a decision's code is a reason to check it, not drift by itself. Drift is a
+requirement in the record that the code no longer meets.
+
 ## Limits
 
 - **A decision made in a ticket or a chat, and never written down, isn't in the graph.** The

package/packs/{solution-architect → core}/skills/context-graph/scripts/context_graph.py

@@ -3,13 +3,14 @@
 
 Reads decision records (ADRs, RFCs, design decisions) as Markdown, finds each one's id, title,
 status and date, and the edges between them: what supersedes or amends what, which records cite
-which, the files and folders each one governs, and, with --git, the commits that mention it.
+which, the files and folders each one governs, and, with --git, the commits that mention it and
+the commits that changed each current decision's code since it was made, and who made them.
 Then it checks the graph for what goes wrong as a codebase ages: a supersession only one side
 records, a current decision pointing at code that is gone, two current decisions governing the
 same path, references to records that don't exist.
 
   python3 context_graph.py                          # find records under ./docs, check them
-  python3 context_graph.py --root repo --git        # and the commits that mention each record
+  python3 context_graph.py --root repo --git        # and the commits behind each record, and since it
   python3 context_graph.py --why src/auth/session.py
   python3 context_graph.py --record ADR-0004
   python3 context_graph.py --docs architecture/decisions --json -o graph.json --mermaid graph.mmd
@@ -191,7 +192,7 @@ def parse_record(path, root, text):
     rec = {"id": rid, "title": title_of(meta, body, stem.replace("-", " ")), "status": status,
            "status_text": raw_status, "date": date_of(meta, body), "path": rel,
            "supersedes": [], "superseded_by": [], "amends": [], "cites": [], "governs": [],
-           "missing_paths": [], "commits": []}
+           "missing_paths": [], "commits": [], "drift": None}
     rec["supersedes"] += list_ids(meta.get("supersedes", "")) + list_ids(meta.get("replaces", ""))
     rec["superseded_by"] += list_ids(meta.get("superseded_by", "")) + list_ids(meta.get("replaced_by", ""))
     rec["amends"] += list_ids(meta.get("amends", ""))
@@ -290,6 +291,69 @@ def git_commits(root, records, limit):
     return None
 
 
+def _git(root, *args):
+    """stdout of a git command in root, or None when git is missing or the command fails."""
+    try:
+        out = subprocess.run(["git", "-C", root, *args], capture_output=True, text=True,
+                             encoding="utf-8", errors="replace", timeout=60)
+    except (OSError, subprocess.SubprocessError):
+        return None
+    return out.stdout if out.returncode == 0 else None
+
+
+def git_drift(root, records, limit):
+    """For each current decision that governs code: the commits that changed that code since the
+    decision was made, who made them, and when the record itself was last edited. Code that keeps
+    changing under a record nobody revisits is where a decision quietly stops being true."""
+    for r in records:
+        if r["status"] not in CURRENT or r["successors"] or not r["governs"]:
+            continue
+        since, source = r["date"], "record"
+        if not since:  # no date in the record: when the record was first committed
+            added = _git(root, "log", "--diff-filter=A", "--follow", "--date=short", "--format=%ad", "--", r["path"])
+            since, source = ((added or "").split() or [""])[-1], "git"
+        if not since:
+            r["drift"] = {"since": None, "note": "the record has no date and isn't committed, so changes since it can't be dated"}
+            continue
+        log = _git(root, "log", "--no-merges", "--since=%s 00:00" % since, "-n", str(limit), "--date=short",
+                   "--format=%h%x1f%ad%x1f%an%x1f%s%x1f%b%x1e", "--", *[g.rstrip("/") or "." for g in r["governs"]])
+        commits = []
+        for entry in (log or "").split("\x1e"):
+            parts = entry.strip("\n").split("\x1f")
+            if len(parts) < 4:
+                continue
+            body = parts[4] if len(parts) > 4 else ""
+            commits.append({"sha": parts[0], "date": parts[1], "author": parts[2], "subject": parts[3][:120],
+                            "cites_record": r["id"] in ids_in(parts[3] + "\n" + body)})
+        authors = {}
+        for c in commits:
+            authors[c["author"]] = authors.get(c["author"], 0) + 1
+        edited = (_git(root, "log", "-1", "--date=short", "--format=%ad", "--", r["path"]) or "").strip()
+        r["drift"] = {
+            "since": since, "since_from": source, "count": len(commits),
+            "not_citing_record": sum(1 for c in commits if not c["cites_record"]),
+            "authors": [{"name": n, "commits": k} for n, k in sorted(authors.items(), key=lambda x: (-x[1], x[0]))],
+            "last_change": commits[0]["date"] if commits else None,
+            "record_last_edited": edited or None,
+            "commits": commits[:20],
+        }
+
+
+def drift_line(d):
+    """One line: '12 commits by Ana (9), Ben (3) since 2026-02-10, the last on 2026-09-30'."""
+    if not d or d.get("since") is None:
+        return (d or {}).get("note", "")
+    if not d["count"]:
+        return "no commits have changed its code since %s" % d["since"]
+    who = ", ".join("%s (%d)" % (a["name"], a["commits"]) for a in d["authors"][:4]) + (" …" if len(d["authors"]) > 4 else "")
+    cite = "" if not d["not_citing_record"] else ("; %d don't cite the record" % d["not_citing_record"]
+                                                  if d["not_citing_record"] < d["count"] else "; none cites the record")
+    return "%d commit%s by %s since %s%s, the last on %s%s" % (
+        d["count"], "" if d["count"] == 1 else "s", who, d["since"],
+        " (when the record was committed; it has no date)" if d.get("since_from") == "git" else "",
+        d["last_change"], cite)
+
+
 SKIP_DIRS = {".git", "node_modules", "vendor", "dist", "build", ".venv", "venv", "__pycache__", "target"}
 
 
@@ -432,7 +496,8 @@ def why(records, path, root):
     hits.sort(key=lambda h: (0 if live(h[0]) else 1, rank.get(h[0]["status"], 2),
                              -int(h[0]["date"].replace("-", "") or 0)))
     return p, [{"id": r["id"], "title": r["title"], "status": r["status"], "date": r["date"], "path": r["path"],
-                "via": g, "superseded_by": sorted(set(succ.get(r["id"], []))), "current": live(r)} for r, g in hits]
+                "via": g, "superseded_by": sorted(set(succ.get(r["id"], []))), "current": live(r),
+                "drift": r.get("drift")} for r, g in hits]
 
 
 def mermaid(records):
@@ -479,6 +544,8 @@ def report(records, findings, note, query, dirs, root):
                     state = h["status"] + (", current" if h["current"] else "")
                 out.append("- **%s %s** (%s%s), via `%s`: %s" % (
                     h["id"], h["title"], state, ", " + h["date"] if h["date"] else "", h["via"], h["path"]))
+                if h.get("drift"):
+                    out.append("  - Changed since: %s" % drift_line(h["drift"]))
             if not cur:
                 out.append("\nNone of these is current: the decisions that governed it were superseded, "
                            "deprecated or never accepted.")
@@ -502,6 +569,13 @@ def report(records, findings, note, query, dirs, root):
                 out.append("- %s: %s" % (label, ", ".join(r[k])))
         for c in r["commits"]:
             out.append("- Commit %s %s: %s" % (c["sha"], c["date"], c["subject"]))
+        if r.get("drift"):
+            out.append("- Code changed since the decision: %s" % drift_line(r["drift"]))
+            if r["drift"].get("record_last_edited"):
+                out.append("- Record last edited: %s" % r["drift"]["record_last_edited"])
+            for c in r["drift"].get("commits", [])[:10]:
+                out.append("  - %s %s %s: %s%s" % (c["sha"], c["date"], c["author"], c["subject"],
+                                                    " (cites it)" if c["cites_record"] else ""))
         out.append("")
     counts = {}
     for r in records:
@@ -516,6 +590,28 @@ def report(records, findings, note, query, dirs, root):
     out += ["- %s %s" % (rid, msg) for _, rid, msg in probs] or ["None."]
     out.append("\n## Warnings (%d)\n" % len(warns))
     out += ["- %s %s" % (rid, msg) for _, rid, msg in warns] or ["None."]
+    drifted = sorted((r for r in records if r.get("drift") and r["drift"].get("count")),
+                     key=lambda r: (-r["drift"]["count"], r["id"]))
+    if not query and any(r.get("drift") for r in records):
+        out.append("\n## Code changed since each decision\n")
+        if not drifted:
+            out.append("No commit has changed the code a current decision governs since it was made.")
+        else:
+            out.append("Current decisions whose code has changed since they were made, most changed first. "
+                       "Each is a place to check that the code still does what the record says.\n")
+            out.append("| Record | Decided | Commits since | Not citing it | By | Last change | Record last edited |")
+            out.append("|---|---|---|---|---|---|---|")
+            for r in drifted[:15]:
+                d = r["drift"]
+                out.append("| %s %s | %s%s | %d | %d | %s | %s | %s |" % (
+                    r["id"], r["title"].replace("|", "/")[:50], d["since"], "*" if d["since_from"] == "git" else "",
+                    d["count"], d["not_citing_record"],
+                    ", ".join("%s (%d)" % (a["name"].replace("|", "/"), a["commits"]) for a in d["authors"][:3])
+                    + (" …" if len(d["authors"]) > 3 else ""), d["last_change"], d["record_last_edited"] or "-"))
+            if len(drifted) > 15:
+                out.append("\n…and %d more; `--json` lists them all." % (len(drifted) - 15))
+            if any(r["drift"]["since_from"] == "git" for r in drifted[:15]):
+                out.append("\n\\* The record has no date, so this counts from when it was first committed.")
     if not query:
         out.append("\n## Graph\n")
         out.append("| Record | Status | Date | Supersedes | Superseded by | Governs |")
@@ -536,7 +632,9 @@ def _main(argv=None):
     q = ap.add_mutually_exclusive_group()
     q.add_argument("--why", metavar="PATH", help="list the decisions that govern a file or folder")
     q.add_argument("--record", metavar="ID", help="show one record and its neighbours, e.g. ADR-0004")
-    ap.add_argument("--git", action="store_true", help="also read commit messages for record ids")
+    ap.add_argument("--git", action="store_true",
+                    help="also read the commits that mention each record, and those that changed each current "
+                         "decision's code since it was made")
     ap.add_argument("--git-limit", type=int, default=5000)
     ap.add_argument("--json", action="store_true", help="print the graph as JSON instead of Markdown")
     ap.add_argument("--mermaid", metavar="FILE", help="also write a Mermaid flowchart of the graph")
@@ -579,6 +677,8 @@ def _main(argv=None):
         claimed = [o["id"] for o in records if r["id"] in o["supersedes"]]
         r["successors"] = sorted(set(r["superseded_by"]) | set(claimed))
         r["successors_only_claimed_by_successor"] = sorted(set(claimed) - set(r["superseded_by"]))
+    if a.git and not any("no commits were read" in n for n in notes):
+        git_drift(root, records, a.git_limit)
     # Guides and READMEs that still cite a superseded decision may still teach it.
     by_id = {r["id"]: r for r in records}
     docs = other_docs(root, {r["path"] for r in records})

package/packs/dev-team/loops/modernize/LOOP.md

@@ -16,7 +16,7 @@ can accept what the recordings don't cover and approve every intended change.
 
 | # | Stage | Type | Skills | Gate |
 |---|---|---|---|---|
-| 1 | `survey` | generate | [`codebase-tour`](../../skills/codebase-tour/SKILL.md) | — |
+| 1 | `survey` | generate | [`codebase-tour`](../../skills/codebase-tour/SKILL.md), [`context-graph`](../../../core/skills/context-graph/SKILL.md) | — |
 | 2 | `plan` | generate | [`refactor-plan`](../../skills/refactor-plan/SKILL.md), [`migration-plan`](../../skills/migration-plan/SKILL.md) | — |
 | 3 | `capture` | generate | [`behaviour-equivalence`](../../skills/behaviour-equivalence/SKILL.md) | — |
 | 4 | `rebuild` | generate | [`feature-implement-loop`](../../skills/feature-implement-loop/SKILL.md) | — |
@@ -29,6 +29,15 @@ can accept what the recordings don't cover and approve every intended change.
    must end with the boundary it will be swapped at (an HTTP API, a function signature, a
    batch file, a queue) and every caller and side effect that crosses it, each cited to a
    file. A boundary nobody can name means the component isn't ready to be replaced.
+
+   Then run `context-graph` on the same component, with git history. It finds the recorded
+   decisions that govern it: why it was built this way, what was tried before, and the
+   constraints the rewrite must keep. It also finds where the code has changed since those
+   decisions were made, and who changed it. Carry every constraint a current decision sets
+   into `plan`. A behaviour the old code has that contradicts its decision is a question for
+   the owner before `capture`: record it as it is, and ask whether the rewrite should keep it.
+   Each person who changed the code since the decision is worth asking what the records don't
+   say.
 2. **Plan the work.**
    - Restructuring the code in place → `refactor-plan`.
    - Moving data, a schema or a platform → `migration-plan`.
@@ -122,3 +131,4 @@ The log holds verdicts only: never recordings, code or data.
 - ❌ **Rebuilding everything, then comparing once.** Each planned step merges on its own and is compared again.
 - ❌ **Calling the migration done at G10.** Equivalence on the recordings is evidence; the cutover is a person's decision, with a rollback.
 - ❌ **Skipping `survey` because the old code is "well known".** The callers and side effects nobody remembers are the ones that break.
+- ❌ **Rewriting without reading the decisions behind the old code.** A constraint someone recorded years ago, such as a retention period or an ordering guarantee, is easy to drop in a rewrite and expensive to rediscover in production.

package/packs/dev-team/loops/modernize/evals/evals.json

@@ -22,6 +22,18 @@
         "Says a new or wider normalisation rule is a return to capture, not a fix",
         "Counts the return under the cap of 3"
       ]
+    },
+    {
+      "id": "survey-reads-the-recorded-decisions",
+      "prompt": "Run the modernize loop. We're replacing services/billing (a Python 2 batch job) with a Go service. The repo has ADRs under docs/adr.",
+      "assertions": [
+        "Surveys the boundary and every caller and side effect that crosses it, each cited to a file, before planning",
+        "Reads the ADRs that govern services/billing and names the current one by id, status and date",
+        "Carries each constraint the current decision sets into the plan",
+        "Says where the code has changed since the decision was made, from the git history, and who changed it, or says git history wasn't available",
+        "Treats a behaviour that contradicts the recorded decision as a question for the owner before capture, not as something to fix silently in the rewrite",
+        "Does not invent decisions, ids, commits or people that are not in the repository"
+      ]
     }
   ]
 }

package/packs/dev-team/loops/modernize/loop.json

@@ -1,7 +1,7 @@
 {
   "$comment": "RFC-0057. A legacy component replaced without changing what it does. The old system's behaviour is recorded before anything is rebuilt, a script decides G10 from the recordings, and a person decides the cutover, because only they can accept the coverage and the listed changes.",
   "name": "modernize",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Replace or rewrite a legacy component without changing what it does: orient in the old code, plan the restructuring and the move, record the old system's behaviour before anything is rebuilt, rebuild in small steps, prove the new one gives the same results on the recordings, and cut over only when a person accepts the evidence. Use when the user is migrating, rewriting or porting a legacy service, batch job or module (COBOL to Java, Python 2 to 3, a monolith to a service, one framework to another), says \"run the modernize loop\", or asks how to replace old code without breaking what depends on it.",
   "entrypoint": "LOOP.md",
   "kind": "loop",
@@ -10,8 +10,8 @@
     {
       "id": "survey",
       "type": "generate",
-      "intent": "Find the boundary the component is replaced at, what crosses it, who calls it, and the traps in the old code, each cited to a file.",
-      "skills": ["codebase-tour"]
+      "intent": "Find the boundary the component is replaced at, what crosses it, who calls it, and the traps in the old code, each cited to a file; then the recorded decisions that govern it, and which of them the code has drifted from.",
+      "skills": ["codebase-tour", "context-graph"]
     },
     {
       "id": "plan",

package/packs/solution-architect/loops/design/LOOP.md

@@ -14,16 +14,19 @@ a script, and why the decision is recorded only *after* the panel agrees.
 
 | # | Stage | Type | Skills | Gate |
 |---|---|---|---|---|
-| 1 | `constrain` | generate | [`nfr-spec`](../../skills/nfr-spec/SKILL.md) | — |
+| 1 | `constrain` | generate | [`context-graph`](../../../core/skills/context-graph/SKILL.md), [`nfr-spec`](../../skills/nfr-spec/SKILL.md) | — |
 | 2 | `shape` | generate | [`design-doc`](../../skills/design-doc/SKILL.md), [`architecture-diagrams`](../../skills/architecture-diagrams/SKILL.md) | — |
 | 3 | `threat` | verify | [`threat-model`](../../skills/threat-model/SKILL.md) | — |
 | 4 | `ratify` | gate | [`council-review`](../../../core/skills/council-review/SKILL.md) | **G1** review |
-| 5 | `record` | generate | [`adr-generator`](../../skills/adr-generator/SKILL.md) | — |
+| 5 | `record` | generate | [`adr-generator`](../../skills/adr-generator/SKILL.md), [`context-graph`](../../../core/skills/context-graph/SKILL.md) | — |
 
 ## How to run this loop
 
-1. **Constrain before shaping.** `nfr-spec` first, always. A design produced before its
-   quality targets exist gets judged on taste, and taste does not survive a review panel.
+1. **Constrain before shaping.** First run `context-graph` where the design will land. List the
+   decisions already in force there, each by id, and any the code has drifted from. A new
+   design either keeps each one or says which it supersedes; when the repo has no records,
+   say so. Then run `nfr-spec`, always. A design produced before its quality targets exist
+   gets judged on taste, and taste does not survive a review panel.
 2. **Shape prose and picture together.** `design-doc` and `architecture-diagrams` are one
    artifact in two renderings. A diagram that disagrees with the doc is a defect in both.
 3. **Attack it before ratifying.** `threat-model` consumes the design directly. Running it
@@ -33,7 +36,10 @@ a script, and why the decision is recorded only *after* the panel agrees.
    `REVISE` returns to `shape`. `SPLIT` and `RECONSIDER` leave the loop.
 5. **Record last.** `adr-generator` writes the decision *after* it is a decision, with the
    rejected options and the reasoning that killed them. An ADR written before G1 is a proposal
-   wearing an ADR's clothes.
+   wearing an ADR's clothes. Then run `context-graph` again. Every record the new ADR
+   supersedes must now say "Superseded by" it, and the new ADR must name the code it governs.
+   A supersession recorded on one side only is the most common way a decision log starts to
+   lie.
 
 ## Verdicts
 
@@ -74,10 +80,13 @@ which end in `BLOCKED`.
 - **The ADR names what was rejected and why.** A decision record with one option is a description of what happened, not a decision.
 - **Dissent is recorded, not resolved away.** A panel that always reaches consensus is not seating real positions.
 - **The diagram and the doc say the same thing.** They are checked against each other before G1, not after someone builds from the wrong one.
+- **The design names the decisions already in force where it lands,** and which of them it keeps or supersedes.
+- **After `record`, the records agree with each other:** each record the new ADR supersedes says so too.
 
 ## Anti-patterns to avoid
 
 - ❌ **Writing the ADR before G1.** It pre-commits the panel to a decision it has not made, and every reviewer can feel it.
 - ❌ **Running `threat-model` after ratification.** The panel then ratified an unattacked design, which is the failure this ordering exists to prevent.
 - ❌ **Treating `PROCEED WITH CONDITIONS` as `PROCEED`.** The conditions must reach the ADR; dropping them is how a conditional approval silently becomes unconditional.
+- ❌ **Designing over a decision nobody read.** A new design that quietly contradicts a current ADR leaves two decisions in force on one system, and the next reader can't tell which one wins.
 - ❌ **Skipping `constrain` because the NFRs are "obvious".** Obvious targets are the ones nobody writes down and everybody remembers differently.

package/packs/solution-architect/loops/design/evals/evals.json

@@ -21,6 +21,18 @@
         "Carries the named condition into the ADR as part of the decision",
         "Proceeds to `record` rather than looping back to `shape`"
       ]
+    },
+    {
+      "id": "reads-existing-decisions-and-closes-the-supersession",
+      "prompt": "Run the design loop for moving order events from Kafka to SQS. The repo has ADRs under docs/adr, and ADR-0004 chose Kafka.",
+      "assertions": [
+        "Before setting targets, lists the decisions already in force for order events by id, including ADR-0004",
+        "States whether the new design keeps or supersedes each of those decisions",
+        "Runs nfr-spec and expresses targets as numbers, not adjectives",
+        "Writes the ADR only after G1, and the new ADR says it supersedes ADR-0004",
+        "After writing the ADR, checks that ADR-0004 is marked superseded by the new record, and gives the exact edit when it isn't",
+        "Does not invent records, ids or dates that are not in the repository"
+      ]
     }
   ]
 }

package/packs/solution-architect/loops/design/loop.json

@@ -1,7 +1,7 @@
 {
   "$comment": "RFC-0028. The loop with the worst reversibility profile: a design mistake surfaces months later in code nobody wants to unwind. That is why its gate is a panel, not a script.",
   "name": "design",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Take a ratified requirement to a recorded architectural decision — constraints, structure, diagrams, threats, then a panel that must agree before the decision is written down. Use when the user is designing a system, choosing an architecture, or asking how something should be built.",
   "entrypoint": "LOOP.md",
   "kind": "loop",
@@ -10,8 +10,8 @@
     {
       "id": "constrain",
       "type": "generate",
-      "intent": "Name the quality targets before the structure, so the design is judged against numbers rather than taste.",
-      "skills": ["nfr-spec"]
+      "intent": "Read the decisions already in force where the design will land, then name the quality targets before the structure, so the design is judged against numbers and the existing decisions rather than taste.",
+      "skills": ["context-graph", "nfr-spec"]
     },
     {
       "id": "shape",
@@ -40,8 +40,8 @@
     {
       "id": "record",
       "type": "generate",
-      "intent": "Write the decision down with its rejected alternatives, so the next team inherits the reasoning and not just the outcome.",
-      "skills": ["adr-generator"]
+      "intent": "Write the decision down with its rejected alternatives, so the next team inherits the reasoning and not just the outcome, then check the records still agree with each other.",
+      "skills": ["adr-generator", "context-graph"]
     }
   ]
 }