AI-accelerated delivery on SAP programs

"""Draft a spec and test-case pack for Calder's interface I10 with AI, then score it.

Calder Pumpworks is fictional. Notes, answer key, rules and minutes are course values.

Commands (run from your course folder):
  python unit14/delivery_pack.py init               write the workshop notes and the answer key
  python unit14/delivery_pack.py draft --sample     use a recorded draft (free, no account)
  python unit14/delivery_pack.py draft --llm        a real model drafts the pack (small charge)
  python unit14/delivery_pack.py draft --file my_draft.json   score your own draft
  python unit14/delivery_pack.py score              compare the draft with the answer key
  python unit14/delivery_pack.py log --reviewer "Your Name" --review-minutes 50 --fix-minutes 40
  python unit14/delivery_pack.py report             time saved per pack, from the log

Nothing here connects to an SAP system. The draft is never accepted by this script:
a person reviews it, fixes it and signs the spec, and the log records that work.
"""
import argparse
import json
import os
import re
import sys
from datetime import datetime, timezone
from pathlib import Path

HERE = Path(__file__).resolve().parent
WORK = HERE / "delivery"
NOTES = WORK / "notes_I10.md"
KEY = WORK / "key_I10.json"
DRAFT = WORK / "draft_I10.json"
SCORE = WORK / "score_I10.json"
LOG = WORK / "delivery_log.jsonl"

# Course baseline: what writing this pack by hand took on comparable interfaces.
BASELINE_MINUTES = 360

NOTES_TEXT = """\
# Workshop notes: I10 distributor purchase orders (Calder Pumpworks, fictional)

Workshop on 2026-10-27. Present: customer service lead, integration lead, Hallam's EDI contact.
Course notes, typed during the meeting. Not reviewed.

- Distributors send POs by EDI to Calder's EDI address. One message = one PO, one or more lines.
- Hallam Fluid Systems is the first distributor. The trading partner profile says Hallam = 10000002.
  If we don't know the sender, reject it and tell the integration team. Never trust a customer number in the message.
- Ship-to: distributors send a location code. Sales master data keeps the cross-reference.
  Blank ship-to means same as sold-to.
- Their PO number goes into the customer reference. Customer service wants a check:
  same PO number for the same sold-to twice means a duplicate, no second order. Customer service owns duplicates.
- PO date goes into the customer reference date.
- Line numbers: line 1 becomes item 10, line 2 item 20, so line x 10.
- Hallam sends its own part numbers. HFS-SK-200 is our CP-SK200 (seal kit).
  Unknown part number -> message stops in S/4HANA, customer service adds the cross-reference and reprocesses.
- Units: they send EA or PCE, we use PC. Unknown unit -> integration team extends the code list.
- Requested date goes into the requested delivery date. A date in the past is kept and flagged for customer service.
- Price: they send a unit price but S/4HANA determines the price. Do not map it. A price dispute is a sales issue.
- Sales area is always sales org CPUS, channel 20, division PU (from the partner agreement).
- Someone asked about Incoterms. Not in scope for now; maybe later with the order change interface.
- Order changes and cancellations are a separate interface. The confirmation back to the distributor stays on I04.
- If S/4HANA is down: automatic retry, 4 tries, backoff 0.5 s doubling to 4 s, then alert the integration team.
- Credit block on a created order is NOT an interface error. Credit management works it in the normal worklist.
- Volumes: about 120 messages a day, peak 30 an hour. The business notices after 1 hour.
- Test data: HFS-PO-7781 (60 CP-SK200) is the happy path. HFS-PO-7790 for the S/4HANA-down case.
  XYZ-PO-0001 is an unknown sender. Volume test: 60 messages in one hour, twice the peak.
- Technical user posts with a role limited to creating sales orders in sales org CPUS.
"""

