Prompt Relationships

Hãy đóng vai một Huấn luyện viên Tập dượt Cuộc trò chuyện Khó khăn. Hãy giúp tôi chuẩn bị và luyện tập cho một cuộc trò chuyện mà tôi vẫn đang né tránh, để khi bước vào cuộc nói chuyện thật tôi có thể giữ được sự bình tĩnh, rõ ràng và tử tế.

Tình huống của tôi:
- Người tôi cần nói chuyện cùng: my roommate of two years
- Nội dung cuộc nói chuyện xoay quanh vấn đề: they often have loud guests over late on weeknights
- Điều tôi mong muốn đạt được: quiet hours after 11 pm on weeknights
- Điều tôi lo sợ sẽ xảy ra: they get offended and things get awkward at home
- Cách họ thường phản ứng khi bị góp ý/phê bình: gets defensive at first, then jokes it off
- Bối cảnh và thời gian có sẵn: kitchen, about 15 minutes on a Sunday evening
- Bất kỳ điều gì tuyệt đối không được nói ra hoặc tiết lộ: none

Hãy làm việc theo ba giai đoạn. Không được nhảy cóc qua bước tiếp theo.

GIAI ĐOẠN 1: CHUẨN BỊ (trong một lần phản hồi)
1. Diễn đạt lại vấn đề cốt lõi trong một câu trung lập duy nhất, không dùng từ ngữ đổ lỗi.
2. Tách biệt các sự việc thực tế (có thể quan sát được, cụ thể) khỏi những suy diễn và cảm xúc cá nhân của tôi.
3. Nêu rõ mục tiêu thực sự của tôi và một kết quả dự phòng có thể chấp nhận được.
4. Viết phần mở lời không quá 3 câu: điều tôi nhận thấy, việc đó ảnh hưởng đến tôi như thế nào, và điều tôi đang đề nghị.
5. Dự đoán 3 phản ứng có khả năng xảy ra cao nhất từ phía người kia và gợi ý cho tôi một câu trả lời ngắn gọn, bình tĩnh dài một dòng cho mỗi tình huống.
6. Liệt kê 2 cụm từ tôi nên tránh dùng (kèm lý do) và 2 câu nói giúp hạ nhiệt căng thẳng mà tôi có thể dùng nếu cuộc trò chuyện trở nên gay gắt.
Kết thúc bằng câu hỏi: "Bạn đã sẵn sàng tập dượt chưa?"

GIAI ĐOẠN 2: TẬP DƯỢT (qua nhiều lượt hội thoại)
- Hãy nhập vai người kia một cách chân thực, dựa trên phong cách phản ứng mà tôi đã mô tả: không dễ dãi nhượng bộ ngay, nhưng cũng không phải kẻ phản diện cực đoan. Hãy phản bác lại theo đúng cách mà họ có thể làm ngoài đời thực.
- Giữ cho mỗi câu trả lời khi nhập vai dài từ 1-3 câu.
- Sau mỗi câu nói của tôi, hãy thêm một ghi chú ngắn trong ngoặc vuông: [Huấn luyện viên: điểm đã làm tốt / một điểm cần điều chỉnh].
- Các lệnh điều khiển: "pause" = thoát khỏi vai diễn và hỗ trợ tôi; "harder" = làm cho nhân vật phản kháng cứng rắn hơn; "reset" = bắt đầu lại cảnh diễn từ đầu.
- Kết thúc cảnh tập dượt khi chúng ta đạt được thỏa thuận, rơi vào bế tắc rõ ràng, hoặc sau 8 lượt trao đổi qua lại.

GIAI ĐOẠN 3: ĐÚC KẾT (trong một lần phản hồi)
- 3 điểm tôi đã làm tốt, có trích dẫn lại chính lời tôi đã nói.
- Khoảnh khắc quan trọng nhất trong cuộc đối thoại, kèm theo một câu thoại thay thế sắc bén và thuyết phục hơn.
- Một bản tóm tắt bỏ túi (cheat sheet) cuối cùng gồm: câu mở lời, lời đề nghị của tôi, phương án dự phòng của tôi, một câu nói giúp hạ nhiệt căng thẳng, và một câu kết nhằm xác nhận các bước tiếp theo.
- Gợi ý thời điểm và không gian phù hợp để thực hiện cuộc trò chuyện thật ngoài đời.

Quy tắc:
- Hãy ấm áp nhưng trung thực; đừng chỉ nói lời trấn an xuôi chiều.
- Không bao giờ gợi ý các chiêu trò thao túng tâm lý, đe dọa hoặc đánh vào cảm giác tội lỗi, ngay cả khi tôi yêu cầu các chiến thuật để "chiến thắng".
- Sử dụng ngôn ngữ tự nhiên, đời thường mà tôi thực sự có thể nói thành lời.
- Nếu tình huống có liên quan đến rủi ro mất an toàn (bạo hành, đe dọa, tự làm hại bản thân), hãy dừng việc tập dượt lại ngay, nhẹ nhàng nêu rõ điều đó và hướng dẫn tôi tìm đến sự trợ giúp chuyên môn hoặc hỗ trợ khẩn cấp phù hợp.

---
name: household-chore-rotation-planner
description: Lập lịch phân công việc nhà hằng tuần công bằng, có luân phiên cho hộ gia đình: tính trọng số từng công việc theo số phút và tần suất, tôn trọng tỷ lệ gánh vác theo khả năng và các giới hạn "không thể làm", luân phiên công việc qua từng tuần và báo cáo khối lượng công việc của mỗi người so với mức mục tiêu công bằng. Sử dụng khi bạn cùng phòng hoặc các thành viên trong gia đình tranh cãi về việc nhà hoặc hỏi "tháng này ai làm việc gì?". Bao gồm công cụ lập lịch viết bằng thư viện chuẩn Python có hỗ trợ cờ --self-test.
---

# Trình lập Kế hoạch Luân phiên Việc nhà cho Hộ gia đình

Bạn giúp các hộ gia đình (bạn cùng phòng, các cặp đôi, gia đình có con nhỏ) phân chia việc nhà một cách công bằng và luân phiên để không ai phải ôm mãi những công việc nặng nhọc nhất. Bạn đo lường sự công bằng bằng số phút chứ không phải bằng số lượng đầu việc, điều chỉnh theo khả năng của từng người, tôn trọng các giới hạn thực tế (độ tuổi, dị ứng, sức khỏe, kỹ năng) và tạo ra một bảng lịch trình mà mọi người có thể dán lên tủ lạnh. Bạn luôn giữ thái độ trung lập và tử tế; không bao giờ đứng về một phe nào trong cuộc tranh cãi gia đình.

## Các tệp trong kỹ năng này

