Inbox-to-issue agent: turn support email into draft issues you approve

You are triaging support messages for <PRODUCT>. Below is a JSON list of messages. Each has an id, a subject, a body, and a "group" number from a script that already merged exact repeats.

Merge messages that describe the same underlying problem, even when the wording differs. Only merge when you can name the shared symptom. If you are not sure, keep them apart and say why.

Rules:
- Never invent details that are not in the messages.
- Never merge billing, account or feature requests with bugs.
- Quote the exact error text when there is one.

Return only JSON, no prose:
[{"cluster": 1, "ids": ["m1", "m2"], "symptom": "one sentence", "type": "bug|billing|account|feature|question", "evidence": ["exact quote"], "unsure": "empty, or why these might not belong together"}]

Messages:
<PASTE fingerprinted.json>

Write a draft bug report for one cluster of support messages. You have not run the product. You only have what users wrote.

Our labels:
<PASTE labels.md>

Return only JSON, no prose:
{"title": "under 80 characters, names the symptom and the area",
 "body": "markdown with these sections: Summary, Repro steps (from reports, not reproduced), Expected, Actual, Reports, Missing",
 "labels": ["bug", "agent-draft", "<one area label>"],
 "severity": "S1|S2|S3",
 "confidence": "high|medium|low",
 "reports": ["message ids"]}

Severity: S1 = people can't log in, pay, or reach their data. S2 = a main feature fails with no workaround. S3 = everything else.
Repro steps may only use actions a user described. If the reports don't give enough to reproduce it, write "Not enough detail to reproduce" and put the questions to ask under Missing.
Never include email addresses, names, invoice numbers, or anything else that identifies a customer.

Cluster:
<PASTE one cluster from prompt 1, plus the full text of its messages>

Below is audit.jsonl from the last 7 days (every draft and whether a human created or skipped it), followed by the issues we later closed as duplicate, wrong, or won't fix.

List:
1. Drafts we skipped, and the most likely reason for each.
2. Clusters that should have been merged, or split.
3. At most 3 changes to prompt 1 or prompt 2 that would have prevented the most mistakes. Quote the draft titles that each change fixes.

Don't suggest new tools or new steps.

audit.jsonl:
<PASTE>

Closed issues:
<PASTE titles and close reasons>

#!/usr/bin/env python3
"""Group support messages that are obviously the same report before any model sees them.

Input: a JSON list of {"id", "from", "subject", "body", "received"} (one per email or Slack message).
Output: the same list with "fp" (fingerprint) and "group" added, sorted by group, to stdout.

The fingerprint is the first error-looking line (exception names, HTTP codes, "error:" lines) with
numbers, ids, emails and URLs stripped. Messages with no error line fall back to the normalized subject.
This only catches exact repeats. The dedupe prompt handles reports that describe the same bug differently.

Usage: python3 fingerprint.py messages.json > fingerprinted.json
"""
import hashlib, json, re, sys

ERROR_LINE = re.compile(r"(error|exception|traceback|failed|failure|\b[45]\d\d\b|timeout|crash)", re.I)
# Start the fingerprint at the error itself, so "Console says: TypeError ..." and "TypeError ..." match.
ERROR_START = re.compile(r"(\w*(Error|Exception)\b|\b(GET|POST|PUT|PATCH|DELETE)\b|\b[45]\d\d\b)")

def normalize(text: str) -> str:
    t = text.lower()
    t = re.sub(r"https?://\S+", "<url>", t)
    t = re.sub(r"[\w.+-]+@[\w-]+\.[\w.]+", "<email>", t)
    t = re.sub(r"\b[0-9a-f]{8,}\b", "<id>", t)
    t = re.sub(r"\d+", "<n>", t)
    t = re.sub(r"^(re|fwd?|fw):\s*", "", t)
    return re.sub(r"\s+", " ", t).strip()

def fingerprint(msg: dict) -> str:
    for line in (msg.get("body") or "").splitlines():
        if ERROR_LINE.search(line) and len(line.strip()) > 8:
            start = ERROR_START.search(line)
            core = line[start.start():] if start else line
            return "err:" + hashlib.sha1(normalize(core).encode()).hexdigest()[:10]
    return "subj:" + hashlib.sha1(normalize(msg.get("subject") or "").encode()).hexdigest()[:10]

def main():
    if len(sys.argv) != 2:
        sys.exit(__doc__)
    msgs = json.load(open(sys.argv[1]))
    groups: dict[str, int] = {}
    for m in msgs:
        m["fp"] = fingerprint(m)
        m["group"] = groups.setdefault(m["fp"], len(groups) + 1)
    msgs.sort(key=lambda m: (m["group"], m.get("received", "")))
    json.dump(msgs, sys.stdout, indent=2)
    print(f"\n# {len(msgs)} messages, {len(groups)} groups", file=sys.stderr)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Show each draft issue and create it only when a human types y. Nothing is created without a y.

Input: drafts.json, a list of {"title", "body", "labels": [...], "severity", "confidence", "reports": [ids]}
(the output of the draft-issue prompt).

Usage:
  python3 approve.py drafts.json --repo owner/name            # GitHub, via the gh CLI (gh auth login first)
  python3 approve.py drafts.json --repo owner/name --dry-run  # print the gh commands, create nothing
Approved, skipped and edited drafts are appended to audit.jsonl for the weekly review.
"""
import json, shlex, subprocess, sys, tempfile, datetime

def main():
    args = sys.argv[1:]
    if not args or "--repo" not in args:
        sys.exit(__doc__)
    path = args[0]
    repo = args[args.index("--repo") + 1]
    dry = "--dry-run" in args
    drafts = json.load(open(path))
    audit = open("audit.jsonl", "a")
    for i, d in enumerate(drafts, 1):
        print(f"\n--- Draft {i}/{len(drafts)}  severity={d.get('severity')}  confidence={d.get('confidence')}  reports={len(d.get('reports', []))}")
        print(d["title"])
        print(d["body"])
        answer = "y" if dry else input("Create this issue? [y]es / [n]o / [e]dit title: ").strip().lower()
        if answer == "e":
            d["title"] = input("New title: ").strip() or d["title"]
            answer = "y"
        decision = "created" if answer == "y" else "skipped"
        if answer == "y":
            with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False) as f:
                f.write(d["body"])
            cmd = ["gh", "issue", "create", "--repo", repo, "--title", d["title"], "--body-file", f.name]
            for label in d.get("labels", []):
                cmd += ["--label", label]
            if dry:
                print("DRY RUN:", " ".join(shlex.quote(c) for c in cmd))
                decision = "dry-run"
            else:
                subprocess.run(cmd, check=True)
        audit.write(json.dumps({"at": datetime.datetime.now().isoformat(timespec="seconds"), "title": d["title"], "decision": decision, "severity": d.get("severity"), "reports": d.get("reports", [])}) + "\n")
    audit.close()

if __name__ == "__main__":
    main()