# The answer key, written by hand from the I10 spec in Unit 5B. Each item lists the words
# that must appear for a draft item to count (any one of "find", all of "need").
KEY_DATA = {
    "interface": "I10",
    "mapping": [
        {"id": "M01", "target": "Sold-to party", "find": ["sold-to", "sold to"], "need": ["10000002"]},
        {"id": "M02", "target": "Ship-to party", "find": ["ship-to", "ship to"], "need": ["sold-to"]},
        {"id": "M03", "target": "Customer reference", "find": ["customer reference", "customer po"], "need": []},
        {"id": "M04", "target": "Customer reference date", "find": ["reference date", "po date"], "need": []},
        {"id": "M05", "target": "Item number", "find": ["item number", "item"], "need": ["10"]},
        {"id": "M06", "target": "Product", "find": ["product", "material"], "need": ["CP-SK200"]},
        {"id": "M07", "target": "Order quantity and unit", "find": ["unit", "quantity"], "need": ["EA", "PCE", "PC"]},
        {"id": "M08", "target": "Requested delivery date", "find": ["requested delivery date", "delivery date"], "need": []},
        {"id": "M09", "target": "Sales area", "find": ["sales area", "sales org"], "need": ["CPUS", "20", "PU"]},
    ],
    "errors": [
        {"id": "E01", "what": "Unknown sender", "find": ["unknown sender", "sender not", "partner not"], "owner": "integration"},
        {"id": "E02", "what": "Unknown part number", "find": ["part number", "unknown part", "product not"], "owner": "customer service"},
        {"id": "E03", "what": "Duplicate customer PO", "find": ["duplicate"], "owner": "customer service"},
        {"id": "E04", "what": "Unknown unit of measure", "find": ["unit of measure", "unknown unit"], "owner": "integration"},
        {"id": "E05", "what": "S/4HANA not reachable", "find": ["down", "not reachable", "unavailable"], "owner": "integration"},
    ],
    "tests": [
        {"id": "T-HAPPY", "level": "string", "find": ["HFS-PO-7781"]},
        {"id": "T-DOWN", "level": "string", "find": ["HFS-PO-7790"]},
        {"id": "T-DUP", "level": "string", "find": ["duplicate", "twice", "again"]},
        {"id": "T-SENDER", "level": "string", "find": ["XYZ-PO-0001"]},
        {"id": "T-E2E", "level": "end-to-end", "find": ["invoice", "delivery"]},
        {"id": "T-REPROC", "level": "end-to-end", "find": ["reprocess"]},
        {"id": "T-VOLUME", "level": "volume", "find": ["60 messages", "60 msgs", "twice the peak"]},
    ],
    "levels": ["unit", "string", "end-to-end", "volume"],
    # Things the notes rule out. A draft that does them contradicts the notes.
    "must_not": [
        {"id": "X01", "section": "mapping", "find": ["price"], "why": "S/4HANA determines the price; the notes say do not map it"},
        {"id": "X02", "section": "mapping", "find": ["incoterm"], "why": "Incoterms are out of scope for now"},
        {"id": "X03", "section": "errors", "find": ["credit"], "why": "A credit block is not an interface error"},
    ],
}