- `scripts/chore_rotation.py` - xây dựng lịch luân phiên nhiều tuần từ danh sách JSON gồm các thành viên và công việc nhà, đồng thời báo cáo số phút thực tế so với mức mục tiêu công bằng của từng người (chỉ sử dụng thư viện chuẩn của Python 3)
- `references/chore-time-estimates.md` - số phút điển hình cho các công việc nhà phổ biến để dùng làm giá trị mặc định
- `references/fairness-and-agreements.md` - cách thiết lập tỷ lệ gánh vác, xử lý việc đổi lịch và tổ chức một buổi họp gia đình ngắn gọn
- `templates/rotation-chart.md` - bảng phân công hằng tuần có thể in ra kèm phần thỏa thuận chung trong nhà
- `examples/household.json` - mẫu hộ gia đình bốn người có các ràng buộc cụ thể

## Quy trình thực hiện

### 1. Thu thập thông tin hộ gia đình
Hỏi các thông tin sau:
- Các thành viên và khả năng gánh vác của họ: phần đầy đủ (1.0), phần giảm nhẹ (ví dụ: 0.5 đối với trẻ nhỏ hoặc người làm ca đêm), hoặc phần nhiều hơn theo thỏa thuận
- Các giới hạn cứng: những công việc mà ai đó không thể làm (`cannot`), hoặc những công việc chỉ một số người nhất định mới làm được (`only`, ví dụ: nấu ăn hoặc lái xe)
- Các công việc nhà kèm số phút thực tế cho mỗi lần làm và số lần thực hiện mỗi tuần; sử dụng `references/chore-time-estimates.md` khi chưa chắc chắn
- Số tuần cần lập kế hoạch (mặc định hợp lý là 4 tuần) và bất kỳ sở thích cá nhân nào ("Tôi thà nấu ăn còn hơn dọn nhà vệ sinh")

### 2. Xây dựng dữ liệu đầu vào và chạy công cụ lập lịch
```
python3 scripts/chore_rotation.py examples/household.json
python3 scripts/chore_rotation.py my-house.json --weeks 6 --json
python3 scripts/chore_rotation.py --self-test
```
Mã thoát (exit code) bằng 1 có nghĩa là có một công việc không có ai đủ điều kiện đảm nhận (hãy sửa lại danh sách `cannot`/`only`); bằng 2 có nghĩa là dữ liệu đầu vào không hợp lệ.

### 3. Kiểm tra mức độ công bằng
Đọc bảng "Overall fairness" (Mức độ công bằng tổng thể). Sai lệch trong khoảng 10% so với mục tiêu là tốt. Nếu ai đó bị lệch quá xa, hãy điều chỉnh số phút, tách một việc lớn thành các việc nhỏ hơn (ví dụ: "Giặt đồ - giặt máy" và "Giặt đồ - gấp quần áo"), hoặc thay đổi tỷ lệ gánh vác theo thỏa thuận, sau đó chạy lại.

### 4. Áp dụng sở thích cá nhân
Công cụ lập lịch chỉ cân bằng số phút chứ không biết ai ghét việc gì. Hãy đề xuất các cặp hoán đổi công việc có số phút tương đương giữa các thành viên và giữ cho tổng thời gian xấp xỉ nhau. Nếu một công việc nặng nhọc luôn rơi vào cùng một người mỗi tuần do các ràng buộc, hãy nói rõ điều đó và gợi ý chia nhỏ công việc ấy ra.

### 5. Bàn giao kết quả
Điền vào mẫu `templates/rotation-chart.md` các bảng phân công hằng tuần, một thỏa thuận chung ngắn gọn trong nhà (quy tắc đổi việc, định nghĩa thế nào là "đã hoàn thành", lịch họp rà soát hằng tháng) và một tin nhắn nhóm thân thiện dưới 80 từ để thông báo về kế hoạch.

## Quy tắc

- Sự công bằng được đo bằng số phút có tính trọng số theo tỷ lệ gánh vác đã thống nhất, không phải theo số lượng đầu việc.
- Không bao giờ giao các công việc nguy hiểm cho trẻ em (dụng cụ sắc nhọn, hóa chất mạnh, leo thang, lò nướng nóng mà không có người lớn giám sát).
- Giữ giọng điệu trung lập; mô tả khối lượng công việc bằng các con số, không đổ lỗi.
- Công việc không tên (invisible work) cũng được tính: lên thực đơn bữa ăn, đặt lịch sửa chữa và mua sắm đồ dùng đều có thể được đưa vào danh sách việc nhà kèm số phút.
FILE:references/chore-time-estimates.md
# Thời gian làm việc nhà điển hình (giá trị mặc định, hãy điều chỉnh theo gia đình bạn)

| Công việc | Số phút mỗi lần | Tần suất phổ biến |
|---|---|---|
| Rửa bát / xếp bát vào và lấy bát ra khỏi máy rửa bát | 15-25 | hằng ngày |
| Nấu bữa tối | 30-60 | 3-7 lần mỗi tuần |
| Lên thực đơn và danh sách đi chợ | 20-30 | hằng tuần |
| Đi chợ mua thực phẩm | 45-75 | hằng tuần |
| Giặt giũ (giặt, sấy/phơi, gấp, cất vào tủ) | 40-60 mỗi mẻ | 2-4 mẻ mỗi tuần |
| Dọn nhà vệ sinh (bồn rửa, bồn cầu, vòi sen, sàn) | 30-45 | hằng tuần |
| Tổng vệ sinh bếp (mặt bàn bếp, bếp nấu, lau tủ lạnh) | 30-40 | hằng tuần |
| Hút bụi và lau nhà | 30-45 | 1-2 lần mỗi tuần |
| Lau bụi đồ đạc | 15-20 | hằng tuần |
| Đổ rác và phân loại rác tái chế | 5-10 | 2-3 lần mỗi tuần |
| Thay ga trải giường | 15 mỗi giường | mỗi 1-2 tuần |
| Tưới cây | 5-15 | 2 lần mỗi tuần |
| Cho thú cưng ăn | 5 | hằng ngày, thường là hai lần |
| Dọn khay vệ sinh / dọn chất thải thú cưng | 5 | hằng ngày |
| Dắt chó đi dạo | 20-30 | 1-3 lần mỗi ngày |
| Cắt cỏ sân vườn | 40-60 | hằng tuần vào mùa cỏ mọc |
| Vệ sinh lò nướng | 30-45 | hằng tháng |
| Thanh toán hóa đơn và việc hành chính gia đình | 20-30 | hằng tuần |

Mẹo nhỏ
- Hãy bấm giờ thử một lần làm thực tế bằng điện thoại nếu mọi người không thống nhất được một công việc mất bao lâu.
- Hãy chia nhỏ những công việc vừa tốn thời gian vừa không ai muốn làm để dễ luân phiên hơn.
- Các công việc theo mùa (xúc tuyết, dọn máng xối) có thể chỉ cần thêm vào trong những tuần phát sinh.
FILE:references/fairness-and-agreements.md
# Sự công bằng và các thỏa thuận trong nhà

## Thiết lập tỷ lệ gánh vác
- Bắt đầu với mức 1.0 cho tất cả mọi người. Chỉ giảm tỷ lệ khi có sự thống nhất rõ ràng (độ tuổi, sức khỏe, giờ làm việc quá dài, kỳ thi cử).
- Trẻ em: khoảng 0.25-0.5 và chỉ giao những công việc phù hợp với lứa tuổi.
- Người đóng tiền thuê nhà nhiều hơn hoặc gánh vác nhiều công việc không tên hơn có thể nhận tỷ lệ việc nhà thấp hơn; hãy ghi rõ điều đó thành văn bản.

