@1aboveio/skills 1.0.10 → 1.0.11

package/skills/risk-compliance/tld-detection/scripts/render_charts.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""Render a saved group profile as standalone, accessible offline HTML."""
+import argparse
+import html
+import json
+import math
+from datetime import timedelta
+
+from tld_common import _period, write_text
+
+
+def esc(value):
+    return html.escape(str(value), quote=True)
+
+
+def display(value, percent=False):
+    if value is None:
+        return 'N/A'
+    return f'{value * 100:.2f}%' if percent else str(value)
+
+
+def validate_profile(profile):
+    """Check the dimensions and scalar values consumed by the renderer."""
+    def count(value, field):
+        if type(value) is not int or value < 0:
+            raise ValueError(f'{field} must be a nonnegative integer')
+
+    def rate(value, field):
+        if value is not None and (type(value) not in (int, float) or not 0 <= value <= 1 or not math.isfinite(value)):
+            raise ValueError(f'{field} must be null or a finite rate between 0 and 1')
+
+    def counts(values, length, field):
+        if not isinstance(values, list) or len(values) != length:
+            raise ValueError(f'{field} must contain {length} counts')
+        for value in values:
+            count(value, field)
+
+    def matches(value, expected, field):
+        if expected is None:
+            if value is not None:
+                raise ValueError(f'{field} must be null')
+        elif value is None or not math.isclose(value, expected, rel_tol=1e-9, abs_tol=1e-12):
+            raise ValueError(f'{field} is inconsistent with its counts')
+
+    def status(value, field, denominator):
+        if not isinstance(value, dict):
+            raise ValueError(f'{field} must be an object')
+        for key in ('numerator', 'denominator', 'unknown'):
+            count(value.get(key), f'{field}.{key}')
+        for key in ('rate', 'coverage'):
+            rate(value.get(key), f'{field}.{key}')
+            if key not in value:
+                raise ValueError(f'{field}.{key} is required')
+        n, yes, unknown = value['denominator'], value['numerator'], value['unknown']
+        if n != denominator or yes + unknown > n:
+            raise ValueError(f'{field} counts are inconsistent')
+        matches(value['rate'], yes / n if n and not unknown else None, f'{field}.rate')
+        matches(value['coverage'], (n - unknown) / n if n else None, f'{field}.coverage')
+
+    if not isinstance(profile, dict) or type(profile.get('schema_version')) is not int or profile['schema_version'] != 1:
+        raise ValueError('unsupported profile schema')
+    _, start, end, _ = _period(profile.get('period'))
+    groups = profile.get('groups')
+    if not isinstance(groups, list):
+        raise ValueError('groups must be an array')
+    for group in groups:
+        if not isinstance(group, dict) or not isinstance(group.get('id'), str) or not isinstance(group.get('scope'), dict):
+            raise ValueError('group requires an id and scope')
+        tiers = group.get('tiers')
+        tiers = tiers.get('tiers') if isinstance(tiers, dict) else None
+        if not isinstance(tiers, list) or not tiers or any(not isinstance(t, dict) or not isinstance(t.get('label'), str) for t in tiers):
+            raise ValueError('tiers must contain labelled tiers')
+        for name in ('group', 'out_group'):
+            pop = group.get(name)
+            if not isinstance(pop, dict) or not isinstance(pop.get('daily'), list):
+                raise ValueError(f'{name} requires daily records')
+            daily = pop['daily']
+            if len(daily) != (end - start).days + 1:
+                raise ValueError(f'{name} daily records must cover the period')
+            counts(pop.get('hours'), 24, f'{name}.hours')
+            total = pop.get('total')
+            if not isinstance(total, dict):
+                raise ValueError(f'{name}.total must be an object')
+            count(total.get('count'), f'{name}.total.count')
+            counts(total.get('tier_counts'), len(tiers), f'{name}.total.tier_counts')
+            for key in ('success', 'fraud'):
+                status(total.get(key), f'{name}.total.{key}', total['count'])
+            for i, day in enumerate(daily):
+                if not isinstance(day, dict) or day.get('date') != (start + timedelta(days=i)).isoformat():
+                    raise ValueError(f'{name} daily dates must align with the period')
+                count(day.get('count'), f'{name}.daily.count')
+                if 'share' not in day:
+                    raise ValueError(f'{name}.daily.share is required')
+                rate(day['share'], f'{name}.daily.share')
+                matches(day['share'], day['count'] / total['count'] if total['count'] else None, f'{name}.daily.share')
+                counts(day.get('hours'), 24, f'{name}.daily.hours')
+                counts(day.get('tier_counts'), len(tiers), f'{name}.daily.tier_counts')
+                if sum(day['hours']) != day['count'] or sum(day['tier_counts']) != day['count']:
+                    raise ValueError(f'{name} daily counts do not reconcile')
+                for key in ('success', 'fraud'):
+                    status(day.get(key), f'{name}.daily.{key}', day['count'])
+            if (sum(day['count'] for day in daily) != total['count']
+                    or any(sum(day['hours'][i] for day in daily) != pop['hours'][i] for i in range(24))
+                    or any(sum(day['tier_counts'][i] for day in daily) != total['tier_counts'][i] for i in range(len(tiers)))):
+                raise ValueError(f'{name} totals do not reconcile')
+            for key in ('success', 'fraud'):
+                for field in ('numerator', 'unknown'):
+                    if sum(day[key][field] for day in daily) != total[key][field]:
+                        raise ValueError(f'{name}.{key}.{field} does not reconcile')
+
+
+def chart(title, labels, series, percent=False, tier_count=None, context=None):
+    """Draw supplied values on one shared scale; missing values break lines."""
+    max_value = 100 if percent else max([1] + [v for _, values in series for v in values if v is not None])
+    width, height, left, top, bottom = max(800, 100 * len(labels) + 80), 260, 60, 20, 200
+    def x(i):
+        return left + i * (width - left - 20) / max(1, len(labels) - 1)
+    def y(v):
+        return bottom - (v * (100 if percent else 1)) / max_value * (bottom - top)
+    def style(index):
+        # The tier controls hue; the population controls line and point shape.
+        n = tier_count or len(series)
+        color = f'hsl({index % n * 360 / n:.8f}, 80%, 35%)'
+        return color, '6 4' if tier_count and index // n else 'none', bool(tier_count and index // n)
+
+    def marker(color, square, x, y, title=''):
+        if square:
+            return f'<rect x="{x - 3:.2f}" y="{y - 3:.2f}" width="6" height="6" fill="{color}">{title}</rect>'
+        return f'<circle cx="{x:.2f}" cy="{y:.2f}" r="3" fill="{color}">{title}</circle>'
+
+    def legend(index, name):
+        color, dash, square = style(index)
+        return (f'<li><svg class="legend-key" viewBox="0 0 32 12" aria-hidden="true">'
+                f'<line x1="0" y1="6" x2="32" y2="6" stroke="{color}" stroke-dasharray="{dash}"/>'
+                + marker(color, square, 16, 6) + f'</svg>{esc(name)}</li>')
+
+    out = [f'<section><h3>{esc(title)}</h3>', f'<p>{esc(context)}</p>' if context else '', '<ul class="legend" aria-label="Series legend">',
+           *[legend(i, name) for i, (name, _) in enumerate(series)],
+           '</ul>', f'<div class="scroll" role="region" aria-label="{esc(title)} chart" tabindex="0">',
+           f'<svg style="min-width:{width}px" viewBox="0 0 {width} {height}" role="img" aria-label="{esc(title)}"><title>{esc(title)}</title>',
+           f'<line x1="{left}" y1="{bottom}" x2="{width-20}" y2="{bottom}" stroke="black"/>',
+           f'<line x1="{left}" y1="{top}" x2="{left}" y2="{bottom}" stroke="black"/>',
+           f'<text x="2" y="{top+5}">{esc(display(max_value / 100 if percent else max_value, percent))}</text><text x="35" y="{bottom}">0</text>']
+    for i, label in enumerate(labels):
+        out.append(f'<text x="{x(i):.2f}" y="220" text-anchor="middle" font-size="9">{esc(label)}</text>')
+    for index, (name, values) in enumerate(series):
+        color, dash, square = style(index)
+        segment = []
+        def flush():
+            if len(segment) > 1:
+                points = ' '.join(segment)
+                out.append(f'<polyline fill="none" stroke="{color}" stroke-dasharray="{dash}" points="{points}"/>')
+            segment.clear()
+        for i, value in enumerate(values):
+            if value is None:
+                flush()
+                continue
+            px, py = x(i), y(value)
+            segment.append(f'{px:.2f},{py:.2f}')
+            out.append(marker(color, square, px, py, f'<title>{esc(name)}: {esc(labels[i])}: {esc(display(value, percent))}</title>'))
+        flush()
+    out.append('</svg></div><div class="scroll" role="region" aria-label="' + esc(title) + ' data table" tabindex="0"><table><caption>' + esc(title) + '</caption><thead><tr><th scope="col">Period</th>' + ''.join(f'<th scope="col">{esc(name)}</th>' for name, _ in series) + '</tr></thead><tbody>')
+    for i, label in enumerate(labels):
+        out.append(f'<tr><th scope="row">{esc(label)}</th>' + ''.join(f'<td>{esc(display(values[i], percent))}</td>' for _, values in series) + '</tr>')
+    out.append('</tbody></table></div></section>')
+    return ''.join(out)
+
+
+def render(profile):
+    validate_profile(profile)
+    period = profile['period']
+    out = ['<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1"><title>Group profiles</title>',
+           '<style>body{font:16px sans-serif;margin:1em}svg{display:block;width:100%;height:auto}.scroll{max-width:100%;overflow-x:auto}.scroll:focus{outline:2px solid #005a9c;outline-offset:2px}table{border-collapse:collapse;margin:1em 0}th,td{border:1px solid #888;padding:.3em;text-align:left;white-space:nowrap}section{margin:2em 0}.legend{display:flex;flex-wrap:wrap;gap:.5em 1em;list-style:none;padding:0}.legend-key{display:inline-block;width:2em;height:.75em;margin-right:.4em;vertical-align:middle}</style></head><body>',
+           f'<h1>Group profiles</h1><p>{esc(period["start"])} to {esc(period["end"])} inclusive; timezone {esc(period["timezone"])}</p>']
+    for group in profile['groups']:
+        out.append(f'<article><h2>Group {esc(group["id"])}</h2><p>Scope: {esc(json.dumps(group["scope"], ensure_ascii=False, sort_keys=True))}</p>')
+        populations = [('Group', group['group']), ('Out-group', group['out_group'])]
+        days = [d['date'] for d in group['group']['daily']]
+        tiers = group['tiers']['tiers']
+        series = [(f'{name}: {tier["label"]}', [day['tier_counts'][i] for day in pop['daily']]) for name, pop in populations for i, tier in enumerate(tiers)]
+        out.append(chart('Daily amount-tier counts', days, series, tier_count=len(tiers)))
+        for key, title, percent in [('count', 'Daily transaction counts', False), ('share', 'Daily shares', True)]:
+            context = (f"Daily share = daily count / that population's own whole-period count. "
+                       f"Group total: {group['group']['total']['count']}; out-group total: {group['out_group']['total']['count']}."
+                       if key == 'share' else None)
+            out.append(chart(title, days, [(name, [d[key] for d in pop['daily']]) for name, pop in populations], percent, context=context))
+        for key, title in [('success', 'Daily success rates'), ('fraud', 'Daily suspected-fraud rates')]:
+            context = ('Daily rate = status numerator / the same population’s daily transaction count; '
+                       'N/A if the count is zero or any status is unknown. Denominators are in the status detail table.')
+            out.append(chart(title, days, [(name, [d[key]['rate'] for d in pop['daily']]) for name, pop in populations], True, context=context))
+            out.append(chart(title + ' status coverage', days, [(name, [d[key]['coverage'] for d in pop['daily']]) for name, pop in populations], True, context='Coverage = known statuses / the same population’s daily transaction count; N/A for an empty population.'))
+            out.append('<div class="scroll" role="region" aria-label="' + esc(title) + ' status detail" tabindex="0"><table><caption>' + esc(title) + ' status detail</caption><thead><tr><th scope="col">Date</th><th scope="col">Population</th><th scope="col">Numerator</th><th scope="col">Denominator</th><th scope="col">Unknown</th></tr></thead><tbody>')
+            for name, pop in populations:
+                for day in pop['daily']:
+                    r = day[key]
+                    out.append(f'<tr><th scope="row">{esc(day["date"])}</th><td>{esc(name)}</td><td>{esc(r["numerator"])}</td><td>{esc(r["denominator"])}</td><td>{esc(r["unknown"])}</td></tr>')
+            out.append('</tbody></table></div>')
+        hours = [f'{i:02d}' for i in range(24)]
+        out.append(chart('24-hour transaction counts', hours, [(name, pop['hours']) for name, pop in populations]))
+        out.append('<div class="scroll" role="region" aria-label="Date-by-hour counts" tabindex="0"><table><caption>Date-by-hour counts</caption><thead><tr><th scope="col">Date</th><th scope="col">Population</th>' + ''.join(f'<th scope="col">{h}</th>' for h in hours) + '</tr></thead><tbody>')
+        for name, pop in populations:
+            for day in pop['daily']:
+                out.append(f'<tr><th scope="row">{esc(day["date"])}</th><td>{esc(name)}</td>' + ''.join(f'<td>{esc(n)}</td>' for n in day['hours']) + '</tr>')
+        out.append('</tbody></table></div></article>')
+    return ''.join(out) + '</body></html>'
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('profile'); parser.add_argument('output'); parser.add_argument('--overwrite', action='store_true')
+    args = parser.parse_args()
+    with open(args.profile, encoding='utf-8') as f:
+        page = render(json.load(f))
+    write_text(args.output, page, overwrite=args.overwrite)
+
+
+if __name__ == '__main__':
+    main()

package/skills/risk-compliance/tld-detection/scripts/tld_common.py

@@ -0,0 +1,243 @@
+"""Validated transaction and membership boundary shared by TLD command-line tools."""
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import tempfile
+from datetime import date, datetime, timezone
+from decimal import Decimal, InvalidOperation
+from pathlib import Path
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+VIEWS = ("usd", "bin_country")
+REQUIRED = ("transaction_id", "transaction_time", "currency", "amount", "mcc",
+            "billing_descriptor", "mid", "card_scheme", "card_bin", "card_issuer",
+            "card_bin_country")
+
+
+def _string(value, field):
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{field} must be a nonempty string")
+    return value.strip()
+
+
+def decimal_string(value, field="amount"):
+    if not isinstance(value, str):
+        raise ValueError(f"{field} must be a decimal string")
+    try:
+        amount = Decimal(value)
+    except InvalidOperation as exc:
+        raise ValueError(f"{field} must be a finite nonnegative decimal") from exc
+    if not amount.is_finite() or amount < 0:
+        raise ValueError(f"{field} must be a finite nonnegative decimal")
+    if not amount:
+        return "0"
+    text = format(amount, "f")
+    return text.rstrip("0").rstrip(".") if "." in text else text
+
+
+def _currency(value, field="currency"):
+    value = _string(value, field).upper()
+    if len(value) != 3 or not value.isascii() or not value.isalpha():
+        raise ValueError(f"{field} must be a three-letter currency code")
+    return value
+
+
+def normalize_descriptor(value):
+    return " ".join(_string(value, "billing_descriptor").split()).casefold()
+
+
+def _period(value):
+    if not isinstance(value, dict) or set(value) != {"start", "end", "timezone"}:
+        raise ValueError("period requires start, end and timezone")
+    try:
+        start = date.fromisoformat(value["start"])
+        end = date.fromisoformat(value["end"])
+        zone = ZoneInfo(value["timezone"])
+    except (ValueError, TypeError, KeyError, ZoneInfoNotFoundError) as exc:
+        raise ValueError("period requires ISO dates and an IANA timezone") from exc
+    if start.isoformat() != value["start"] or end.isoformat() != value["end"] or end < start:
+        raise ValueError("period dates must be ordered YYYY-MM-DD dates")
+    return dict(value), start, end, zone
+
+
+def _timestamp(value):
+    value = _string(value, "transaction_time")
+    try:
+        dt = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ValueError("transaction_time must be an ISO timestamp") from exc
+    if dt.tzinfo is None or dt.utcoffset() is None:
+        raise ValueError("transaction_time must include an explicit UTC offset")
+    return dt.astimezone(timezone.utc)
+
+
+def _transaction(raw):
+    if not isinstance(raw, dict):
+        raise ValueError("transaction must be an object")
+    for field in REQUIRED:
+        if field not in raw:
+            raise ValueError(f"missing required field: {field}")
+    row = {field: _string(raw[field], field) for field in REQUIRED
+           if field not in ("card_bin_country", "amount", "currency", "transaction_time")}
+    row["billing_descriptor"] = normalize_descriptor(row["billing_descriptor"])
+    row["transaction_time"] = _timestamp(raw["transaction_time"]).isoformat()
+    row["currency"] = _currency(raw["currency"])
+    row["amount"] = decimal_string(raw["amount"])
+    country = raw["card_bin_country"]
+    row["card_bin_country"] = _string(country, "card_bin_country").upper() if country is not None else None
+    for status in ("authorized", "suspected_fraud"):
+        value = raw.get(status)
+        if value is not None and type(value) is not bool:
+            raise ValueError(f"{status} must be true, false or null")
+        row[status] = value
+    views = raw.get("views")
+    if not isinstance(views, dict) or set(views) != set(VIEWS):
+        raise ValueError("views must contain exactly usd and bin_country")
+    row["views"] = {}
+    for name in VIEWS:
+        view = views[name]
+        if not isinstance(view, dict):
+            raise ValueError(f"{name} view must be an amount or explicit exclusion")
+        if set(view) == {"excluded_reason"}:
+            row["views"][name] = {"excluded_reason": _string(view["excluded_reason"], "excluded_reason")}
+            continue
+        if set(view) != {"currency", "amount"}:
+            raise ValueError(f"{name} view requires currency and amount, or excluded_reason")
+        currency = _currency(view["currency"])
+        if name == "usd" and currency != "USD":
+            raise ValueError("usd view must target USD")
+        if name == "bin_country" and country is None:
+            raise ValueError("missing BIN country requires an excluded bin_country view")
+        row["views"][name] = {"currency": currency, "amount": decimal_string(view["amount"])}
+    return row
+
+
+def dataset_fingerprint(data):
+    bound = {"schema_version": 1, "period": data["period"],
+             "transactions": sorted(data["transactions"], key=lambda row: row["transaction_id"])}
+    encoded = json.dumps(bound, sort_keys=True, ensure_ascii=False, separators=(",", ":"), allow_nan=False)
+    return hashlib.sha256(encoded.encode("utf-8")).hexdigest()
+
+
+def validate_dataset(payload):
+    if not isinstance(payload, dict) or type(payload.get("schema_version")) is not int or payload["schema_version"] != 1:
+        raise ValueError("unsupported dataset schema_version")
+    period, start, end, zone = _period(payload.get("period"))
+    source = payload.get("transactions")
+    if not isinstance(source, list):
+        raise ValueError("transactions must be an array")
+    by_id = {}
+    duplicates = 0
+    for raw in source:
+        row = _transaction(raw)
+        key = row["transaction_id"]
+        if key in by_id:
+            if by_id[key] != row:
+                raise ValueError(f"conflicting records for transaction ID {key}")
+            duplicates += 1
+        else:
+            by_id[key] = row
+    selected = [row for row in by_id.values()
+                if start <= _timestamp(row["transaction_time"]).astimezone(zone).date() <= end]
+    selected.sort(key=lambda row: row["transaction_id"])
+    exclusions = {view: {} for view in VIEWS}
+    for row in selected:
+        for view in VIEWS:
+            reason = row["views"][view].get("excluded_reason")
+            if reason:
+                exclusions[view][reason] = exclusions[view].get(reason, 0) + 1
+    data = {"schema_version": 1, "period": period, "transactions": selected,
+            "census": {"source_rows": len(source), "duplicate_rows": duplicates,
+                       "out_of_period": len(by_id) - len(selected), "transactions": len(selected),
+                       "view_exclusions": exclusions}}
+    data["dataset_sha256"] = dataset_fingerprint(data)
+    return data
+
+
+def load_dataset(path):
+    return validate_dataset(json.loads(Path(path).read_text(encoding="utf-8")))
+
+
+def view_rows(data):
+    zone = ZoneInfo(data["period"]["timezone"])
+    output = []
+    for tx in data["transactions"]:
+        local = _timestamp(tx["transaction_time"]).astimezone(zone)
+        for name in VIEWS:
+            converted = tx["views"][name]
+            if "excluded_reason" in converted:
+                continue
+            row = {key: value for key, value in tx.items() if key != "views"}
+            row.update({"view": name, "currency": converted["currency"], "amount": converted["amount"],
+                        "charge_currency": tx["currency"], "charge_amount": tx["amount"],
+                        "descriptor": tx["billing_descriptor"], "date": local.date().isoformat(), "hour": local.hour})
+            output.append(row)
+    return output
+
+
+def scope_of(row):
+    return {key: row[key] for key in ("mid", "descriptor", "view", "currency")}
+
+
+def validate_groups(data, payload):
+    if not isinstance(payload, dict) or type(payload.get("schema_version")) is not int or payload["schema_version"] != 1:
+        raise ValueError("unsupported group schema_version")
+    if payload.get("period") != data["period"] or payload.get("dataset_sha256") != dataset_fingerprint(data):
+        raise ValueError("group manifest period or dataset digest is stale or mismatched")
+    groups = payload.get("groups")
+    if not isinstance(groups, list):
+        raise ValueError("groups must be an array")
+    eligible = {}
+    for row in view_rows(data):
+        scope = scope_of(row)
+        key = tuple(scope[k] for k in ("mid", "descriptor", "view", "currency"))
+        eligible.setdefault(key, set()).add(row["transaction_id"])
+    seen = set()
+    for group in groups:
+        if not isinstance(group, dict):
+            raise ValueError("group must be an object")
+        gid = _string(group.get("id"), "group id")
+        if gid in seen:
+            raise ValueError(f"duplicate group ID {gid}")
+        seen.add(gid)
+        if group.get("pattern") not in ("concentration", "escalating", "pricing"):
+            raise ValueError("unsupported group pattern")
+        scope = group.get("scope")
+        if not isinstance(scope, dict) or set(scope) != {"mid", "descriptor", "view", "currency"}:
+            raise ValueError("group scope requires mid, descriptor, view and currency")
+        fields = ("mid", "descriptor", "view", "currency")
+        key = tuple(_string(scope[k], k) for k in fields)
+        if any(scope[field] != value for field, value in zip(fields, key)):
+            raise ValueError("group scope must use canonical values without surrounding whitespace")
+        members = group.get("member_ids")
+        if not isinstance(members, list) or not members or any(not isinstance(m, str) or not m for m in members):
+            raise ValueError("group member_ids must be a nonempty list of IDs")
+        if len(set(members)) != len(members):
+            raise ValueError("duplicate member IDs in group")
+        if not set(members) <= eligible.get(key, set()):
+            raise ValueError(f"group {gid} has unknown, out-of-scope or excluded member IDs")
+    return groups
+
+
+def write_json(path, payload, overwrite=False):
+    text = json.dumps(payload, ensure_ascii=False, indent=2, allow_nan=False) + "\n"
+    write_text(path, text, overwrite)
+
+
+def write_text(path, text, overwrite=False):
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = None
+    try:
+        with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8", dir=path.parent, delete=False) as handle:
+            temporary = Path(handle.name)
+            handle.write(text)
+        if overwrite:
+            os.replace(temporary, path)
+        else:
+            os.link(temporary, path)
+    finally:
+        if temporary is not None:
+            temporary.unlink(missing_ok=True)

package/skills/engineering/contributing/SKILL.md

@@ -1,70 +0,0 @@
----
-name: contributing
-description: "The conventions a repo's CONTRIBUTING.md holds, starting with tracker routing: which tracker an issue belongs in (GitHub for engineering, Linear for product), duplicate search, and linking back to the source requirement. Use before creating any issue, spec, epic, ticket or sub-issue on GitHub or Linear, including inside /to-spec, /to-tickets and /triage, and whenever work that started from a Linear issue turns into engineering work. Also writes the rules as the Issue tracking section of the repo's CONTRIBUTING.md. NOT for delivering a PR (github-flow) or splitting work into slices (to-tickets)."
-release-version: 0.44.1
----
-**Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
-# Contributing
-
-Rules every engineering skill follows, whatever skill or harness is running, kept as sections of the
-repo's `CONTRIBUTING.md`. Each rule is the authority; another skill's "publish to the configured
-tracker" means the tracker these rules pick.
-
-## First use in a repo
-
-Scripts live under **this skill's directory**: set `SKILL_DIR` to the directory you read this file
-from, never your CWD. On the first trigger in a repo, write the `## Issue tracking` section into its
-`CONTRIBUTING.md`, creating the file when it is missing:
-
-```sh
-node "$SKILL_DIR/scripts/persist-conventions.mjs" --repo-root <repo-root> --if-missing --write \
-  [--linear-project "<Linear project>"]... [--github-repo <owner/name>]
-```
-
-- **Pass every Linear project whose resources link to this repo.** Example: the `Checkout Risk`
-  project lists `https://github.com/acme/widgets`, so pass `--linear-project "Checkout Risk"`.
-- **Pass `--github-repo` only when `origin` is not the GitHub repo.** Example: exit 2 with
-  `no GitHub origin remote` means pass it.
-- **`--if-missing` never touches an existing section.** To rewrite it, run without `--if-missing`.
-- **`AGENTS.md` indexes `CONTRIBUTING.md`.** The script adds a `## Contributing` pointer unless
-  `AGENTS.md` already names `CONTRIBUTING.md`, creates a missing `AGENTS.md`, and creates a missing
-  `CLAUDE.md` as a symlink to `AGENTS.md`, even when the section already exists.
-- Report each file's result line; commit with the change you are making, or leave it for the user
-  when you make no other change.
-
-## Tracker routing
-
-| Work item | Tracker |
-|---|---|
-| Product goals, business requirements, priorities, milestones | Linear |
-| Consulting engagements, reports, research deliverables | Linear |
-| Engineering specs and implementation epics | GitHub |
-| Implementation tickets, technical investigations, refactors, engineering bugs | GitHub |
-| Delivery progress for stakeholders | A summary in Linear that links to GitHub |
-
-Before you create an issue:
-
-1. **Classify the work; the tracker follows the work, not where the request came from.** Example:
-   `/to-spec` run on a conversation about DEV-123 publishes a GitHub issue.
-2. **Resolve the GitHub repo in this order: the repo's `CONTRIBUTING.md` Issue tracking section, the
-   GitHub links in the source Linear project's resources, then ask the user. Never fall back to
-   Linear.** Example: a project linking two repos gets the repo the work changes; a project linking
-   none gets a question, not a Linear ticket.
-3. **Search before you create.** Example: `gh issue list --repo <owner/name> --state all --search
-   "<keywords>"`; reuse or comment on a match.
-4. **A Linear issue is a source reference, never a parent for implementation tickets.** Example: put
-   `Source: <Linear URL>` in the GitHub epic body and file the tickets as GitHub sub-issues of the
-   epic.
-5. **Link back once per epic.** Example: add the GitHub epic URL to the Linear requirement as a
-   link; never copy the GitHub tickets into Linear.
-6. **Report progress in Linear as a summary; acceptance stays with the requester.** Example: when the
-   last sub-issue closes, comment `Engineering complete: <epic URL>` on the Linear requirement and
-   leave its status alone.
-7. **An explicit destination from the user wins.** Example: "file this in Linear" files it in Linear.
-
-## Common wrong answers
-
-- "The request came from Linear, so the tickets go in Linear." The work type decides, rule 1.
-- "No tracker is configured, so use the one the conversation used." Resolve the repo, rule 2.
-- "Mirror the epic into Linear so stakeholders see it." Post a summary with a link, rule 5.
-- "All sub-issues closed, so the Linear requirement is done." Engineering complete is not accepted, rule 6.

package/skills/risk-compliance/fraud-analysis/SKILL.md

@@ -1,114 +0,0 @@
----
-name: fraud-analysis
-description: >
-  Analyze tabular payment, transfer, collection, payout, account, or fraud-case
-  data (CSV, XLSX, TXT) to find interpretable features and operable risk rules.
-  Supports third-party fraud (including stolen credentials and account takeover),
-  first-party fraud or deliberate account abuse, and authorized payment scams
-  (including APP scams), across card payments, collections, bank transfers, and
-  payouts. Produces temporal holdout metrics, domain-appropriate actions, strategy
-  impact, and a business report. Use for fraud, scam, mule, account-takeover,
-  chargeback, dispute, transfer, collection, or payout risk analysis even when the
-  user does not name this skill.
-release-version: 0.44.1
----
-**Updates:** Once/session run `node <skill-base-dir>/release-check.mjs`.
-# Fraud Analysis
-
-Analyze fraud through composable dimensions rather than treating every case as
-card fraud:
-
-- **Archetype** — the genuine customer's relationship to the fraud
-- **Mechanism** — how compromise, deception, or abuse occurred
-- **Context** — the product or money-movement surface where a rule fires
-
-Run this **10-step** loop:
-
-0. Pre-flight → 1. Profile → 2. Label → 3. Time split → 4. Engineer features →
-5. Shortlist → 6. Score rules → 7. Map actions + packages → 8. Write report →
-9. Review
-
-**Produce:** operable rules and portfolio impact in a business report.  
-**Do not produce:** a black-box model as the main answer.
-
-> Paths under `references/` are relative to this skill directory. Step detail:
-> [references/workflow.md](references/workflow.md).
-
-## Required references
-
-| File | When |
-|---|---|
-| [references/workflow.md](references/workflow.md) | Every step — full procedure |
-| [references/taxonomy.md](references/taxonomy.md) | Step 1; select archetype, mechanism, and context |
-| [references/feature-engineering.md](references/feature-engineering.md) | Step 4; shared decision-time rules |
-| [references/report-template.md](references/report-template.md) | Step 8; common report contract and overlay selection |
-| [references/terminology.md](references/terminology.md) | Step 8; fixed terms and language proofread |
-| [references/review-checklist.md](references/review-checklist.md) | Step 9; common and selected-profile checks |
-
-After Step 1, read only the selected profile references:
-
-| Dimension | References |
-|---|---|
-| Archetype | `references/archetypes/<archetype>.md` |
-| Mechanism | `references/mechanisms/<mechanism>.md` when present |
-| Context | `references/contexts/<context>.md` for every selected context |
-
-Current packs: archetypes `third-party-fraud`, `first-party-fraud`,
-`authorized-payment-scam`; mechanism `account-takeover`; contexts
-`card-payment`, `payment-collection`, `bank-transfer`, `payout`.
-
-## Progress
-
-Track a task plan. One item is `in_progress` at a time.
-
-1. Pass pre-flight
-2. Select analysis profile
-3. Formalize label
-4. Freeze time split
-5. Engineer candidate features
-6. Select shortlist
-7. Score candidate rules
-8. Map actions and packages
-9. Write business report and proofread language
-10. Independent review
-
-Suggested notes: `preflight=…`, `profile=…`, `label=…`, `cut=…`,
-`allowed/excluded=…`, `shortlist=…`, `N rules, holdout|in-sample`,
-`packages=…`, `report=…`, `verdict=…`.
-
-## Input
-
-CSV / XLSX / TXT; one row per event or case; optional outcome column. A dataset
-may contain more than one event type, but every scored rule needs a declared
-event grain and decision point.
-
-## Workflow
-
-Follow [references/workflow.md](references/workflow.md) for each step. The map:
-
-| Step | Do | Gate |
-|---|---|---|
-| 0 Pre-flight | Label provenance; pass / needs-user-input / descriptive-only / blocked | No supervised metrics until pass |
-| 1 Profile | Archetype + mechanism(s) + context(s) from taxonomy | Read selected packs before Step 2 |
-| 2 Label | Formalize positive / negative / unlabeled | Both classes defined before scoring |
-| 3 Time split | Freeze train/holdout before features | No random shuffle as headline |
-| 4 Features | Engineer candidates at decision time | Train-only thresholds |
-| 5 Shortlist | Lift / support / stability / operability | Train only |
-| 6 Score | occurrence → precision → recall on holdout | Headline = holdout |
-| 7 Actions | Map to context packs + strategy packages | Freeze packages before report |
-| 8 Report | Business report per template; grep terminology banned strings | No review process in the file |
-| 9 Review | Checklist + selected packs | Prefer fresh independent reviewer |
-
-## Output contract
-
-| Item | Requirement |
-|---|---|
-| Analysis profile | Archetype, role, consent, technical authentication, mechanism, context, confidence, grain, decision point |
-| Rule metrics | occurrence → precision → recall; headline window identified |
-| Strategy coverage | triggered count + rate and amount + share, with currency |
-| Domain impact | Measures and denominators from selected context packs only |
-| Uncertainty | Proxy labels, immature outcomes, weak identity links, and unresolved attribution stated |
-| Report file | Business content only; no reviewer model, verdict, or repair log |
-
-Steps 0–7 are analysis and its entry gate. Step 8 writes the report. Step 9
-reviews it.