# A recorded draft, kept so the walkthrough runs without an account. It has the kinds of
# mistakes model drafts make: a missed case, a ruled-out field, a made-up rule, a wrong owner.
SAMPLE_DRAFT = {
    "interface": "I10",
    "drafted_by": "recorded sample (no model call)",
    "mapping": [
        {"source": "Sender identifier", "target": "Sold-to party",
         "rule": "Look up the trading partner profile: Hallam = 10000002",
         "evidence": "The trading partner profile says Hallam = 10000002."},
        {"source": "Purchase order number", "target": "Customer reference",
         "rule": "Copy", "evidence": "Their PO number goes into the customer reference."},
        {"source": "Purchase order date", "target": "Customer reference date",
         "rule": "Copy", "evidence": "PO date goes into the customer reference date."},
        {"source": "Line number", "target": "Item number", "rule": "Line x 10",
         "evidence": "so line x 10"},
        {"source": "Distributor part number", "target": "Product",
         "rule": "Cross-reference HFS-SK-200 -> CP-SK200",
         "evidence": "HFS-SK-200 is our CP-SK200 (seal kit)."},
        {"source": "Quantity and unit", "target": "Order quantity and unit", "rule": "EA -> PC",
         "evidence": "they send EA or PCE, we use PC."},
        {"source": "Requested date", "target": "Requested delivery date", "rule": "Copy",
         "evidence": "Requested date goes into the requested delivery date."},
        {"source": "Unit price", "target": "Net price", "rule": "Copy the distributor's unit price",
         "evidence": "they send a unit price"},
        {"source": "Incoterms", "target": "Incoterms", "rule": "Copy",
         "evidence": "Someone asked about Incoterms."},
        {"source": "(constant)", "target": "Sales area", "rule": "CPUS / 20 / PU",
         "evidence": "Sales area is always sales org CPUS, channel 20, division PU"},
    ],
    "errors": [
        {"code": "E01", "error": "Unknown sender", "owner": "Integration team",
         "next": "Reject and alert", "evidence": "If we don't know the sender, reject it and tell the integration team."},
        {"code": "E02", "error": "Unknown part number", "owner": "Customer service",
         "next": "Add the cross-reference and reprocess",
         "evidence": "customer service adds the cross-reference and reprocesses."},
        {"code": "E03", "error": "Unknown unit of measure", "owner": "Integration team",
         "next": "Extend the code list", "evidence": "Unknown unit -> integration team extends the code list."},
        {"code": "E04", "error": "S/4HANA down", "owner": "Integration team",
         "next": "Retry 4 times, then alert", "evidence": "automatic retry, 4 tries, backoff 0.5 s doubling to 4 s"},
        {"code": "E05", "error": "Credit block on the order", "owner": "Integration team",
         "next": "Retry automatically after one hour", "evidence": "Credit block on a created order"},
        {"code": "E06", "error": "Invalid tax code", "owner": "Integration team",
         "next": "Correct the tax code and reprocess", "evidence": "Tax codes are checked by the interface."},
    ],
    "tests": [
        {"level": "unit", "case": "Each mapping row with a valid value", "data": "Rows 1-10",
         "expected": "Target field filled", "evidence": "line 1 becomes item 10"},
        {"level": "string", "case": "Happy path", "data": "HFS-PO-7781",
         "expected": "One sales order for 60 CP-SK200", "evidence": "HFS-PO-7781 (60 CP-SK200) is the happy path."},
        {"level": "string", "case": "S/4HANA down", "data": "HFS-PO-7790",
         "expected": "Retries, then one order", "evidence": "HFS-PO-7790 for the S/4HANA-down case."},
        {"level": "string", "case": "Unknown sender", "data": "XYZ-PO-0001",
         "expected": "Rejected, alert to the integration team", "evidence": "XYZ-PO-0001 is an unknown sender."},
        {"level": "end-to-end", "case": "Distributor order to invoice", "data": "HFS-PO-7781",
         "expected": "Order, delivery, invoice, confirmation on I04",
         "evidence": "The confirmation back to the distributor stays on I04."},
    ],
    "open_questions": ["Which IDoc basic type and segments does the EDI provider deliver?"],
}

SYSTEM = """You draft interface specifications for an SAP S/4HANA program.
Use only the workshop notes you are given. Rules:
- Every mapping row, error and test case carries an "evidence" field: a short quote copied
  word for word from the notes. If the notes don't support an item, leave the item out.
- Anything the notes leave open goes into "open_questions", not into the mapping.
- Do not map fields the notes say are out of scope or must not be mapped.
- Reply with JSON only, in this shape:
{"interface": "I10",
 "mapping": [{"source": "", "target": "", "rule": "", "evidence": ""}],
 "errors": [{"code": "E01", "error": "", "owner": "", "next": "", "evidence": ""}],
 "tests": [{"level": "unit|string|end-to-end|volume", "case": "", "data": "", "expected": "", "evidence": ""}],
 "open_questions": [""]}"""


def norm(text: str) -> str:
    return re.sub(r"\s+", " ", str(text)).strip().lower()


def has_any(text: str, words) -> bool:
    t = norm(text)
    return any(norm(w) in t for w in words)


def has_all(text: str, words) -> bool:
    t = norm(text)
    return all(norm(w) in t for w in words)


def need(path: Path, hint: str):
    if not path.exists():
        sys.exit(f"{path.relative_to(HERE.parent)} not found. Run first: {hint}")
    return path.read_text(encoding="utf-8")


# ---------- drafting ----------

def llm_draft(model: str, notes: str) -> dict:
    try:
        from dotenv import load_dotenv
        from anthropic import Anthropic  # imported here so --sample works without the library
    except ImportError:
        sys.exit("The anthropic or python-dotenv library is missing. Run: pip install -r requirements.txt")
    load_dotenv()
    if not os.environ.get("ANTHROPIC_API_KEY"):
        sys.exit("ANTHROPIC_API_KEY is not set in .env. Add it, or use --sample.")
    try:
        reply = Anthropic().messages.create(
            model=model, max_tokens=4000, system=SYSTEM,
            messages=[{"role": "user", "content": f"<notes>\n{notes}</notes>\n\nDraft the I10 pack."}])
    except Exception as err:  # wrong key, wrong model name, network blocked
        sys.exit(f"The model call failed: {type(err).__name__}: {err}")
    text = "".join(b.text for b in reply.content if b.type == "text")
    try:
        data = json.loads(text[text.index("{"):text.rindex("}") + 1])
    except ValueError as err:
        sys.exit(f"The model's reply could not be read as JSON ({err}). Run draft again.")
    data["drafted_by"] = f"model {model}"
    return data