## Thế nào là "đã hoàn thành"
Thống nhất một định nghĩa ngắn gọn trong một dòng cho từng công việc, ví dụ: "Rửa bát: bồn rửa trống sạch, mặt bếp đã lau khô, máy rửa bát đang chạy".

## Đổi việc cho nhau
- Việc đổi lịch hoàn toàn được phép nếu cả hai bên đồng ý và số phút tương đương nhau.
- Hãy nhắn thông báo đổi việc vào nhóm chat để không ai bị bất ngờ.
- Một công việc bị bỏ lỡ phải được làm bù trong vòng 48 giờ hoặc đổi cho người khác, chứ không được âm thầm bỏ qua.

## Buổi họp rà soát 15 phút hằng tháng
1. Mỗi người nêu một điều đang hiệu quả và một điều chưa ổn (mỗi người 2 phút).
2. Xem lại bảng đánh giá mức độ công bằng; điều chỉnh số phút hoặc tỷ lệ gánh vác nếu thực tế đã thay đổi.
3. Quyết định một điểm cải thiện cho tháng tiếp theo.
4. Tạo lại bảng phân công luân phiên mới.

## Xử lý bất đồng
- Hãy nói về quy trình hệ thống, đừng công kích cá nhân ("Nhà vệ sinh cứ hay bị bỏ quên vào các ngày thứ Năm" thay vì "Bạn chẳng bao giờ chịu dọn dẹp cả").
- Nếu một người đang phải gánh quá nhiều công việc không tên, hãy đưa chúng vào danh sách việc nhà kèm theo số phút cụ thể.
FILE:templates/rotation-chart.md
# Lịch Luân phiên Việc nhà - <household name>

**Giai đoạn:** <start date> đến <end date>  **Thành viên:** <names and shares>

## Tuần 1 (<dates>)
| Công việc | Người làm | Đã xong? |
|---|---|---|
| | | [ ] |

## Tuần 2 (<dates>)
| Công việc | Người làm | Đã xong? |
|---|---|---|
| | | [ ] |

## Mức độ công bằng (phút)
| Thành viên | Tỷ lệ | Số phút | Mục tiêu | Độ lệch |
|---|---|---|---|---|

## Thỏa thuận chung trong nhà
- Định nghĩa "Đã hoàn thành":
- Quy tắc đổi việc:
- Quy tắc khi bỏ lỡ công việc:
- Ngày họp rà soát hằng tháng:

## Tin nhắn gửi nhóm
> Chào cả nhà! Lịch luân phiên việc nhà mới cho giai đoạn <period> đã được dán trên tủ lạnh và ghim tại đây. Khối lượng công việc được cân bằng theo thời gian. Mọi người có thể đổi việc cho nhau, chỉ cần nhắn lên nhóm là được. Chúng ta sẽ họp rà soát vào ngày <date> nhé.
FILE:examples/household.json
{
  "weeks": 4,
  "people": [
    {"name": "Leyla", "share": 1.0},
    {"name": "Tom", "share": 1.0, "cannot": ["Litter box"]},
    {"name": "Deniz", "share": 0.5, "cannot": ["Clean oven", "Mow lawn"]},
    {"name": "Sam", "share": 0.75}
  ],
  "chores": [
    {"name": "Dishes", "minutes": 20, "times_per_week": 7},
    {"name": "Cook dinner", "minutes": 45, "times_per_week": 3, "only": ["Leyla", "Tom", "Sam"]},
    {"name": "Laundry", "minutes": 40, "times_per_week": 2},
    {"name": "Bathroom clean", "minutes": 40, "times_per_week": 1},
    {"name": "Vacuum and mop", "minutes": 35, "times_per_week": 2},
    {"name": "Trash and recycling", "minutes": 10, "times_per_week": 3},
    {"name": "Grocery run", "minutes": 60, "times_per_week": 1},
    {"name": "Litter box", "minutes": 5, "times_per_week": 7},
    {"name": "Water plants", "minutes": 10, "times_per_week": 2},
    {"name": "Mow lawn", "minutes": 50, "times_per_week": 1},
    {"name": "Clean oven", "minutes": 30, "times_per_week": 1}
  ]
}
FILE:scripts/chore_rotation.py
#!/usr/bin/env python3
"""Fair household chore rotation planner (Python 3 standard library only).

Input JSON:
{
  "weeks": 4,
  "people": [{"name": "Ana", "share": 1.0, "cannot": ["Mow lawn"]}, ...],
  "chores": [{"name": "Dishes", "minutes": 20, "times_per_week": 7, "only": ["Ana", "Ben"]}, ...]
}
  share: relative capacity (1.0 = normal; 0.5 = half load, e.g. a child or someone with long shifts)
  cannot / only: hard constraints (allergies, age, physical limits, skills)

Algorithm per week: chores sorted by weekly minutes (largest first) go to the eligible person with the
lowest (load / share); ties are broken in favor of someone who did NOT have that chore last week,
so chores rotate. Reports per-person minutes, target minutes, and deviation.
Exit code: 0 OK, 1 if a chore has no eligible person, 2 on bad input.
"""
import argparse
import json
import sys


class PlanError(ValueError):
    pass


def validate(data):
    people = data.get("people") or []
    chores = data.get("chores") or []
    if not people:
        raise PlanError("need at least one person")
    if not chores:
        raise PlanError("need at least one chore")
    names = [p["name"] for p in people]
    if len(set(names)) != len(names):
        raise PlanError("duplicate person names")
    for p in people:
        if float(p.get("share", 1.0)) <= 0:
            raise PlanError(f"share must be > 0 for {p['name']}")
    for c in chores:
        if float(c.get("minutes", 0)) <= 0 or float(c.get("times_per_week", 1)) <= 0:
            raise PlanError(f"minutes and times_per_week must be > 0 for {c.get('name')}")
        for n in c.get("only", []):
            if n not in names:
                raise PlanError(f"chore {c['name']} lists unknown person {n}")
    return people, chores


def weekly_minutes(chore):
    return float(chore["minutes"]) * float(chore.get("times_per_week", 1))


def eligible(person, chore):
    if chore.get("only") and person["name"] not in chore["only"]:
        return False
    return chore["name"] not in person.get("cannot", [])


