Merge remote-tracking branches 'origin/main_laptop_1', 'origin/sub_laptop_1', 'origin/sub_laptop_5' and 'origin/sub_laptop_7' into sub_laptop_8

resources/tester/spreadsheet/test_stage2_autofit.ts

@@ -1,10 +1,11 @@
 /* =============================================================================
- * test_stage2_autofit.ts — spreadsheet_autofit 시험. 돌리기: node --experimental-strip-types <이 파일>
+ * test_stage2_autofit.ts — spreadsheet_autofit 시험. 돌리기: esbuild --bundle --platform=node <이 파일> → node (주소 import 가 확장자 없음)
  * ========================================================================== */
 
 import {
   autofitColumn,
   estimateColumnWidth,
+  fillMissingWidths,
 } from "../../../A00_Common/spreadsheet/spreadsheet_autofit.ts";
 import { assertEqual, makeBook, makeCtx, makeSheet, v } from "./test_stage2_helpers.ts";
 
@@ -28,5 +29,23 @@ assertEqual(sheet.열?.A.폭, widthA, "autofitColumn 이 열폭 명령으로 반
 const fixedWidth = estimateColumnWidth(book, "s1", 0, () => 7);
 assertEqual(fixedWidth, 9, "measure 를 넘기면 그걸로 어림(7 + 여백 2)");
 
+// 741 — 폭 없는 열만 글 길이로 채움(최소 · 최대) · 있는 폭 · 여러 열 병합(제목) 칸은 그대로 · 뺌
+const longText = "가".repeat(80);
+const sheet741 = makeSheet("s2", {
+  A1: v("제목 한 줄이 매우 길어도 병합이라 뺌 ".repeat(5)),
+  A2: v("짧음"),
+  B1: v(longText),
+  C1: v("x"),
+  D1: v("이미 있음"),
+});
+sheet741.병합 = ["A1:D1"];
+sheet741.열 = { D: { 폭: 33 } };
+const book741 = makeBook([sheet741]);
+fillMissingWidths(book741);
+assertEqual(sheet741.열.D.폭, 33, "있는 폭은 그대로");
+assertEqual(sheet741.열.B.폭, 60, "너무 긴 글은 최대 60");
+assertEqual(sheet741.열.C.폭, 6, "짧은 글은 최소 6");
+assertEqual(sheet741.열.A.폭 < 20, true, "병합 제목 칸은 폭에서 뺌");
+
 if (process.exitCode) process.exit(process.exitCode);
 console.log("spreadsheet_autofit 시험 끝");

resources/tester/test_721_find_pick.py

@@ -63,7 +63,7 @@ def test_721_2_부르는_곳_셋만_새_창():
 def test_721_2_고정_줄_꼴():
     find = _text(M02 / "M02_MasterTemplete_Find_Pick.ts")
     assert "이음: { 노임: labor ? e.코드 : null, 자재: labor ? null : e.코드, 기계: null }" in find
-    assert "go: put ? take(() => put(e))" in find
+    assert "take(() => put(e))" in find and "!put" in find
     assert "dim: !put," in find  # 받는 쪽 없으면 회색 막힘
 
 
@@ -151,3 +151,42 @@ def test_736_2_빠진_길_둘_신규_자재_기계_탭():
     assert '"machine"' in lost and "pickMachine" not in lost
     unlinked = _text(M02 / "M02_MasterTemplete_Labor_Unlinked.ts")
     assert 'machine: (e) => done("기계", e.코드)' in unlinked and "pickMachine" not in unlinked
+
+
+def test_736_3_기계_고정_줄_금액():
+    """736-3 — [항목 추가] 기계(EQ) = 고정 줄(이음 기계 · 단가 = 한 시간 노 · 재 · 경) — 단가산출 · 일위대가가 같은 금액."""
+    from M02_MasterTemplete import M02_Machine_Hourly as machine
+
+    EQ = "EQ000019"  # 굴착기(무한궤도) 0.6㎥
+    got = machine.hourly(EQ)
+    assert got["ok"] and got["계"] > 0
+    assert got["계"] == pytest.approx(got["노무비"] + got["재료비"] + got["경비"])
+    assert not machine.hourly(LB)["ok"] and not machine.hourly("EQ999999")["ok"]
+    fx = {
+        "이름": got["이름"],
+        "규격": got["규격"],
+        "단위": "시간",
+        "단가": {k: got[k] for k in ("노무비", "재료비", "경비")},
+        "이음": {"노임": None, "자재": None, "기계": EQ},
+    }
+    sk = calc.calc_doc(
+        {
+            "키": "SK-000001",
+            "이름": "시험",
+            "단위": "시간",
+            "바탕": None,
+            "더한줄": [{"고정": fx, "이름": got["이름"], "단위": "시간", "수량": 1}],
+        }
+    )["1단위"]
+    doc = labor.clean({"담은로직": [{"로직": "", "고정": fx, "수량": {"손": 1}}]})
+    assert sk["계"] == pytest.approx(got["계"])
+    assert labor.calc(doc, {})["반영합"]["계"] == pytest.approx(got["계"])
+    find = _text(M02 / "M02_MasterTemplete_Find_Pick.ts")
+    assert (
+        "/logic-lib/machine-hourly?key=" in find
+        and "이음: { 노임: null, 자재: null, 기계: e.코드 }" in find
+    )
+    assert "machine: fixed &&" in _text(M02 / "M02_MasterTemplete_Labor_Pick.ts")
+    assert "machine: (e) => done({ 고정: fixedOf(e)" in _text(
+        M02 / "M02_MasterTemplete_Sangeun_Pick.ts"
+    )

resources/tester/test_739_1_alias_central.py

@@ -0,0 +1,147 @@
+"""별칭 장부 중앙 관리(PLAN 739-1 · `M02_Hopyo_Ledger` · `M02_Hopyo_Line` ·
+`M01_MasterData_Alias`) — 자동 짝 = 마스터(승인) · 이 불러오기에서 이은 짝만 · 회사 · 개인 층 짝 =
+「내 제안」(자동 0 · 꼬리표 · 고르기 맨 위 `제안`) · 이은 짝 → 층 장부(불러오기 표시) → M01 후보 ·
+승인 뒤 다음 불러오기 자동 · 장부 화면 승인 상태(대기 · 승인 · 반려) · master_data 원본 그대로.
+층 · storage 는 임시 폴더.
+"""
+
+from M01_MasterData import M01_MasterData_Alias as alias
+from M02_MasterTemplete import M02_Hopyo_Fit as fit
+from M02_MasterTemplete import M02_Hopyo_Ledger as ledger
+from M02_MasterTemplete import M02_Hopyo_Store as hs
+from M02_MasterTemplete import M02_Template_Layers as layers
+
+# 올리기 길 시험의 `client` 마당(임시 storage · 마스터 층)을 같이 씀
+# ruff: noqa: F811
+from resources.tester.test_m02_hopyo_excel import URL, _post, client, master_hash  # noqa: F401
+
+DIG = {"이름": "구조물터파기(인력100%)", "규격": "토사", "단위": "㎥"}
+DIG_KEY = "구조물터파기(인력100%)|토사|m3"
+WHO = {"id": 42, "이름": "갑"}
+ADMIN = {"id": 1, "이름": "관리자"}
+LEDGER = "/api/m02/layers/{}/hopyo-ledger"
+FROM_LEDGER = ("별칭", "뺌")  # 장부가 자동으로 정한 줄 상태
+
+
+def _pair(code):
+    return ledger.check(DIG_KEY, {"갈래": "짝", "짝": [{"로직": code, "배": 1}]})
+
+
+def _candidate(key, code):
+    got = [
+        x
+        for x in alias.gather()["후보"]
+        if x["열쇠"] == key and x["종류"] == alias.ALIAS and x["짝"][0]["로직"] == code
+    ]
+    assert len(got) == 1, got
+    return got[0]
+
+
+def test_장부_층_짝은_제안_이_불러오기_짝은_자동_승인_뒤_모두_자동(client):
+    before = master_hash()
+    mine = layers.personal_dir(7, 42)
+    here = ledger.doc_id(mine, "HP-000001")
+    assert here == "personal/7/42/HP-000001"
+    ledger.write(mine, {DIG_KEY: _pair("GF000101")}, WHO, "가.xls", here)
+    got = ledger.recall(DIG, mine, doc=here)
+    assert (got["층"], got["제안"]) == ("personal", False)  # 이 불러오기에서 이은 짝 = 바로 씀
+    later = ledger.doc_id(mine, "HP-000002")  # 다음 불러오기
+    for doc in (later, None):
+        got = ledger.recall(DIG, mine, doc=doc)
+        assert (got["층"], got["짝"][0]["로직"], got["제안"]) == ("personal", "GF000101", True)
+    ledger.put(mine, {DIG_KEY: {**_pair("GF000101"), "엑셀조항": []}}, WHO)  # 장부 화면 고침
+    assert ledger.read(mine)[DIG_KEY]["불러오기"] == here  # 이은 불러오기 표시는 남음
+    assert [r["상태"] for r in ledger.rows(mine, True)] == ["대기"]
+    # M01 후보에 보임 → 승인 → 마스터 → 다음 불러오기 · 다른 회사 새 사용자도 자동
+    sig = _candidate(DIG_KEY, "GF000101")["서명"]
+    alias.approve(alias.ALIAS, DIG_KEY, sig, ADMIN)
+    for folder, doc in ((mine, later), (layers.personal_dir(9, 99), None)):
+        got = ledger.recall(DIG, folder, doc=doc)
+        assert (got["층"], got["짝"][0]["로직"], got["제안"]) == ("system", "GF000101", False)
+    assert [(r["층"], r["상태"]) for r in ledger.rows(mine, True)] == [
+        ("personal", "승인"),
+        ("system", "승인"),
+    ]
+    # 다른 짝 제안 → 반려 = 상태 반려 · 여전히 내 제안(자동 아님)
+    other = layers.personal_dir(7, 43)
+    ledger.write(other, {DIG_KEY: _pair("GF000103")}, {"id": 43}, "나.xls")
+    alias.reject(alias.ALIAS, DIG_KEY, _candidate(DIG_KEY, "GF000103")["서명"], ADMIN)
+    assert ledger.rows(other, True)[0]["상태"] == "반려"
+    got = ledger.recall(DIG, other)
+    assert (got["층"], got["짝"][0]["로직"]) == ("system", "GF000101")  # 자동 = 마스터
+    assert master_hash() == before
+
+
+def _hopyo(client, no):
+    res = client.get(f"{URL.format('personal')}/HP-000001/{no}")
+    assert res.status_code == 200, res.text
+    return res.json()["호표"]
+
+
+def _lines(client, no):
+    return {one["이름"]: one["맞춤"] for one in _hopyo(client, no)["줄"]}
+
+
+def _auto(client, no):
+    """장부가 자동으로 정한 줄 수."""
+    return sum(1 for m in _lines(client, no).values() if m["상태"] in FROM_LEDGER)
+
+
+def test_불러오기_내_제안_후보_이은_짝_승인_흐름(client):
+    before = master_hash()
+    assert _post(client).status_code == 200
+    mine = layers.personal_dir(7, 42)
+    fit.run_job(mine, "HP-000001")
+    plain = _lines(client, 3)["구조물터파기(인력100%)"]
+    assert plain["상태"] not in FROM_LEDGER and "제안" not in plain
+    # 개인 층 장부 짝(옛 층 장부 · 승인 전) = 자동 0 · 꼬리표 「내 제안」 · 고르기 맨 위 `제안`
+    row = {"갈래": "짝", "짝": [{"로직": "GC000083", "배": 1}]}
+    res = client.put(LEDGER.format("personal"), json={"줄": {DIG_KEY: row}})
+    assert res.status_code == 200, res.text
+    assert _auto(client, 3) == 0
+    got = _lines(client, 3)["구조물터파기(인력100%)"]
+    assert (got["상태"], got["체크"]) == (plain["상태"], plain["체크"])  # 숫자 판정 그대로
+    assert "내 제안" in got["꼬리표"] and "별칭" not in got
+    assert got["제안"]["짝"][0]["로직"] == "GC000083" and got["제안"]["층"] == "personal"
+    assert got["제안"]["대상"][0]["로직"] == "GC000083"
+    # 확인하고 만들기 = 이은 짝 → 이 불러오기 안에서는 바로 자동 · 층 장부(제안)에 불러오기 표시
+    hopyo = _hopyo(client, 3)
+    at = next(x["차례"] for x in hopyo["줄"] if x["이름"] == "구조물터파기(인력100%)")
+    body = {"층": "personal", "키": "HP-000001", "번": 3}
+    lines = [{"차례": at, "대상": [{"로직": "GC000083", "입력값": {}, "배": 1}]}]
+    left = client.post(
+        "/api/m02/layers/personal/hopyo-unlinked", json={**body, "줄": lines}
+    ).json()["남은줄"]
+    lines += [{"차례": x["차례"], "뺌": "우리에 없음"} for x in left]
+    res = client.post("/api/m02/layers/personal/hopyo-build", json={**body, "줄": lines})
+    assert res.status_code == 200, res.text
+    book = ledger.read(mine)
+    assert book[DIG_KEY]["불러오기"] == "personal/7/42/HP-000001"
+    got = _lines(client, 3)["구조물터파기(인력100%)"]
+    assert got["상태"] == "별칭" and got["별칭"]["층"] == "personal"
+    # 다음 불러오기(다른 HP) = 승인 전 자동 0
+    nxt = {k: {**v, "불러오기": "personal/7/42/HP-000009"} for k, v in book.items()}
+    hs.remember(mine, nxt)  # 장부 파일 그대로 — 다른 불러오기에서 이은 짝
+    assert _auto(client, 3) == 0
+    # M01 후보에 보임 → 승인 → 다음 불러오기 자동(마스터)
+    sig = _candidate(DIG_KEY, "GC000083")["서명"]
+    alias.approve(alias.ALIAS, DIG_KEY, sig, ADMIN)
+    got = _lines(client, 3)["구조물터파기(인력100%)"]
+    assert got["상태"] == "별칭" and got["별칭"]["층"] == "system" and "제안" not in got
+    assert _auto(client, 3) == 1
+    assert master_hash() == before
+
+
+def test_화면_내_제안_글():
+    """고르기 창 맨 위 「내 제안」(한 번 눌러 짝 통째) · 장부 화면 = 내 제안 목록 · 승인 칸."""
+    from pathlib import Path
+
+    m02 = Path(__file__).resolve().parents[2] / "M02_MasterTemplete"
+    choose = (m02 / "M02_MasterTemplete_Hopyo_Choose.ts").read_text(encoding="utf-8")
+    assert choose.index("...(mineRow ? [mineRow] : [])") < choose.index("...sections")
+    assert '"data-group": "내 제안"' in choose and "mine.짝.map((p)" in choose
+    rows = (m02 / "M02_MasterTemplete_Hopyo_CheckRows.ts").read_text(encoding="utf-8")
+    assert '"고르기 · 내 제안"' in rows
+    book = (m02 / "M02_MasterTemplete_Hopyo_Ledger.ts").read_text(encoding="utf-8")
+    assert 'MINE_TITLE = "내 제안 목록"' in book and '"승인",' in book
+    assert "createBadge(r.상태, STATE_TONE[r.상태])" in book

resources/tester/test_741_sheet_widths.py

@@ -0,0 +1,49 @@
+"""741-1 지킴 — 일위대가 엑셀 보기 열 폭: xlsx 도 파일 열 폭을 서버가 보냄 · 열 끌기 · 두 번 눌러
+맞춤은 읽기 전용에서도 열림(화면 수치 판정은 tmp 일회 검증)."""
+
+import io
+from pathlib import Path
+
+import openpyxl
+
+from M02_MasterTemplete import M02_Hopyo_Grid as grid
+
+ROOT = Path(__file__).parents[2]
+SS = ROOT / "A00_Common/spreadsheet"
+
+
+def _xlsx(widths: dict[str, float]) -> bytes:
+    wb = openpyxl.Workbook()
+    ws = wb.active
+    ws.title = "일위대가"
+    ws["A1"] = "x"
+    for letter, width in widths.items():
+        ws.column_dimensions[letter].width = width
+    ws.column_dimensions["E"].hidden = True
+    out = io.BytesIO()
+    wb.save(out)
+    return out.getvalue()
+
+
+def test_xlsx_widths_read_from_cols():
+    got = grid._xlsx_widths(_xlsx({"A": 30, "C": 12.5}))["일위대가"]
+    assert got["A"] == {"폭": 30.0} and got["C"] == {"폭": 12.5}
+    assert got["E"].get("숨김") is True
+
+
+def test_xlsx_without_widths_is_empty_and_garbage_is_safe():
+    assert grid._xlsx_widths(_xlsx({}))["일위대가"].keys() <= {"E"}
+    assert grid._xlsx_widths(b"not a zip") == {}
+
+
+def test_xlsx_sheet_carries_widths():
+    data = _xlsx({"A": 30})
+    sheets = grid._xlsx("a.xlsx", data)["시트"]
+    assert sheets and sheets[0]["열"]["A"]["폭"] == 30.0
+
+
+def test_readonly_still_resizes_columns():
+    spread = (SS / "spreadsheet.ts").read_text(encoding="utf-8")
+    assert 'readOnly && command.종류 !== "열폭"' in spread
+    mouse = (SS / "spreadsheet_mouse.ts").read_text(encoding="utf-8")
+    assert 'ctx.readOnly && hit.kind !== "colEdge"' in mouse

resources/tester/test_m02_hopyo_ledger.py

@@ -1,5 +1,5 @@
 """일위대가 실무자료 별칭 장부(PLAN 338-3 · `M02_Hopyo_Ledger`) — 옛 꼴 바꿔 읽음 · 새 꼴 ·
-층 차례(아래 층이 이김) · 느슨 찾기(규격다름) · 우리에 없음 · 안 씀 · 호표 통째 열쇠 ·
+층 차례(739-1 자동 = 마스터 · 이 불러오기 짝 · 아래 층 = 제안) · 느슨 찾기(규격다름) · 우리에 없음 · 안 씀 · 호표 통째 열쇠 ·
 위 층 읽기만 · 재검사 · 쓰기(처음파일 둠 · 옛 꼴 새로 씀) · master_data 원본 그대로. 층은 임시 폴더.
 """
 
@@ -65,21 +65,26 @@ def test_옛_꼴_바꿔_읽음(client):
     assert got["표지석||개"]["짝"] == [{"자재": "MT004258", "입력값": {}, "배": 1, "몫": None}]
 
 
-def test_층_차례_아래_층이_이김_느슨_찾기(client):
+def test_층_차례_마스터만_자동_아래_층은_제안_느슨_찾기(client):
     mine, company, system = ledger.chain(layers.personal_dir(7, 42))
     assert (company, system) == (layers.company_dir(7), store.FOLDER)
     new = {"갈래": "짝", "짝": [{"로직": "GF000103", "입력값": {}, "배": 1, "몫": None}]}
     _put_raw(system, {DIG_KEY: new, "잔토처리(인력100%)||m3": {"갈래": "우리에 없음"}})
     _put_raw(company, {DIG_KEY: {**new, "짝": [{"로직": "GF000102", "배": 1}]}})
-    got = ledger.recall(DIG, mine)
-    assert (got["층"], got["주인"], got["짝"][0]["로직"], got["규격다름"]) == (
-        "company",
-        "7",
-        "GF000102",
+    got = ledger.recall(DIG, mine)  # 739-1 — 회사 층 짝이 있어도 자동 = 마스터(승인)
+    assert (got["층"], got["주인"], got["짝"][0]["로직"], got["규격다름"], got["제안"]) == (
+        "system",
+        None,
+        "GF000103",
+        False,
         False,
     )
+    _put_raw(system, {"잔토처리(인력100%)||m3": {"갈래": "우리에 없음"}})
+    got = ledger.recall(DIG, mine)
+    assert (got["층"], got["짝"][0]["로직"], got["제안"]) == ("company", "GF000102", True)
     _put_raw(mine, {DIG_KEY: {"로직": "GF000101", "환산": 1}})
-    assert ledger.recall(DIG, mine)["짝"][0]["로직"] == "GF000101"  # 같은 층 먼저
+    got = ledger.recall(DIG, mine)
+    assert (got["짝"][0]["로직"], got["제안"]) == ("GF000101", True)  # 제안 = 같은 층 먼저
     rock = {**DIG, "규격": "경암"}
     loose = ledger.recall(rock, mine)
     assert loose["규격다름"] is True and loose["층"] == "personal"  # 품명|단위 느슨
@@ -90,12 +95,11 @@ def test_층_차례_아래_층이_이김_느슨_찾기(client):
     books = ledger.books(mine)
     assert ledger.recall(DIG, mine, books)["짝"][0]["로직"] == "GF000101"  # 한 번 읽어 넘김
     rows = ledger.rows(mine, True)
-    assert [(r["층"], r["고침"]) for r in rows] == [
-        ("personal", True),
-        ("company", False),
-        ("system", False),
-        ("system", False),
-    ]  # 위 층 = 읽기만
+    assert [(r["층"], r["고침"], r["상태"]) for r in rows] == [
+        ("personal", True, "대기"),
+        ("company", False, "대기"),
+        ("system", False, "승인"),
+    ]  # 위 층 = 읽기만 · 739-1 승인 상태
     assert not any(r["고침"] for r in ledger.rows(mine, False))
 
 

resources/tester/test_m02_hopyo_match.py

@@ -157,11 +157,18 @@ def _ledger(client, rows, layer="personal"):
     assert res.status_code == 200, res.text
 
 
+def _master(client, rows):
+    """739-1 자동 짝 = 마스터(승인) 장부만 — 시스템 관리자로 마스터 층에 씀."""
+    client.who.update(role="SYSTEM_ADMIN")
+    _ledger(client, rows, "system")
+    client.who.update(role="USER")
+
+
 def test_별칭_체크_규칙(client):
     _ready(client)
     dig = "구조물터파기(인력100%)|토사|m3"
     remicon = "레미콘타설(장비사용)|철근구조물-소량타설|m3"
-    _ledger(
+    _master(
         client,
         {
             dig: {"갈래": "짝", "짝": [{"로직": "GC000083", "배": 1}]},
@@ -172,7 +179,7 @@ def test_별칭_체크_규칙(client):
     )
     got = _hopyo(client, 3)["구조물터파기(인력100%)"]
     assert got["상태"] == "별칭" and got["체크"] is True and got["대상"][0]["출처"] == {}
-    assert got["별칭"]["층"] == "personal" and not got["별칭"]["근거다름"]
+    assert got["별칭"]["층"] == "system" and not got["별칭"]["근거다름"]
     first = _hopyo(client, 1)
     other = first["레미콘타설(장비사용)"]  # 숫자 판정 맞음 = GC000198 ≠ 장부 짝 → 판정 먼저(358-3)
     assert other["상태"] == "맞음" and other["체크"] is True and "별칭" not in other
@@ -182,14 +189,14 @@ def test_별칭_체크_규칙(client):
     assert loose["상태"] == "맞음" and "별칭" not in loose and "별칭 · 규격 다름" in loose["꼬리표"]
     assert all("별칭" not in t["출처"].values() for t in loose["대상"])
     assert "GC000211" in {c["로직"] for c in loose["후보"]} | {t["로직"] for t in loose["대상"]}
-    _ledger(
+    _master(
         client, {remicon: {"갈래": "짝", "짝": [{"로직": "GC000198", "입력값": {"소량감률": 50}}]}}
     )
     plain = _hopyo(client, 7)["레미콘타설(장비사용)"]  # 무근구조물 ↔ 장부 철근구조물-소량타설
     assert plain["상태"] == "맞음" and plain["체크"] is True and "별칭" not in plain
     assert plain["대상"][0]["로직"] == "GC000198" and plain["대상"][0]["입력값"]["소량감률"] == 0
     assert "별칭 · 규격 다름" in plain["꼬리표"]
-    _ledger(client, {dig: {"갈래": "짝", "짝": [{"로직": "GF000101", "배": 1}]}})
+    _master(client, {dig: {"갈래": "짝", "짝": [{"로직": "GF000101", "배": 1}]}})
     off = _hopyo(client, 3)["구조물터파기(인력100%)"]  # 산림 로직 ↔ 엑셀 건설 3-2-1
     assert off["별칭"]["근거다름"] and off["체크"] is False and "근거 다름" in off["꼬리표"]
 

resources/tester/test_m02_hopyo_screen.py

@@ -514,10 +514,11 @@ def test_명사형_단추와_별칭_장부_풀이_359():
     갈래 글 = 확인 창 드롭다운과 같음(저장 값 그대로)."""
     ledger = _text("M02_MasterTemplete_Hopyo_Ledger.ts")
     hint = "엑셀 품명 ↔ 우리 로직 · 자재 짝을 기억해 두었다가 같은 품명이 나오면 먼저 제안"
-    assert hint in ledger and "note(`${LEDGER_HINT}" in ledger
+    assert hint in ledger and "`${LEDGER_HINT}" in ledger
     side = _text("M02_MasterTemplete_Hopyo_Side.ts")
     assert "title: LEDGER_HINT" in side
-    for label in ('"변경 취소"', '"항목 추가"', '"내 층 복사"', '"삭제"'):
+    assert 'label: master ? "삭제" : "거두기"' in ledger  # 739-1 내 제안 = 거두기
+    for label in ('"변경 취소"', '"항목 추가"', '"내 층 복사"'):
         assert f"label: {label}" in ledger, label
     assert '"우리에 없음": "로직없음"' in ledger and '"안 씀": "사용안함"' in ledger
     mine = ("Hopyo_Side", "Hopyo_Sheet", "Hopyo_Check", "Hopyo_CheckRows", "Hopyo_Ledger")