def cmd_init(args) -> None:
    if WORK.exists() and any(WORK.iterdir()) and not args.force:
        sys.exit("unit14/delivery already exists. Add --force to start over (deletes the draft, score and log).")
    WORK.mkdir(parents=True, exist_ok=True)
    for old in WORK.glob("*"):
        old.unlink()
    NOTES.write_text(NOTES_TEXT, encoding="utf-8")
    KEY.write_text(json.dumps(KEY_DATA, indent=1) + "\n", encoding="utf-8")
    print("Wrote unit14/delivery/notes_I10.md (workshop notes) and key_I10.json (answer key)")
    print("Next: python unit14/delivery_pack.py draft --sample")


def cmd_draft(args) -> None:
    notes = need(NOTES, "python unit14/delivery_pack.py init")
    if args.llm:
        data = llm_draft(args.model, notes)
    elif args.file:
        try:
            data = json.loads(Path(args.file).read_text(encoding="utf-8"))
        except (OSError, ValueError) as err:
            sys.exit(f"Could not read {args.file} as JSON: {err}")
        data.setdefault("drafted_by", f"file {args.file}")
    else:
        data = SAMPLE_DRAFT
    for part in ("mapping", "errors", "tests"):
        if not isinstance(data.get(part), list):
            sys.exit(f"The draft has no '{part}' list. Check the JSON shape in the script's SYSTEM text.")
    DRAFT.write_text(json.dumps(data, indent=1) + "\n", encoding="utf-8")
    print(f"Wrote unit14/delivery/draft_I10.json ({data['drafted_by']}): "
          f"{len(data['mapping'])} mapping rows, {len(data['errors'])} errors, {len(data['tests'])} tests")
    print("Next: python unit14/delivery_pack.py score")


# ---------- scoring ----------

def item_text(item: dict) -> str:
    return " ".join(str(v) for k, v in item.items() if k != "evidence")


def grounded(item: dict, notes: str) -> bool:
    quote = norm(item.get("evidence", ""))
    return len(quote) >= 8 and quote in norm(notes)


def score(draft: dict, key: dict, notes: str) -> dict:
    out = {"mapping": [], "errors": [], "tests": [], "levels": [], "contradictions": [], "ungrounded": []}

    for k in key["mapping"]:
        rows = [r for r in draft["mapping"] if has_any(r.get("target", ""), k["find"])]
        if not rows:
            out["mapping"].append((k["id"], k["target"], "MISSING", ""))
        elif any(has_all(item_text(r), k["need"]) for r in rows):
            out["mapping"].append((k["id"], k["target"], "MATCH", ""))
        else:
            text = norm(item_text(rows[0]))
            lacks = [w for w in k["need"] if norm(w) not in text]
            out["mapping"].append((k["id"], k["target"], "PARTIAL", "rule lacks " + ", ".join(lacks)))

    for k in key["errors"]:
        rows = [r for r in draft["errors"] if has_any(r.get("error", ""), k["find"])]
        if not rows:
            out["errors"].append((k["id"], k["what"], "MISSING", ""))
        elif any(k["owner"] in norm(r.get("owner", "")) for r in rows):
            out["errors"].append((k["id"], k["what"], "MATCH", ""))
        else:
            out["errors"].append((k["id"], k["what"], "PARTIAL", "wrong owner: " + rows[0].get("owner", "")))

    for k in key["tests"]:
        hit = any(has_any(item_text(t), k["find"]) for t in draft["tests"])
        out["tests"].append((k["id"], k["level"], "MATCH" if hit else "MISSING", ""))
    levels = {norm(t.get("level", "")) for t in draft["tests"]}
    out["levels"] = [lvl for lvl in key["levels"] if lvl not in levels]

    for x in key["must_not"]:
        for r in draft[x["section"]]:
            field = r.get("target", "") if x["section"] == "mapping" else r.get("error", "")
            if has_any(field, x["find"]):
                out["contradictions"].append((x["id"], f"{x['section']}: {field}", x["why"]))

    for part in ("mapping", "errors", "tests"):
        for i, r in enumerate(draft[part], 1):
            if not grounded(r, notes):
                label = r.get("target") or r.get("error") or r.get("case") or f"item {i}"
                out["ungrounded"].append((part, label, r.get("evidence", "")))
    return out


def summary(out: dict) -> dict:
    def pct(rows):
        hit = sum(1 for r in rows if r[2] == "MATCH") + 0.5 * sum(1 for r in rows if r[2] == "PARTIAL")
        return round(100 * hit / len(rows)) if rows else 0
    s = {"mapping_pct": pct(out["mapping"]), "errors_pct": pct(out["errors"]), "tests_pct": pct(out["tests"]),
         "missing_levels": len(out["levels"]), "contradictions": len(out["contradictions"]),
         "ungrounded": len(out["ungrounded"])}
    s["coverage_pct"] = round((s["mapping_pct"] + s["errors_pct"] + s["tests_pct"]) / 3)
    blockers = s["contradictions"] + s["ungrounded"]
    s["verdict"] = ("REDRAFT" if s["coverage_pct"] < 60
                    else "REVIEW, FIX THE FLAGGED ITEMS FIRST" if blockers or s["missing_levels"]
                    else "REVIEW")
    return s


def cmd_score(args) -> None:
    notes = need(NOTES, "python unit14/delivery_pack.py init")
    key = json.loads(need(KEY, "python unit14/delivery_pack.py init"))
    draft = json.loads(need(DRAFT, "python unit14/delivery_pack.py draft --sample"))
    out = score(draft, key, notes)
    s = summary(out)
    print(f"Draft: {draft.get('drafted_by', '?')}\n")
    for part, title in (("mapping", "Mapping rows"), ("errors", "Error cases"), ("tests", "Test cases")):
        print(f"{title} against the answer key: {s[part + '_pct']}%")
        for iid, what, status, note in out[part]:
            print(f"  {status:8} {iid:9} {what}" + (f"  ({note})" if note else ""))
    print(f"\nTest levels missing: {', '.join(out['levels']) or 'none'}")
    print(f"\nContradicts the notes: {len(out['contradictions'])}")
    for iid, where, why in out["contradictions"]:
        print(f"  {iid}  {where}: {why}")
    print(f"\nNot grounded in the notes (evidence quote not found): {len(out['ungrounded'])}")
    for part, label, quote in out["ungrounded"]:
        print(f"  {part}: {label}  quote: \"{quote}\"")
    print(f"\nCoverage {s['coverage_pct']}%  ->  {s['verdict']}")
    SCORE.write_text(json.dumps({"draft": draft.get("drafted_by"), "summary": s, "detail": out}, indent=1) + "\n",
                     encoding="utf-8")


# ---------- time saved ----------

def cmd_log(args) -> None:
    if not SCORE.exists():
        sys.exit("No score yet. Run: python unit14/delivery_pack.py score")
    if not args.reviewer.strip():
        sys.exit("Name the reviewer: --reviewer \"Your Name\"")
    sc = json.loads(SCORE.read_text(encoding="utf-8"))
    entry = {"at": datetime.now(timezone.utc).isoformat(timespec="seconds"), "artifact": "I10 spec and test pack",
             "draft": sc["draft"], "coverage_pct": sc["summary"]["coverage_pct"],
             "flagged": sc["summary"]["contradictions"] + sc["summary"]["ungrounded"],
             "reviewer": args.reviewer.strip(), "review_minutes": args.review_minutes,
             "fix_minutes": args.fix_minutes, "baseline_minutes": BASELINE_MINUTES}
    with LOG.open("a", encoding="utf-8") as f:
        f.write(json.dumps(entry) + "\n")
    print(f"Logged: {entry['reviewer']} reviewed for {args.review_minutes} min and fixed for {args.fix_minutes} min.")


def cmd_report(args) -> None:
    if not LOG.exists():
        sys.exit("No log yet. Run: python unit14/delivery_pack.py log --reviewer \"Your Name\" ...")
    rows = [json.loads(line) for line in LOG.read_text(encoding="utf-8").splitlines() if line.strip()]
    print(f"{'Artifact':24} {'Draft':34} {'Cov.':>5} {'Flag':>5} {'Hand':>6} {'AI+rev':>7} {'Saved':>7}")
    total_base = total_ai = 0
    for r in rows:
        spent = r["review_minutes"] + r["fix_minutes"]
        total_base += r["baseline_minutes"]
        total_ai += spent
        print(f"{r['artifact']:24} {r['draft'][:34]:34} {r['coverage_pct']:>4}% {r['flagged']:>5} "
              f"{r['baseline_minutes']:>5}m {spent:>6}m {r['baseline_minutes'] - spent:>6}m")
    saved = total_base - total_ai
    print(f"\n{len(rows)} pack(s): {total_base} min by hand, {total_ai} min with AI and review, "
          f"{saved} min saved ({round(100 * saved / total_base)}%).")
    print("Course baseline and your own minutes. Compare like with like before you claim a saving.")


def main() -> None:
    p = argparse.ArgumentParser(description="AI-drafted spec and test pack for Calder's I10, scored against a key")
    sub = p.add_subparsers(dest="cmd", required=True)
    s = sub.add_parser("init")
    s.add_argument("--force", action="store_true")
    s = sub.add_parser("draft")
    g = s.add_mutually_exclusive_group()
    g.add_argument("--sample", action="store_true", help="recorded draft (default)")
    g.add_argument("--llm", action="store_true", help="a real model drafts the pack")
    g.add_argument("--file", help="your own draft as JSON")
    s.add_argument("--model", default="claude-haiku-5-5", help="Anthropic model ID for --llm")
    sub.add_parser("score")
    s = sub.add_parser("log")
    s.add_argument("--reviewer", required=True)
    s.add_argument("--review-minutes", type=int, required=True)
    s.add_argument("--fix-minutes", type=int, required=True)
    sub.add_parser("report")
    args = p.parse_args()
    {"init": cmd_init, "draft": cmd_draft, "score": cmd_score, "log": cmd_log, "report": cmd_report}[args.cmd](args)


if __name__ == "__main__":
    main()

python unit14/delivery_pack.py init

Wrote unit14/delivery/notes_I10.md (workshop notes) and key_I10.json (answer key)
Next: python unit14/delivery_pack.py draft --sample

python unit14/delivery_pack.py draft --sample

Wrote unit14/delivery/draft_I10.json (recorded sample (no model call)): 10 mapping rows, 6 errors, 5 tests
Next: python unit14/delivery_pack.py score

python unit14/delivery_pack.py score

Draft: recorded sample (no model call)

Mapping rows against the answer key: 83%
  MATCH    M01       Sold-to party
  MISSING  M02       Ship-to party
  MATCH    M03       Customer reference
  MATCH    M04       Customer reference date
  MATCH    M05       Item number
  MATCH    M06       Product
  PARTIAL  M07       Order quantity and unit  (rule lacks PCE)
  MATCH    M08       Requested delivery date
  MATCH    M09       Sales area
Error cases against the answer key: 80%
  MATCH    E01       Unknown sender
  MATCH    E02       Unknown part number
  MISSING  E03       Duplicate customer PO
  MATCH    E04       Unknown unit of measure
  MATCH    E05       S/4HANA not reachable
Test cases against the answer key: 57%
  MATCH    T-HAPPY   string
  MATCH    T-DOWN    string
  MISSING  T-DUP     string
  MATCH    T-SENDER  string
  MATCH    T-E2E     end-to-end
  MISSING  T-REPROC  end-to-end
  MISSING  T-VOLUME  volume

Test levels missing: volume

Contradicts the notes: 3
  X01  mapping: Net price: S/4HANA determines the price; the notes say do not map it
  X02  mapping: Incoterms: Incoterms are out of scope for now
  X03  errors: Credit block on the order: A credit block is not an interface error

Not grounded in the notes (evidence quote not found): 1
  errors: Invalid tax code  quote: "Tax codes are checked by the interface."

Coverage 73%  ->  REVIEW, FIX THE FLAGGED ITEMS FIRST

python unit14/delivery_pack.py log --reviewer "Your Name" --review-minutes 50 --fix-minutes 40
python unit14/delivery_pack.py report

Logged: Your Name reviewed for 50 min and fixed for 40 min.
Artifact                 Draft                               Cov.  Flag   Hand  AI+rev   Saved
I10 spec and test pack   recorded sample (no model call)      73%     4   360m     90m    270m

1 pack(s): 360 min by hand, 90 min with AI and review, 270 min saved (75%).
Course baseline and your own minutes. Compare like with like before you claim a saving.

python unit14/delivery_pack.py draft --llm
python unit14/delivery_pack.py score

git add unit14/delivery_pack.py unit14/delivery
git commit -m "Unit 14: AI-drafted I10 spec pack scored against an answer key"