skilldrop-cli 1.0.0 → 1.1.0

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/dev-team/skills/dependency-upgrade-review/evals/files/4/Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.9-slim
+FROM python:3.9-slim@sha256:2d97f6910b16bd338d3060f261f53f144965f755599aab1acda1e13cf1731b1b
 
 WORKDIR /app
 COPY requirements.txt .

package/packs/dev-team/skills/rollout-plan/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "rollout-plan",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "Plan the progressive release of a code change behind a feature flag or canary — the exposure ladder (internal, beta cohort, 1%, 5%, 25%, 50%, 100%, or what the traffic supports), and for each step who is exposed, decision and guardrail metrics with a baseline and a threshold against a control cohort, the minimum traffic and time before the numbers mean anything, a promote / hold / roll back rule set in advance, who watches and what aborts automatically; then what turning the flag off does not undo, and who removes the flag by when. Use when the user asks for a rollout plan, canary plan, ramp schedule, progressive delivery or percentage rollout, \"how long should the canary run\", \"when do we go from 5% to 25%\", or how to turn on a flagged feature safely.",
   "entrypoint": "SKILL.md",
   "deps": { "npm": [], "pip": [] },

package/packs/dev-team/skills/rollout-plan/scripts/canary_math.py

@@ -165,8 +165,8 @@ def main():
         fail("--traffic must be a finite number greater than zero")
     if not 0 < args.alpha < 1 or not 0 < args.power < 1:
         fail("--alpha and --power must be between 0 and 1")
-    if args.max_hours <= 0:
-        fail("--max-hours must be greater than zero")
+    if not math.isfinite(args.max_hours) or args.max_hours <= 0:
+        fail("--max-hours must be a finite number greater than zero")
     control = None
     if args.control_pct is not None:
         control = parse_rate(args.control_pct.rstrip("%") + "%", "--control-pct")

package/packs/research/skills/hypothesis-comparison/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "hypothesis-comparison",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Compare rival explanations for an observation with analysis of competing hypotheses (ACH) — list the hypotheses and the evidence, build a consistency matrix (consistent / inconsistent / neutral), rank hypotheses by how little evidence contradicts them rather than how much supports them, name the diagnostic evidence and the linchpins, and say which next observation would tell the leaders apart. Use when the user asks \"why did X happen\", \"which explanation fits the evidence\", \"what's really causing this\", wants to stop arguing over a favourite theory, or says \"compare these hypotheses\", \"competing explanations\", \"ACH\".",
   "entrypoint": "SKILL.md",
   "deps": {

package/packs/research/skills/hypothesis-comparison/scripts/ach_matrix.py

@@ -34,6 +34,7 @@ Exit codes: 0 report written, 2 bad input.
 import argparse
 import csv
 import io
+import math
 import sys
 from pathlib import Path
 
@@ -71,28 +72,31 @@ def load(path):
             fail("the CSV needs at least two hypothesis columns; ACH compares rivals")
         rows = []
         for i, raw in enumerate(reader, start=1):
+            line = reader.line_num  # the file's line, which counts the blank lines csv skips
             if None in raw:
                 fail("row {}: more cells than the header has columns; put double quotes around any "
-                     "cell that contains a comma".format(i + 1))
+                     "cell that contains a comma".format(line))
             row = {(k or "").strip(): (v or "").strip() for k, v in raw.items()}
             lrow = {k.lower(): v for k, v in row.items()}
             ev = lrow.get("evidence", "")
             if not ev:
-                fail("row {}: the evidence cell is empty".format(i + 1))
+                fail("row {}: the evidence cell is empty".format(line))
             rid = lrow.get("id") or "E{}".format(i)
             w_raw = lrow.get("weight") or "1"
             try:
                 w = float(w_raw)
             except ValueError:
-                fail("row {} ({}): weight {!r} is not a number".format(i + 1, rid, w_raw))
+                fail("row {} ({}): weight {!r} is not a number".format(line, rid, w_raw))
+            if not math.isfinite(w):
+                fail("row {} ({}): weight {!r} is not a finite number".format(line, rid, w_raw))
             if w <= 0:
-                fail("row {} ({}): weight must be greater than 0".format(i + 1, rid))
+                fail("row {} ({}): weight must be greater than 0".format(line, rid))
             ratings = {}
             for h in hyps:
                 r = row.get(h, "").upper()
                 if r not in RATINGS:
                     fail("row {} ({}), column {!r}: rating {!r} is not one of CC, C, N, NA, I, II".format(
-                        i + 1, rid, h, row.get(h, "")))
+                        line, rid, h, row.get(h, "")))
                 ratings[h] = r
             rows.append({"id": rid, "evidence": ev, "weight": w, "ratings": ratings})
     if not rows:

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"]
     }
   ]
 }

package/packs/sre-oncall/skills/delivery-metrics-report/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "delivery-metrics-report",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Produce a delivery metrics report for one service from deployment, incident and pull-request exports — the DORA metrics (deployment frequency, change lead time, change fail rate, failed deployment recovery time) plus flow metrics (WIP, cycle time p50/p85, throughput), computed by a script with per-week trends and explicit data gaps, then interpreted for what changed and why. Use when the user wants DORA metrics, says \"how are we doing on the four keys\", \"what's our change failure rate\", \"compute lead time and deploy frequency from this CSV\", or \"build our delivery metrics report\".",
   "entrypoint": "SKILL.md",
   "deps": {

package/packs/sre-oncall/skills/delivery-metrics-report/scripts/delivery_metrics.py

@@ -25,6 +25,7 @@ from __future__ import annotations
 
 import argparse
 import csv
+import io
 import json
 import math
 import re
@@ -96,7 +97,12 @@ def parse_bool(raw, where: str):
 def read_csv(path: Path, required: list, label: str) -> list:
     if not path.exists():
         raise InputError("%s file not found: %s" % (label, path))
-    with path.open(newline="", encoding="utf-8-sig") as f:
+    try:
+        text = path.read_text(encoding="utf-8-sig")
+    except UnicodeDecodeError:
+        raise InputError("%s file %s is not UTF-8 text; save it as UTF-8 (in Excel: CSV UTF-8) and retry"
+                         % (label, path))
+    with io.StringIO(text, newline="") as f:
         reader = csv.DictReader(f)
         if not reader.fieldnames:
             raise InputError("%s file %s is empty or has no header row" % (label, path))

package/packs/trackers/skills/team-status-report/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "team-status-report",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Write a weekly team status report from tracker data (Jira, Linear or GitHub Projects, via CSV, JSON or an MCP tool) — shipped, in progress, blocked with the blocker and owner, slipped against plan, risks and asks — with every number computed from the data by a stdlib script, never estimated, and a RAG status that states the rule that set it. Use when the user wants a weekly status update, sprint report or stakeholder update from the tracker, or says \"write this week's status report\", \"are we on track?\".",
   "entrypoint": "SKILL.md",
   "deps": {

package/packs/trackers/skills/team-status-report/scripts/status_counts.py

@@ -305,8 +305,11 @@ def main(argv=None) -> int:
     if args.plan_file:
         if not args.plan_file.exists():
             die("--plan-file {} does not exist".format(args.plan_file))
-        keys = [ln.strip() for ln in args.plan_file.read_text(encoding="utf-8").splitlines()
-                if ln.strip() and not ln.startswith("#")]
+        try:
+            plan_text = args.plan_file.read_text(encoding="utf-8-sig")
+        except UnicodeDecodeError:
+            die("--plan-file {} is not UTF-8 text; save it as UTF-8 and retry".format(args.plan_file))
+        keys = [ln.strip() for ln in plan_text.splitlines() if ln.strip() and not ln.startswith("#")]
         by_key = {it["key"]: it for it in items}
         missing = [k for k in keys if k not in by_key]
         if missing: