feat(801-3): 수식 탭 소계 · 합계 묶음 다시 — 돈 묶음 하나 = 머리 없음 · 계 / 둘 이상 = 소계 / 단가산출 둘 이상 = 합계 · 안쪽 말 0

- 묶음 한 곳 master_equation_group.bundles: 부른 · 더한 단가산출 하나씩 + 직접 줄(인력 · 재료 · 기계 · 덧줄) 한 묶음 · 돈 없는 줄 · 뺀 줄 = 묶음 아님 · 합계 밖 줄 = 밖 글
- M01 subtotals · M02 M02_Sangeun_Equation_Full 같은 꼴 · 끝수 셈 그대로 · 금액 전후 같음
- 부품 ui_template_equation_sum: 자기 자원 · 덧줄 글 0 · 묶음 하나 = 머리 없음 · 계 · 둘 이상 = 가. 머리 · 소 계 · 단가산출 둘 이상 = 합계
- 옛 시험 기대 고침: test_799_1(갈래 자원 · 덧줄 → 직접 한 묶음) · test_796_2c(줄마다 한 행 → 묶음 · 낱줄 · 밖) — 묶음 꼴이 바뀜
- 새 test_801_3_groups 5

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>

resources/master_data/scripts/master_equation.py

@@ -28,6 +28,7 @@ from pathlib import Path
 
 import master_auto as ma
 import master_cut as mcut
+import master_equation_group as grp
 import master_equation_view as view
 import master_formula as mf
 import master_material as mm
@@ -401,36 +402,30 @@ def _line(ctx: _Ctx, kind: str, key: str, text: str, value, **more) -> dict:
 
 
 def subtotals(logic: dict, cut: dict, total: dict) -> dict:
-    """호표 줄 → 소계(799-1 · 보이기만) — 하위 로직 줄 = 블록마다 · 그 밖 자원 · 덧줄은 한 줄씩 + 끝수.
+    """호표 줄 → 소계 묶음(799-1 · 801-3 · 보이기만) — 부른 단가산출 = 묶음 하나씩 · 직접 줄 = 한 묶음 + 끝수.
 
     값 = `master_cut.engine` 이 버린 줄 비목(0.1 원) 그대로 · 합계 = 엔진 비목 합(1 원 버림) ·
-    끝수 = 합계 − 줄 합(금액 셈은 안 바꿈 · 사용자 확정 뒤에 정함).
+    끝수 = 합계 − 묶음 합(금액 셈은 안 바꿈 · 사용자 확정 뒤에 정함). 묶음 꼴 = `master_equation_group`.
     """
-    items, adds = logic.get("호표") or [], logic.get("덧줄") or []
+    items = logic.get("호표") or []
     skip = mcut.ms.skipped(logic) if mcut.ms.uses(logic) else set()
     rows: list[dict] = []
-    pool: dict[str, dict] = {}
     for n, line in enumerate(cut.get("줄") or []):
         if n in skip:
             continue
         split = {k: line.get("비목", {}).get(k) or Decimal(0) for k in mf.COST_ITEMS}
-        if n < len(items) and items[n].get("종류") == "로직":
-            rows.append({"갈래": "블록", "이름": str(items[n].get("이름") or ""), **split})
-            continue
-        kind = "덧줄" if n >= len(items) else "자원"
-        one = pool.setdefault(
-            kind, {"갈래": kind, "이름": kind, **dict.fromkeys(mf.COST_ITEMS, Decimal(0))}
+        item = items[n] if n < len(items) else {}
+        kind = "블록" if item.get("종류") == "로직" else "자원" if item else "덧줄"
+        rows.append(
+            {"갈래": kind, "이름": str(item.get("이름") or ""), "종류": item.get("종류"), **split}
+            | {"계": sum(split.values(), Decimal(0))}
         )
-        for k in mf.COST_ITEMS:
-            one[k] += split[k]
-    rows += [pool[k] for k in ("자원", "덧줄") if k in pool]
-    for one in rows:
-        one["계"] = sum((one[k] for k in mf.COST_ITEMS), Decimal(0))
+    got = grp.bundles(rows)
     rest = {
-        k: (total.get(k) or Decimal(0)) - sum((one[k] for one in rows), Decimal(0))
+        k: (total.get(k) or Decimal(0)) - sum((one[k] for one in got["줄"]), Decimal(0))
         for k in mf.BUNDLE
     }
-    return {"줄": rows, "끝수": rest}
+    return {"줄": got["줄"], "끝수": rest}
 
 
 def export(master, key: str, given: dict | None = None, depth: int = 0) -> dict:

resources/master_data/scripts/master_equation_group.py

@@ -0,0 +1,68 @@
+"""수식 탭 소계 묶음(PLAN 801-3 · 요구 662-3) — 돈 묶음 한 곳 · M01(`master_equation`) · M02(`M02_Sangeun_Equation_Full`) 같은 꼴.
+
+묶음 = 부른 · 더한 단가산출(갈래 블록) 하나씩 + 직접 줄(인력 · 재료 · 기계 · 덧줄 · 율) 전부 한 묶음(갈래 직접).
+돈 없는 줄(계 0 · 바탕) · 뺀 줄 = 묶음 아님(식 줄로만 보임) · 합계 밖 줄 = `밖` 으로만.
+머리 · 소계 · 합계 · 계 글자 판정 = 화면 부품(`ui_template_equation_sum.ts`) — 묶음 둘 이상 = 머리 · 소계 ·
+단가산출(블록) 둘 이상 = 합계 · 아니면 계.
+시험 `resources/tester/test_801_3_groups.py`.
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+
+COSTS = ("노무비", "재료비", "경비")
+_WORDS = ("인력", "재료", "기계")  # 직접 묶음 이름 차례
+
+
+def _zero(row: dict) -> bool:
+    """돈 없는 바탕 줄 · 뺀 줄 — 묶음 아님."""
+    if row.get("상태") == "뺌":
+        return True
+    return row["계"] == 0 and row.get("상태") in (None, "바탕")
+
+
+def _name(direct: list[dict]) -> str:
+    """직접 묶음 이름 — 자원 갈래 말(인력 · 재료 · 기계) · 율 줄 = 이름 (율 %) · 덧줄뿐 = 비목 말."""
+    words = [w for w in _WORDS if any(r.get("종류") == w for r in direct)]
+    words += [
+        f"{r['이름']} ({r['수량']}%)" if r.get("수량") not in (None, "") else str(r["이름"])
+        for r in direct
+        if r["갈래"] == "율"
+    ]
+    if not words:
+        words = [k for k in COSTS if any(r[k] != 0 for r in direct)]
+    return " · ".join(words)
+
+
+def bundles(rows: list[dict]) -> dict:
+    """줄(갈래 블록 | 자원 | 덧줄 | 율 · 비목 칸 · 계) → `{줄: 묶음들, 밖: 합계 밖 줄들}` — 금액은 더하기만(셈 안 바꿈)."""
+    blocks: list[dict] = []
+    direct: list[dict] = []
+    out: list[dict] = []
+    for row in rows:
+        if row.get("합밖"):
+            out.append({"이름": row["이름"], "밖금액": row.get("밖금액")})
+        elif _zero(row):
+            continue
+        elif row["갈래"] == "블록":
+            blocks.append(row)
+        else:
+            direct.append(row)
+    lines = list(blocks)
+    if direct:
+        one = {
+            "갈래": "직접",
+            "이름": _name(direct),
+            **{k: sum((r[k] for r in direct), Decimal(0)) for k in COSTS},
+        }
+        one["계"] = sum((one[k] for k in COSTS), Decimal(0))
+        mine = [  # 더한 · 덮은 줄 — 묶음 속에 한 줄씩(고친 줄을 숨기지 않음)
+            {k: r[k] for k in ("이름", "상태", "계", "원래") if r.get(k) is not None}
+            for r in direct
+            if r.get("상태") in ("더함", "덮음")
+        ]
+        if mine:
+            one["낱줄"] = mine
+        lines.append(one)
+    return {"줄": lines, "밖": out}