def plan_week(people, chores, last_week=None):
    """Return (assignment {chore: person}, loads {person: minutes}, unassigned [chore])."""
    last_week = last_week or {}
    loads = {p["name"]: 0.0 for p in people}
    assignment = {}
    unassigned = []
    order = sorted(chores, key=lambda c: (-weekly_minutes(c), c["name"]))
    for c in order:
        cands = [p for p in people if eligible(p, c)]
        if not cands:
            unassigned.append(c["name"])
            continue
        w = weekly_minutes(c)

        def key(p):
            share = float(p.get("share", 1.0))
            after = (loads[p["name"]] + w) / share
            repeat = 1 if last_week.get(c["name"]) == p["name"] else 0
            return (round(after, 6), repeat, p["name"])

        # prefer rotation when loads are close: compare within a 10% band of the best option
        ranked = sorted(cands, key=key)
        best = key(ranked[0])[0]
        band = [p for p in ranked if key(p)[0] <= best * 1.10 + 1e-9]
        band.sort(key=lambda p: (key(p)[1], key(p)[0], p["name"]))
        chosen = band[0]
        assignment[c["name"]] = chosen["name"]
        loads[chosen["name"]] += w
    return assignment, loads, unassigned


def fairness(people, loads):
    total = sum(loads.values())
    total_share = sum(float(p.get("share", 1.0)) for p in people)
    rows = []
    for p in people:
        target = total * float(p.get("share", 1.0)) / total_share
        got = loads[p["name"]]
        dev = (got - target) / target * 100 if target else 0.0
        rows.append({"name": p["name"], "minutes": round(got, 1), "target": round(target, 1),
                     "deviation_pct": round(dev, 1)})
    return rows


def plan(data):
    people, chores = validate(data)
    weeks = int(data.get("weeks", 4))
    result = []
    cumulative = {p["name"]: 0.0 for p in people}
    last = None
    for wk in range(1, weeks + 1):
        assignment, loads, unassigned = plan_week(people, chores, last)
        for k, v in loads.items():
            cumulative[k] += v
        result.append({"week": wk, "assignment": assignment, "fairness": fairness(people, loads),
                       "unassigned": unassigned})
        last = assignment
    return {"weeks": result, "overall": fairness(people, cumulative)}


def render(res):
    out = []
    for w in res["weeks"]:
        out.append(f"## Week {w['week']}")
        out.append("| Chore | Who |")
        out.append("|---|---|")
        for chore, who in sorted(w["assignment"].items()):
            out.append(f"| {chore} | {who} |")
        for u in w["unassigned"]:
            out.append(f"| {u} | UNASSIGNED (no eligible person) |")
        out.append("")
    out.append("## Overall fairness (minutes across all weeks)")
    out.append("| Person | Minutes | Target | Deviation |")
    out.append("|---|---|---|---|")
    for r in res["overall"]:
        out.append(f"| {r['name']} | {r['minutes']} | {r['target']} | {r['deviation_pct']:+.1f}% |")
    return "\n".join(out)


def self_test():
    base = {
        "weeks": 4,
        "people": [{"name": "Ana"}, {"name": "Ben"}, {"name": "Cem", "share": 0.5, "cannot": ["Mow lawn"]}],
        "chores": [
            {"name": "Dishes", "minutes": 20, "times_per_week": 7},
            {"name": "Laundry", "minutes": 60, "times_per_week": 2},
            {"name": "Bathroom", "minutes": 45, "times_per_week": 1},
            {"name": "Vacuum", "minutes": 30, "times_per_week": 2},
            {"name": "Trash", "minutes": 5, "times_per_week": 3},
            {"name": "Mow lawn", "minutes": 50, "times_per_week": 1},
            {"name": "Feed cat", "minutes": 5, "times_per_week": 14, "only": ["Cem", "Ana"]},
        ],
    }
    res = plan(base)
    w1 = res["weeks"][0]["assignment"]
    lawn_never_cem = all(w["assignment"]["Mow lawn"] != "Cem" for w in res["weeks"])
    cat_ok = all(w["assignment"]["Feed cat"] in ("Cem", "Ana") for w in res["weeks"])
    dishes_people = {w["assignment"]["Dishes"] for w in res["weeks"]}
    overall = {r["name"]: r for r in res["overall"]}
    max_dev = max(abs(r["deviation_pct"]) for r in res["overall"])
    two = plan({"weeks": 2, "people": [{"name": "A"}, {"name": "B"}],
                "chores": [{"name": "X", "minutes": 10}, {"name": "Y", "minutes": 10}]})
    rotated = two["weeks"][0]["assignment"]["X"] != two["weeks"][1]["assignment"]["X"]
    orphan = plan({"weeks": 1, "people": [{"name": "A", "cannot": ["Z"]}], "chores": [{"name": "Z", "minutes": 5}]})
    errors = []
    for bad in ({"people": [], "chores": [{"name": "x", "minutes": 1}]},
                {"people": [{"name": "A"}, {"name": "A"}], "chores": [{"name": "x", "minutes": 1}]},
                {"people": [{"name": "A", "share": 0}], "chores": [{"name": "x", "minutes": 1}]},
                {"people": [{"name": "A"}], "chores": [{"name": "x", "minutes": 0}]},
                {"people": [{"name": "A"}], "chores": [{"name": "x", "minutes": 1, "only": ["Q"]}]}):
        try:
            plan(bad)
            errors.append(False)
        except PlanError:
            errors.append(True)
    cases = [
        ("all_chores_assigned_w1", len(w1), 7),
        ("weekly_minutes", weekly_minutes(base["chores"][0]), 140.0),
        ("cannot_respected", lawn_never_cem, True),
        ("only_respected", cat_ok, True),
        ("dishes_rotate", len(dishes_people) >= 2, True),
        ("half_share_lower_load", overall["Cem"]["minutes"] < overall["Ana"]["minutes"], True),
        ("overall_fair_within_25pct", max_dev <= 25.0, True),
        ("targets_sum_to_total", round(sum(r["target"] for r in res["overall"]), 0) == round(sum(r["minutes"] for r in res["overall"]), 0), True),
        ("equal_tie_rotates", rotated, True),
        ("orphan_reported", orphan["weeks"][0]["unassigned"], ["Z"]),
        ("bad_inputs_rejected", errors, [True] * 5),
        ("render_has_header", render(res).startswith("## Week 1"), True),
    ]
    failed = 0
    for name, got, expected in cases:
        ok = got == expected
        failed += not ok
        print(f"{'PASS' if ok else 'FAIL'}  {name}: got={got!r} expected={expected!r}")
    print(f"\n{len(cases) - failed}/{len(cases)} passed")
    return 1 if failed else 0


def main(argv=None):
    p = argparse.ArgumentParser(description="Plan a fair, rotating household chore schedule.")
    p.add_argument("input", nargs="?", help="JSON file with weeks, people, chores")
    p.add_argument("--weeks", type=int, help="override number of weeks")
    p.add_argument("--json", action="store_true")
    p.add_argument("--self-test", action="store_true")
    a = p.parse_args(argv)
    if a.self_test:
        return self_test()
    if not a.input:
        p.error("give an input JSON file, or --self-test")
    try:
        with open(a.input, encoding="utf-8") as fh:
            data = json.load(fh)
        if a.weeks:
            data["weeks"] = a.weeks
        res = plan(data)
    except (OSError, json.JSONDecodeError, PlanError, KeyError) as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    print(json.dumps(res, indent=2) if a.json else render(res))
    return 1 if any(w["unassigned"] for w in res["weeks"]) else 0


if __name__ == "__main__":
    sys.exit(main())

---
name: group-trip-expense-splitter
description: Chia các khoản chi phí chung cho một chuyến đi nhóm, ở ghép hoặc sự kiện: chia đều, chia theo nhóm nhỏ, chia theo trọng số hoặc chia số tiền chính xác, hỗ trợ nhiều loại tiền tệ với tỷ giá xác định và các khoản đã hoàn trả trước đó, tất cả đều tính bằng đơn vị xu nguyên (integer cents) để tổng số tiền luôn khớp hoàn toàn. Tạo bảng số dư của từng người và danh sách ngắn gọn "ai trả cho ai" (tối đa ít hơn tổng số người một giao dịch chuyển tiền). Sử dụng khi bạn bè hỏi "ai nợ ai bao nhiêu?" sau một chuyến đi hoặc một tháng ở ghép. Bao gồm công cụ chia tiền bằng thư viện chuẩn Python có hỗ trợ cờ --self-test.
---

# Công cụ Chia Chi phí Chuyến đi Nhóm

Bạn giúp một nhóm quyết toán các khoản chi phí chung một cách công bằng và không gây tranh cãi. Bạn thu thập thông tin về những gì đã mua, ai đã trả tiền và khoản chi đó dành cho ai, quy đổi tiền tệ theo tỷ giá đã thống nhất, tính toán số dư của từng người chính xác đến từng xu và đề xuất danh sách ngắn gọn các khoản thanh toán (không bao giờ vượt quá tổng số người trừ một) để mọi người đều sòng phẳng. Bạn giải thích rõ ràng mọi con số để bất kỳ ai trong nhóm cũng có thể kiểm tra lại.

## Các tệp trong kỹ năng này

- `scripts/split_expenses.py` - tính toán số tiền đã chi, phần phải đóng góp và số dư ròng của từng người cùng các giao dịch chuyển tiền quyết toán; hỗ trợ các mục chia đều (equal), chia trong nhóm nhỏ (among), chia theo phần/trọng số (shares), chia chính xác (exact) và chuyển trả trực tiếp (transfer_to) (chỉ sử dụng thư viện chuẩn Python 3)
- `references/splitting-rules.md` - cách chọn phương thức chia cho từng loại chi phí và xử lý các trường hợp ngoại lệ phổ biến
- `references/currency-and-rounding.md` - nên sử dụng tỷ giá hối đoái nào, phí thẻ và cách làm tròn số xu
- `templates/settle-up-summary.md` - bản tóm tắt để dán vào nhóm trò chuyện
- `examples/trip.json` - ví dụ chuyến đi cuối tuần của 4 người có một bữa tối có người vắng mặt, vé sinh viên, đồ uống tính theo số lượng, chi phí bằng USD và GBP, cùng một khoản hoàn trả bằng tiền mặt

## Quy trình thực hiện

### 1. Thu thập các khoản chi phí
Hỏi thông tin về: danh sách các thành viên, loại tiền tệ dùng để quyết toán, và đối với mỗi khoản chi phí: mô tả, số tiền, loại tiền tệ, người đã trả tiền và những người thụ hưởng khoản chi đó. Chấp nhận cả danh sách lộn xộn hoặc hóa đơn rồi chuyển đổi thành cấu trúc JSON như trong `examples/trip.json`. Hỏi về các khoản tiền đã trao tay trước đó (tiền mặt đưa trực tiếp, các khoản trả trước một phần) và ghi nhận chúng dưới dạng `transfer_to`.

### 2. Chọn cách chia cho từng khoản mục
Mặc định là chia đều cho tất cả mọi người. Sử dụng `among` cho các chi phí chỉ một số người tham gia, `shares` cho trường hợp "Jonas uống hai ly còn Maya uống một ly", và `exact` cho các hóa đơn tách riêng từng món. Xem `references/splitting-rules.md` và xác nhận lại các khoản mục chưa rõ ràng với nhóm thay vì tự đoán.

### 3. Thiết lập tỷ giá tiền tệ
Thống nhất một tỷ giá cho mỗi loại tiền tệ (tỷ giá trên sao kê thẻ hoặc tỷ giá công bố vào một ngày xác định) và đưa vào trường `rates` theo quy ước "1 đơn vị = X đơn vị tiền tệ quyết toán". Xem `references/currency-and-rounding.md`.

### 4. Chạy công cụ chia tiền
```
python3 scripts/split_expenses.py examples/trip.json
python3 scripts/split_expenses.py trip.json --json > settle.json
python3 scripts/split_expenses.py --self-test
```
Thoát với mã lỗi 2 kèm thông báo rõ ràng nếu gặp tên người lạ chưa khai báo, thiếu tỷ giá, số tiền âm hoặc các khoản chia chính xác (`exact`) có tổng không khớp với hóa đơn.

### 5. Chia sẻ kết quả
Điền vào mẫu `templates/settle-up-summary.md`: tổng chi tiêu, số tiền đã trả/phần đóng góp/số dư ròng của từng người, danh sách các giao dịch chuyển tiền và tỷ giá đã áp dụng. Giữ nội dung đủ ngắn gọn để gửi vào nhóm trò chuyện và đề nghị cung cấp bảng chi tiết toàn bộ chi phí nếu có người yêu cầu.

## Quy tắc

- Không bao giờ tự đoán xem những ai cùng chia sẻ một khoản chi phí; hãy hỏi lại, hoặc chia đều và nêu rõ điều đó.
- Tổng số tiền phải khớp chính xác đến từng xu; nêu rõ ai là người nhận các xu lẻ do làm tròn.
- Hiển thị rõ tỷ giá hối đoái và nguồn của chúng; không âm thầm tự tra cứu tỷ giá trực tuyến.
- Giữ thái độ trung lập: chỉ trình bày các con số, không đưa ra phán xét về việc ai tiêu nhiều hơn.
- Không xử lý thông tin xác thực thanh toán hoặc thực hiện chuyển tiền; chỉ liệt kê ai cần trả cho ai.
FILE:references/splitting-rules.md
# Quy tắc Chia tiền và Các Trường hợp Ngoại lệ

## Chọn phương thức chia
| Tình huống | Phương thức | Ví dụ |
|---|---|---|
| Tất cả mọi người đều sử dụng | equal (mặc định) | chỗ ở, thuê xe, mua đồ tạp hóa dùng chung |
| Chỉ một số người tham gia | `among` | bữa tối có một người không ăn, tour tham quan chỉ hai người đi |
| Mức độ sử dụng không đồng đều cho cùng một thứ | `shares` | đồ uống, số đêm lưu trú (3 đêm so với 2 đêm), tiền xăng theo quãng đường |
| Hóa đơn tách từng món hoặc mức giá khác nhau | `exact` | vé sinh viên so với vé người lớn, các món gọi riêng trên thực đơn |
| Tiền đã trao tay trước đó | `transfer_to` | tiền mặt trả lại, khoản chuyển khoản ngân hàng trong chuyến đi |

## Các trường hợp ngoại lệ
- **Có người đến muộn hoặc về sớm.** Sử dụng `shares` tính theo số đêm cho chi phí chỗ ở (ví dụ: 3, 3, 2, 3).
- **Cặp đôi hoặc gia đình gộp chung làm một đầu thanh toán.** Có thể liệt kê họ như một người duy nhất, hoặc giữ riêng từng người và chia cho trẻ em phần nhỏ hơn theo thỏa thuận của nhóm.
- **Tiền đặt cọc và hoàn tiền.** Số tiền phải luôn là số dương, vì vậy hãy trừ khoản tiền hoàn lại vào chi phí gốc ban đầu. Nếu tiền hoàn lại được chuyển cho một người khác không phải người trả tiền ban đầu, hãy thêm một mục `transfer_to` từ người trả tiền ban đầu sang người nhận tiền hoàn với đúng số tiền đó, để khoản tiền họ đang giữ được tính vào phần của họ.
- **Tiền boa (tips) và phí dịch vụ.** Chia theo đúng tỷ lệ của hóa đơn mà chúng đi kèm.
- **Quà tặng cho một thành viên (bữa tối sinh nhật).** Sử dụng `among` gồm tất cả mọi người ngoại trừ nhân vật chính được tặng.
- **Quỹ chung (shared kitty / common pot).** Coi người giữ quỹ là người trả tiền cho mọi thứ mua bằng quỹ đó và thêm mỗi khoản đóng góp vào quỹ dưới dạng một mục `transfer_to` chuyển cho người giữ quỹ.
- **Đồ dùng cá nhân nằm chung trong hóa đơn tập thể.** Tách hóa đơn thành hai mục: phần dùng chung (chia đều) và phần cá nhân (`exact` tính riêng cho người đó).

## Kiểm tra tính công bằng trước khi chia sẻ kết quả
1. Tổng phần đóng góp của tất cả mọi người bằng đúng tổng số tiền đã chi.
2. Mọi khoản chi phí đều có người trả tiền là thành viên thực sự tham gia.
3. Phần đóng góp của bất kỳ ai cũng không bao gồm những thứ họ đã từ chối rõ ràng từ trước.
4. Cả nhóm đã đồng thuận về tỷ giá và mọi khoản chia không đồng đều.
FILE:references/currency-and-rounding.md
# Tiền tệ và Làm tròn

## Chọn tỷ giá hối đoái
- **Tốt nhất:** tỷ giá trên sao kê thẻ hoặc ngân hàng của người trả tiền cho giao dịch đó, bao gồm cả phí giao dịch ngoại tệ (nếu có), vì đó là số tiền thực tế họ đã phải trả.
- **Đơn giản:** một tỷ giá công bố chung (ví dụ: tỷ giá tham chiếu của ngân hàng trung ương) vào một ngày xác định áp dụng cho toàn bộ chuyến đi.
- **Tiền mặt đổi tại quầy thu đổi ngoại tệ:** tỷ giá thực tế lúc mua số tiền mặt đó.
Viết tỷ giá theo dạng "1 đơn vị ngoại tệ = X đơn vị tiền tệ quyết toán": `"USD": 0.92` nghĩa là 1 USD = 0.92 EUR.

## Các loại phí
- Phí giao dịch ngoại tệ qua thẻ (thường từ 1-3%) là chi phí thực tế phát sinh của khoản mua sắm chung; hãy cộng chúng vào số tiền chi phí nếu cả nhóm đồng ý.
- Phí chuyển tiền khi quyết toán (phí chuyển khoản ngân hàng hoặc ứng dụng) thường do người gửi tự chịu.

## Làm tròn đến hàng xu (cent)
1. Mỗi khoản chi phí được quy đổi và làm tròn một lần (làm tròn nửa lên - half up) thành số xu nguyên.
2. Số tiền được chia theo trọng số; mỗi người nhận phần xu nguyên từ phần chia chính xác của mình.
3. Các xu lẻ còn dư (tối đa mỗi người một xu) sẽ được phân bổ cho những người có phần thập phân dư lớn nhất, nếu bằng nhau thì xét theo thứ tự bảng chữ cái của tên.
Cách này giúp mọi khoản chi phí đều khớp chính xác đến từng xu và kết quả luôn nhất quán khi chạy lại. Trong suốt một chuyến đi, chênh lệch làm tròn của mỗi người tối đa chỉ vài xu.

## Quyết toán bằng nhiều loại tiền tệ
Hãy quyết toán bằng một loại tiền tệ duy nhất nếu có thể. Nếu ai đó buộc phải thanh toán bằng một loại tiền tệ khác, hãy quy đổi khoản chuyển tiền cuối cùng của họ theo tỷ giá mà cả hai bên chấp nhận và ghi chú rõ trong bản tóm tắt.
FILE:templates/settle-up-summary.md
# Quyết toán chi phí - <tên chuyến đi hoặc sự kiện>

**Ngày:** <ngày tháng>  **Thành viên:** <danh sách tên>  **Tiền tệ quyết toán:** <loại tiền tệ>
**Tổng chi tiêu:** <số tiền> qua <n> khoản chi  **Tỷ giá áp dụng:** <1 USD = 0.92 EUR (sao kê thẻ), ...>

## Bảng số dư
| Thành viên | Đã chi | Phần đóng góp | Số dư ròng (+ được nhận lại / - cần trả thêm) |
|---|---|---|---|
| | | | |

## Ai trả cho ai
- <tên> trả cho <tên> <số tiền>
- <tên> trả cho <tên> <số tiền>

## Ghi chú
- Các khoản chia không đều: <bữa tối không có Leo, vé sinh viên, đồ uống tính theo số lượng>
- Xu lẻ làm tròn được tính vào phần của: <danh sách tên>
- Đã thanh toán trước trong chuyến đi: <tiền mặt hoặc chuyển khoản>

## Tin nhắn gửi nhóm trò chuyện
> Tổng kết chi phí chuyến đi đã có rồi đây! Chúng ta đã chi tổng cộng <total> cùng nhau. Để quyết toán: <transfer 1>; <transfer 2>; <transfer 3>. Bảng kê chi tiết nằm ở tin nhắn bên dưới. Nếu thấy có gì chưa chuẩn thì báo lại trước ngày <date> nhé.
FILE:examples/trip.json
{
  "trip": "Lisbon long weekend, 4 friends",
  "currency": "EUR",
  "rates": {"USD": 0.92, "GBP": 1.17},
  "people": ["Maya", "Jonas", "Priya", "Leo"],
  "expenses": [
    {"desc": "Apartment, 3 nights", "amount": 486.00, "paid_by": "Maya"},
    {"desc": "Airport taxi", "amount": 38.50, "paid_by": "Jonas"},
    {"desc": "Groceries for breakfasts", "amount": 61.27, "paid_by": "Priya"},
    {"desc": "Seafood dinner (Leo skipped)", "amount": 142.80, "paid_by": "Jonas", "among": ["Maya", "Jonas", "Priya"]},
    {"desc": "Sintra day tour, booked online", "amount": 196.00, "currency": "USD", "paid_by": "Leo"},
    {"desc": "Fado show (Priya and Leo have student tickets)", "amount": 84.00, "paid_by": "Maya", "exact": {"Maya": 25, "Jonas": 25, "Priya": 17, "Leo": 17}},
    {"desc": "Wine and pastel de nata tasting", "amount": 72.00, "paid_by": "Priya", "shares": {"Maya": 1, "Jonas": 2, "Priya": 1, "Leo": 2}},
    {"desc": "Tram and metro cards", "amount": 26.40, "currency": "GBP", "paid_by": "Leo"},
    {"desc": "Cash Jonas already handed Maya on day 2", "amount": 30.00, "paid_by": "Jonas", "transfer_to": "Maya"}
  ]
}
FILE:scripts/split_expenses.py
#!/usr/bin/env python3
"""Group trip expense splitter and settle-up planner (Python 3 standard library only).

Input JSON:
{
  "currency": "EUR",                         # settlement currency
  "rates": {"USD": 0.92, "TRY": 0.027},      # 1 unit of key = rate units of settlement currency
  "people": ["Ana", "Ben", "Cem", "Dee"],
  "expenses": [
    {"desc": "Villa", "amount": 1200, "paid_by": "Ana"},                                 # equal, everyone
    {"desc": "Dinner", "amount": 180, "paid_by": "Ben", "among": ["Ana", "Ben", "Cem"]},   # equal, subset
    {"desc": "Boat", "amount": 300, "currency": "USD", "paid_by": "Cem",
     "shares": {"Ana": 2, "Ben": 1, "Cem": 1}},                                         # weighted
    {"desc": "Museum", "amount": 54, "paid_by": "Dee", "exact": {"Dee": 18, "Ana": 36}},  # exact amounts
    {"desc": "Ana pays Ben back", "amount": 50, "paid_by": "Ana", "transfer_to": "Ben"}   # direct repayment
  ]
}
All math is done in integer cents. Rounding remainders go to participants in a fixed order (largest
fractional part first, then name), so totals always match to the cent and results are reproducible.
Settle-up uses a greedy largest-creditor / largest-debtor match, which needs at most n-1 transfers.

Usage:
  python3 split_expenses.py trip.json
  python3 split_expenses.py trip.json --json
  python3 split_expenses.py --self-test
Exit code: 0 OK, 2 bad input.
"""
import argparse
import json
import sys
from decimal import Decimal, ROUND_HALF_UP


class SplitError(ValueError):
    pass


def to_cents(amount, rate=Decimal(1)):
    try:
        d = Decimal(str(amount)) * Decimal(str(rate)) * 100
    except Exception:
        raise SplitError(f"bad amount {amount!r}")
    return int(d.quantize(Decimal(1), rounding=ROUND_HALF_UP))


def fmt(cents, cur):
    sign = "-" if cents < 0 else ""
    return f"{sign}{abs(cents) // 100:,}.{abs(cents) % 100:02d} {cur}"


def allocate(total, weights):
    """Split integer total by weights {name: weight}; largest-remainder method, ties by name."""
    wsum = sum(weights.values())
    if wsum <= 0:
        raise SplitError("weights must sum to more than zero")
    raw = {n: Decimal(total) * Decimal(str(w)) / Decimal(str(wsum)) for n, w in weights.items()}
    base = {n: int(v) for n, v in raw.items()}
    left = total - sum(base.values())
    order = sorted(weights, key=lambda n: (-(raw[n] - base[n]), n))
    for n in order[:left]:
        base[n] += 1
    return base


def compute(data):
    cur = data.get("currency") or "EUR"
    rates = {k.upper(): v for k, v in (data.get("rates") or {}).items()}
    people = data.get("people") or []
    if len(people) < 2:
        raise SplitError("need at least two people")
    if len(set(people)) != len(people):
        raise SplitError("duplicate names in people")
    known = set(people)
    paid = {p: 0 for p in people}
    owed = {p: 0 for p in people}
    lines = []
    for i, e in enumerate(data.get("expenses") or [], start=1):
        desc = e.get("desc") or f"expense {i}"
        payer = e.get("paid_by")
        if payer not in known:
            raise SplitError(f"{desc}: paid_by {payer!r} is not in people")
        ecur = (e.get("currency") or cur).upper()
        if ecur == cur.upper():
            rate = 1
        elif ecur in rates:
            rate = rates[ecur]
        else:
            raise SplitError(f"{desc}: no rate for {ecur} -> {cur}; add it to 'rates'")
        total = to_cents(e.get("amount"), rate)
        if total <= 0:
            raise SplitError(f"{desc}: amount must be positive")
        modes = [k for k in ("among", "shares", "exact", "transfer_to") if k in e]
        if len(modes) > 1:
            raise SplitError(f"{desc}: use only one of among / shares / exact / transfer_to")
        if "transfer_to" in e:
            to = e["transfer_to"]
            if to not in known or to == payer:
                raise SplitError(f"{desc}: transfer_to must be another person")
            split = {to: total}
        elif "exact" in e:
            ex = e["exact"]
            for n in ex:
                if n not in known:
                    raise SplitError(f"{desc}: unknown person {n!r}")
            split = {n: to_cents(v, rate) for n, v in ex.items()}
            diff = total - sum(split.values())
            if abs(diff) > len(split):  # allow only currency-conversion rounding
                raise SplitError(f"{desc}: exact amounts add up to {fmt(sum(split.values()), cur)}, not {fmt(total, cur)}")
            if diff:
                split[sorted(split)[0]] += diff
        elif "shares" in e:
            sh = e["shares"]
            for n, w in sh.items():
                if n not in known:
                    raise SplitError(f"{desc}: unknown person {n!r}")
                if float(w) < 0:
                    raise SplitError(f"{desc}: negative share for {n}")
            split = allocate(total, {n: w for n, w in sh.items() if float(w) > 0})
        else:
            among = e.get("among") or people
            for n in among:
                if n not in known:
                    raise SplitError(f"{desc}: unknown person {n!r}")
            split = allocate(total, {n: 1 for n in among})
        paid[payer] += total
        for n, c in split.items():
            owed[n] += c
        lines.append({"desc": desc, "paid_by": payer, "amount": total, "original": f"{e.get('amount')} {ecur}",
                      "split": split, "kind": modes[0] if modes else "equal"})
    net = {p: paid[p] - owed[p] for p in people}
    assert sum(net.values()) == 0, "internal error: balances do not sum to zero"
    return {"currency": cur, "people": people, "expenses": lines, "paid": paid, "owed": owed,
            "net": net, "transfers": settle(net),
            "total_spent": sum(l["amount"] for l in lines if l["kind"] != "transfer_to")}


def settle(net):
    cred = sorted([[c, n] for n, c in net.items() if c > 0], key=lambda x: (-x[0], x[1]))
    debt = sorted([[-c, n] for n, c in net.items() if c < 0], key=lambda x: (-x[0], x[1]))
    out = []
    while cred and debt:
        amt = min(cred[0][0], debt[0][0])
        out.append({"from": debt[0][1], "to": cred[0][1], "amount": amt})
        cred[0][0] -= amt
        debt[0][0] -= amt
        cred = sorted([x for x in cred if x[0] > 0], key=lambda x: (-x[0], x[1]))
        debt = sorted([x for x in debt if x[0] > 0], key=lambda x: (-x[0], x[1]))
    return out


def to_markdown(r):
    c = r["currency"]
    lines = ["# Trip settle-up", "", f"Total spent: {fmt(r['total_spent'], c)} across {len([e for e in r['expenses'] if e['kind'] != 'transfer_to'])} expenses", "",
             "## Expenses", "| # | Expense | Paid by | Amount | Split |", "|---|---|---|---|---|"]
    for i, e in enumerate(r["expenses"], 1):
        split = ", ".join(f"{n} {fmt(v, c)}" for n, v in sorted(e["split"].items()))
        conv = "" if e["original"].endswith(c.upper()) else f" ({e['original']})"
        lines.append(f"| {i} | {e['desc']} | {e['paid_by']} | {fmt(e['amount'], c)}{conv} | {e['kind']}: {split} |")
    lines += ["", "## Balances", "| Person | Paid | Share | Net |", "|---|---|---|---|"]
    for p in r["people"]:
        lines.append(f"| {p} | {fmt(r['paid'][p], c)} | {fmt(r['owed'][p], c)} | {fmt(r['net'][p], c)} |")
    lines += ["", "## Who pays whom"]
    if not r["transfers"]:
        lines.append("Everyone is even.")
    lines += [f"- {t['from']} pays {t['to']} {fmt(t['amount'], c)}" for t in r["transfers"]]
    return "\n".join(lines)


def self_test():
    cases = []

    def ok(name, cond):
        cases.append((name, bool(cond)))

    base = {"currency": "EUR", "people": ["Ana", "Ben", "Cem"]}
    r = compute(dict(base, expenses=[{"desc": "Taxi", "amount": 10, "paid_by": "Ana"}]))
    ok("10.00 split three ways sums exactly", sum(r["owed"].values()) == 1000 and sorted(r["owed"].values()) == [333, 333, 334])
    ok("remainder cent goes to first name on tie", r["owed"]["Ana"] == 334)
    ok("two transfers to the payer", sorted((t["from"], t["amount"]) for t in r["transfers"]) == [("Ben", 333), ("Cem", 333)])
    r = compute(dict(base, expenses=[{"desc": "A", "amount": 30, "paid_by": "Ana"}, {"desc": "B", "amount": 30, "paid_by": "Ben"}, {"desc": "C", "amount": 30, "paid_by": "Cem"}]))
    ok("equal spending means no transfers", r["transfers"] == [])
    r = compute(dict(base, expenses=[{"desc": "Dinner", "amount": 90, "paid_by": "Ben", "among": ["Ana", "Ben"]}]))
    ok("subset split excludes others", r["owed"]["Cem"] == 0 and r["net"]["Ana"] == -4500)
    r = compute(dict(base, expenses=[{"desc": "Boat", "amount": 100, "paid_by": "Cem", "shares": {"Ana": 2, "Ben": 1, "Cem": 1}}]))
    ok("weighted shares", r["owed"] == {"Ana": 5000, "Ben": 2500, "Cem": 2500})
    r = compute(dict(base, expenses=[{"desc": "Tickets", "amount": 50, "paid_by": "Ana", "exact": {"Ben": 20, "Cem": 30}}]))
    ok("exact amounts", r["net"] == {"Ana": 5000, "Ben": -2000, "Cem": -3000})
    r = compute(dict(base, rates={"USD": 0.9}, expenses=[{"desc": "Gas", "amount": 30, "currency": "USD", "paid_by": "Ben"}]))
    ok("currency conversion to cents", r["paid"]["Ben"] == 2700 and sum(r["owed"].values()) == 2700)
    r = compute(dict(base, expenses=[{"desc": "Hotel", "amount": 300, "paid_by": "Ana"}, {"desc": "Payback", "amount": 100, "paid_by": "Ben", "transfer_to": "Ana"}]))
    ok("direct repayment reduces debt", r["net"] == {"Ana": 10000, "Ben": 0, "Cem": -10000})
    ok("repayment not counted as spending", r["total_spent"] == 30000)
    big = {"currency": "EUR", "people": ["A", "B", "C", "D", "E"],
           "expenses": [{"desc": f"x{i}", "amount": 17.33 * (i + 1), "paid_by": "ABCDE"[i % 5], "among": list("ABCDE"[: 2 + i % 4])} for i in range(12)]}
    r = compute(big)
    ok("balances sum to zero", sum(r["net"].values()) == 0)
    ok("at most n-1 transfers", len(r["transfers"]) <= 4)
    after = dict(r["net"])
    for t in r["transfers"]:
        after[t["from"]] += t["amount"]
        after[t["to"]] -= t["amount"]
    ok("transfers settle everyone to zero", all(v == 0 for v in after.values()))
    ok("deterministic output", compute(big)["transfers"] == r["transfers"])
    bad_inputs = [
        (dict(base, expenses=[{"desc": "X", "amount": 10, "paid_by": "Zed"}]), "unknown payer rejected"),
        (dict(base, expenses=[{"desc": "X", "amount": 10, "currency": "GBP", "paid_by": "Ana"}]), "missing rate rejected"),
        (dict(base, expenses=[{"desc": "X", "amount": 10, "paid_by": "Ana", "exact": {"Ben": 3}}]), "exact mismatch rejected"),
        (dict(base, expenses=[{"desc": "X", "amount": -5, "paid_by": "Ana"}]), "negative amount rejected"),
        ({"people": ["Solo"], "expenses": []}, "single person rejected"),
    ]
    for data, label in bad_inputs:
        try:
            compute(data)
            ok(label, False)
        except SplitError:
            ok(label, True)
    ok("markdown has settle-up section", "## Who pays whom" in to_markdown(compute(dict(base, expenses=[{"desc": "Taxi", "amount": 10, "paid_by": "Ana"}]))))
    passed = sum(c for _, c in cases)
    for name, c in cases:
        print(("PASS " if c else "FAIL ") + name)
    print(f"{passed}/{len(cases)} passed")
    return 0 if passed == len(cases) else 1


def main(argv=None):
    ap = argparse.ArgumentParser(description="Split shared trip expenses and plan a short list of settle-up transfers.")
    ap.add_argument("file", nargs="?", help="trip JSON file, or '-' for stdin")
    ap.add_argument("--json", action="store_true")
    ap.add_argument("--self-test", action="store_true")
    a = ap.parse_args(argv)
    if a.self_test:
        return self_test()
    if not a.file:
        ap.error("trip JSON required (or --self-test)")
    try:
        data = json.load(sys.stdin if a.file == "-" else open(a.file, encoding="utf-8"))
        r = compute(data)
    except (OSError, ValueError) as e:
        print(f"error: {e}", file=sys.stderr)
        return 2
    print(json.dumps(r, indent=2, ensure_ascii=False) if a.json else to_markdown(r))
    return 0


if __name__ == "__main__":
    sys.exit(main())