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

2026-11-02 19:09:52 +09:00
parent 7eb176eb00 b1b9794946 afb9710423 5e2ac2ae79
commit c61fe32c2c
27 changed files with 642 additions and 75 deletions
@@ -168,6 +168,7 @@ class Builder:
            raise _bad(f"없는 호표 「제{no}호표」", 404)
        self.src, self.dry, self._sk, self._maker = Path(source), False, None, None
        self.strict = True  # 남은 줄 있으면 409(붙여넣기 `build_all` = 거짓)
+        self.doc_id = ledger.doc_id(source, key)  # 739-1 이 불러오기에서 이은 짝

    # ── 재검사 ───────────────────────────────────────────────────────
    def _target(self, raw: dict[str, Any], where: str, line: dict | None = None) -> dict[str, Any]:
@@ -395,11 +396,11 @@ class Builder:
        count |= {"빠짐": sum(1 for x in missing if x["까닭"] != TWICE), "이음": links}
        count["단가산출"] = sum(1 for x in lines if _is_sk(x))
        if not save:
-            ledger.write(self.folder, book, self.who, file or None)
+            ledger.write(self.folder, book, self.who, file or None, self.doc_id)
            head = {"문서": doc, "빠진줄": missing, "남은줄": left}
            return {**head, "줄수": {**count, "이음후보": linker.near}}
        ref, again = _save(doc)
-        wrote = ledger.write(self.folder, book, self.who, file or None)
+        wrote = ledger.write(self.folder, book, self.who, file or None, self.doc_id)
        out = {"참조": ref, "다시씀": again, "빠진줄": missing, "장부": {"씀": wrote}}
        return {**out, "줄수": {**count, "이음후보": linker.near}}

@@ -6,16 +6,19 @@ A00 산출근거 스프레드시트 Workbook(`A00_Common/spreadsheet/spreadsheet
 xls = xlrd `formatting_info` — 값 · 병합 · 열 폭(÷256 글자) ·
 행 높이(÷20 pt · 시트 기본과 다른 것만) · 서식 표(글꼴 · 굵게 · 맞춤 · 줄바꿈 · 테두리 · 채움 ·
 숫자 형식) · 틀고정(파일 값 · 없으면 머리 4행).
-xlsx = 값만 · 넓은 시트는 머리 글(앞 4 줄) 마지막 열까지 · STmate 숨은 칸 글(「_x0005_`BDCOD…」) 뺌.
+xlsx = 값 · 열 폭(`<cols>`) · 넓은 시트는 머리 글(앞 4 줄) 마지막 열까지 ·
+STmate 숨은 칸 글(「_x0005_`BDCOD…」) 뺌.
 결과 `{책, 호표: [{번, 이름, 행}], 단산: [{번, 이름, 행}]}` — 행 = 엑셀 1부터 [시작, 끝].
 """

 from __future__ import annotations

 import io
+import zipfile
 from typing import Any

 from openpyxl.utils import get_column_letter
+from openpyxl.xml.functions import fromstring

 from M02_MasterTemplete import M02_Hopyo_Basis as hopyo_basis
 from M02_MasterTemplete import M02_Hopyo_Excel as hopyo_excel
@@ -178,9 +181,42 @@ def _xls(data: bytes) -> dict[str, Any]:
    }


+def _xlsx_widths(data: bytes) -> dict[str, dict[str, dict[str, Any]]]:
+    """시트 이름 → 열 글자 → `{폭, 숨김}` — 시트 XML `<cols>` 를 읽음(read_only 는 폭을 안 줌)."""
+    out: dict[str, dict[str, dict[str, Any]]] = {}
+    try:
+        with zipfile.ZipFile(io.BytesIO(data)) as zf:
+            tag = lambda node: node.tag.rsplit("}", 1)[-1]  # noqa: E731
+            rels = {
+                r.get("Id"): r.get("Target", "")
+                for r in fromstring(zf.read("xl/_rels/workbook.xml.rels"))
+            }
+            for sheet in fromstring(zf.read("xl/workbook.xml")).iter():
+                if tag(sheet) != "sheet":
+                    continue
+                rid = next((v for k, v in sheet.attrib.items() if k.endswith("}id")), None)
+                path = (rels.get(rid) or "").lstrip("/")
+                path = path if path.startswith("xl/") else f"xl/{path}"
+                cols: dict[str, dict[str, Any]] = {}
+                for col in fromstring(zf.read(path)).iter():
+                    if tag(col) != "col":
+                        continue
+                    first, last = int(col.get("min", 0)), min(int(col.get("max", 0)), 200)
+                    one = {"폭": round(float(col.get("width", 0)), 2)}
+                    if col.get("hidden") in ("1", "true"):
+                        one["숨김"] = True
+                    for c in range(first, last + 1):
+                        cols[get_column_letter(c)] = one
+                out[sheet.get("name", "").strip()] = cols
+    except (KeyError, ValueError, zipfile.BadZipFile):
+        pass  # 폭을 못 읽으면 폭 없음 — 화면이 글 길이로 맞춤
+    return out
+
+
 def _xlsx(name: str, data: bytes) -> dict[str, Any]:
-    # ponytail: xlsx 는 값만(병합 · 폭 · 서식은 openpyxl 비 read_only 로 무거움) — 필요하면 그때
+    # ponytail: xlsx 는 값 · 열 폭만(병합 · 서식은 openpyxl 비 read_only 로 무거움) — 필요하면 그때
    found = hopyo_excel._sheets(name, data)
+    widths = _xlsx_widths(data)
    sheets = []
    for at, title in enumerate((n for n in SHEETS if n in found), 1):
        rows = found[title]
@@ -196,7 +232,15 @@ def _xlsx(name: str, data: bytes) -> dict[str, Any]:
            for c, v in enumerate(row[:width])
            if v not in (None, "") and not str(v).startswith("_x000")  # STmate 숨은 칸 글
        }
-        sheets.append({"id": f"s{at}", "이름": title, "칸": cells, "틀고정": {"행": HEAD_ROWS}})
+        sheets.append(
+            {
+                "id": f"s{at}",
+                "이름": title,
+                "칸": cells,
+                "열": widths.get(title, {}),
+                "틀고정": {"행": HEAD_ROWS},
+            }
+        )
    return {"서식": [{}], "시트": sheets}


@@ -6,8 +6,10 @@
 직접 줄 호표 통째 = 열쇠 「호표|품명|규격|단위」.
 옛 줄 {로직|자재|빼기, 입력값, 환산, 확정} = 읽을 때 새 꼴로 바꿔 읽음(빼기 = 「안 씀」 ·
 파일은 다음 쓰기 때 새 꼴).
-읽는 차례 = 같은 층 → 위 층(개인 → 회사 → 마스터) · 아래 층이 이김 · 정확 열쇠가 먼저 · 없으면
-품명|단위 느슨 열쇠(`규격다름`).
+중앙 관리(739-1) — 자동 짝 = 마스터 층(M01 별칭 장부 승인) · 이 불러오기에서 이은 짝
+(줄 `불러오기` = `doc_id`)만 · 회사 · 개인 층 짝 = 「내 제안」(`제안` True · 자동 아님 ·
+후보 맨 위 · M01 승인 대기).
+읽는 차례 = 자동 정확 열쇠(같은 층 → 위 층) → 제안 정확 열쇠 → 품명|단위 느슨 열쇠(`규격다름`).
 쓰는 때 = [확인하고 사전조합 만들기] · 장부 화면 [저장]만 · 쓰기 = 그 층만(권한은 길 몫) ·
 짝은 서버가 다시 검사(돈 로직 · 그 로직 입력 이름 · M01 자재품목 · 배 0 넘음 · 몫 (0, 1]).
 """
@@ -101,32 +103,69 @@ def books(folder: str | Path) -> list[tuple[str, str | None, dict[str, dict[str,
    return [(*refs.where(one), read(one)) for one in chain(folder)]


+def doc_id(folder: str | Path, doc: str) -> str:
+    """불러오기 하나 열쇠 — 「층/주인/HP 키」(장부 줄 `불러오기` · 같은 불러오기 안 자동)."""
+    layer, owner = refs.where(folder)
+    return f"{layer}/{owner or ''}/{doc}"
+
+
 def recall(
-    line: dict[str, Any], folder: str | Path, got: list | None = None, whole: bool = False
+    line: dict[str, Any],
+    folder: str | Path,
+    got: list | None = None,
+    whole: bool = False,
+    doc: str | None = None,
 ) -> dict[str, Any] | None:
-    """줄(`whole` = 호표 통째)의 장부 짝 — `{…줄, 층, 주인, 규격다름}` · 없으면 None.
-    정확 열쇠(아래 층 먼저) → 품명|단위 느슨(규격다름 True · 체크 안 함)."""
+    """줄(`whole` = 호표 통째)의 장부 짝 — `{…줄, 층, 주인, 규격다름, 제안}` · 없으면 None.
+    자동 정확 열쇠(마스터 · `doc` 불러오기에서 이은 짝) → 제안 정확 열쇠(회사 · 개인 층 ·
+    `제안` True · 자동 아님) → 품명|단위 느슨(규격다름 True · 체크 안 함)."""
    full = hopyo_key(line) if whole else key(line)
    got = books(folder) if got is None else got
-    for layer, owner, book in got:
-        if full in book:
-            return {**book[full], "층": layer, "주인": owner, "규격다름": False}
+    hits = [(layer, owner, book[full]) for layer, owner, book in got if full in book]
+    for layer, owner, row in hits:
+        if layer == "system" or (doc and row.get("불러오기") == doc):
+            return {**row, "층": layer, "주인": owner, "규격다름": False, "제안": False}
+    if hits:
+        layer, owner, row = hits[0]
+        return {**row, "층": layer, "주인": owner, "규격다름": False, "제안": True}
    loose = _loose(full)
    for layer, owner, book in got:
        for one, row in book.items():
            if one.startswith(HOPYO) == whole and _loose(one) == loose:
-                return {**row, "층": layer, "주인": owner, "규격다름": True}
+                return {**row, "층": layer, "주인": owner, "규격다름": True, "제안": False}
    return None


+def _states(rows_: list[dict[str, Any]]) -> None:
+    """내 제안 승인 상태(739-1) — 마스터 줄 = 승인 · 아래 층 줄 = 마스터에 같은 짝(서명) 승인 ·
+    M01 반려 기억 반려 · 그 밖 대기(M01 별칭 장부 `sign` · 반려 기억 그대로)."""
+    from M01_MasterData import M01_MasterData_Alias as alias  # M01 이 장부를 부름 — 늦게 읽음
+
+    master = read(store.FOLDER)
+    gone = alias.rejected()
+    for row in rows_:
+        if row["층"] == "system":
+            row["상태"] = "승인"
+            continue
+        sig, mine = alias.sign(alias.ALIAS, row), master.get(row["열쇠"])
+        if mine and alias.sign(alias.ALIAS, mine) == sig:
+            row["상태"] = "승인"
+        elif alias._reject_id(alias.ALIAS, row["열쇠"], sig) in gone:
+            row["상태"] = "반려"
+        else:
+            row["상태"] = "대기"
+
+
 def rows(folder: str | Path, writable: bool) -> list[dict[str, Any]]:
-    """장부 화면 — 이 층 + 위 층 줄 `{열쇠, …줄, 층, 주인, 고침}`(고침 = 이 층 · 쓰기 권한)."""
+    """장부 화면 — 이 층 + 위 층 줄 `{열쇠, …줄, 층, 주인, 고침, 상태}`(고침 = 이 층 · 쓰기 권한 ·
+    상태 = 승인 · 대기 · 반려)."""
    out = []
    for at, (layer, owner, book) in enumerate(books(folder)):
        for full, row in sorted(book.items()):
            out.append(
                {"열쇠": full, **row, "층": layer, "주인": owner, "고침": writable and not at}
            )
+    _states(out)
    return out


@@ -239,9 +278,10 @@ def write(
    entries: dict[str, dict[str, Any] | None],
    who: Any,
    file: str | None = None,
+    doc: str | None = None,
 ) -> int:
    """검사 끝난 줄을 층 장부에 씀(None = 지움) — 같은 열쇠는 덮음 · 처음파일은 있던 값 둠 ·
-    옛 꼴 줄은 이때 새 꼴로 → 쓴 줄 수."""
+    `doc` = 이은 불러오기(`doc_id` · 없으면 있던 값) · 옛 꼴 줄은 이때 새 꼴로 → 쓴 줄 수."""
    if not entries:
        return 0
    have = read(folder)
@@ -254,6 +294,8 @@ def write(
            continue
        first = (have.get(full) or {}).get("처음파일") or file
        out[full] = {**row, "누가": who, "때": stamp, "처음파일": first, "판": version}
+        if came := doc or (have.get(full) or {}).get("불러오기"):
+            out[full]["불러오기"] = came
    hopyo_store.remember(folder, out)
    return len(entries)

@@ -17,6 +17,9 @@
 입력값 출처(칸마다) = 별칭 > 블록(옵션 찾기 값이 규격 읽기와 다름) > 규격(`spec_inputs`) > 자동값.
 체크 = 처음 제안일 뿐 — 들어감은 [확인하고 사전조합 만들기](다 창)만. 저장 없음 · 셈은 서버 단독.
 장부 = `M02_Hopyo_Ledger`(다 창) · 확인된 사전조합 = `M02_Hopyo_Build.confirmed`(다 창).
+④ ⑤ 장부 짝 = 자동 짝만(마스터 · 이 불러오기에서 이은 짝 · 739-1) · 회사 · 개인 층 짝 =
+「내 제안」 — 숫자 판정 그대로 + 꼬리표 「내 제안」 + `제안 {갈래, 짝, 대상, 층, 때}`
+(고르기 창 맨 위 · 한 번 눌러 고름).
 """

 from __future__ import annotations
@@ -40,6 +43,7 @@ from M02_MasterTemplete import M02_Labor_Ref as refs
 from M02_MasterTemplete import M02_MasterTemplete_Store as store

 SKIP = ("우리에 없음", "안 씀")
+MINE = "내 제안"
 LOOSE = "별칭 · 규격 다름"
 LEDGER_OFF = "장부와 다름"
 OUTSIDE = ("%", "노임", "뺌")  # 연결 셈 밖(358-3 ②)
@@ -55,6 +59,7 @@ class Ctx:
        self.got = hm.targets()
        self.units = {int(h["번"]): h for h in self.doc.get("호표") or []}
        self.books = ledger.books(self.to)
+        self.doc_id = ledger.doc_id(self.folder, key)
        self.calc = fit.ensure(folder, key)
        self.cache = (fit.result(folder, key) or {}).get("블록") or {}
        self.done = hopyo_build.confirmed(self.to, refs.where(self.folder))
@@ -255,7 +260,8 @@ def match_line(line: dict[str, Any], ctx: Ctx, full: bool = True) -> dict[str, A
        return {**out, "상태": "호표", "체크": ok, "대상": [target], "글": text}
    if kind == "노임":
        return {**out, "상태": "노임", "글": "노임 · 그릇 없음"}
-    alias = ledger.recall(line, ctx.to, ctx.books)
+    alias = ledger.recall(line, ctx.to, ctx.books, doc=ctx.doc_id)
+    mine, alias = (alias, None) if alias and alias.get("제안") else (None, alias)
    loose, alias = (alias, None) if alias and alias.get("규격다름") else (None, alias)
    entry = ctx.cache.get(fit.unit_key(line)) if kind not in hm.MATERIAL_KINDS else None
    if alias and alias.get("갈래") in SKIP:
@@ -273,9 +279,20 @@ def match_line(line: dict[str, Any], ctx: Ctx, full: bool = True) -> dict[str, A
        why = "셈 중" if not ctx.calc["끝"] else fit.NO_NUMBER
        got = _names_only(line, ctx, why, full)
    got = _loose(got, loose, line, ctx) if loose and full else got
+    got = _mine(got, mine, line, ctx) if mine else got
    return {**out, **(_grouped(got, line, ctx) if full and kind not in hm.MATERIAL_KINDS else got)}


+def _mine(got: dict, mine: dict, line: dict, ctx: Ctx) -> dict:
+    """내 제안(739-1 · 승인 전 회사 · 개인 층 짝) — 자동 아님 · 꼬리표 + `제안`(고르기 맨 위)."""
+    pairs = [p for p in mine.get("짝") or [] if p.get("로직") or p.get("자재")]
+    kind = mine.get("갈래")
+    word = MINE if kind == "짝" else f"{MINE} — {kind}"
+    head = {"갈래": kind, "짝": pairs, "층": mine.get("층"), "때": mine.get("때")}
+    targets = [_pair(p, line, ctx) for p in pairs]
+    return {**got, "꼬리표": [*(got.get("꼬리표") or []), word], "제안": {**head, "대상": targets}}
+
+
 def _grouped(got: dict, line: dict, ctx: Ctx) -> dict:
    """묶음 표시(358-1) — 후보 · 이름후보(옛 324 다섯)마다 뜻겹침 · 출처같음(조항 ≥ 0.9) · 책 ·
    차례 · 무게 · 상태 그대로(아무것도 숨기지 않음 · 묶음은 화면 몫)."""
@@ -356,12 +373,12 @@ def _aliased(line: dict, ctx: Ctx, alias: dict, entry: dict | None) -> dict:
 def whole(hopyo: dict, ctx: Ctx) -> dict | None:
    """직접 줄 호표 통째 제안 — 장부 짝(호표 열쇠) 먼저 · 맞춤셈 「호표:번」."""
    head = {k: hopyo.get(k) for k in ("이름", "규격", "단위")}
-    alias = ledger.recall(head, ctx.to, ctx.books, whole=True)
+    alias = ledger.recall(head, ctx.to, ctx.books, whole=True, doc=ctx.doc_id)
    if alias and alias.get("갈래") == "짝" and alias.get("짝") and not alias.get("규격다름"):
-        return {
+        return {  # 내 제안(739-1) = 체크 안 함 · 한 번 눌러 고름
            "대상": [_pair(p, head, ctx) for p in alias["짝"]],
-            "글": "별칭 장부 짝",
-            "체크": True,
+            "글": MINE if alias.get("제안") else "별칭 장부 짝",
+            "체크": not alias.get("제안"),
        }
    entry = ctx.cache.get(f"호표:{hopyo['번']}")
    if not entry or not entry.get("차례"):
@@ -306,6 +306,8 @@ def build(folder: Path, key: str, who: Any = None, picks: Any = None) -> dict[st
        found = ledger.recall(line, folder, books)
        if no in chosen or found is None or found.get("규격다름"):
            alias[ledger.key(line)] = _alias(line, plan)
-    out["별칭"] = ledger.write(folder, alias, who, maker.hp.get("파일") or None)
+    out["별칭"] = ledger.write(
+        folder, alias, who, maker.hp.get("파일") or None, ledger.doc_id(folder, key)
+    )
    out["같은것씀"], out["위층같음"] = maker.reused, maker.above
    return out
@@ -11,6 +11,7 @@ from __future__ import annotations
 from fastapi import APIRouter, HTTPException

 from M01_MasterData import M01_MasterData_Router as m01
+from M02_MasterTemplete import M02_Machine_Hourly as machine

 router = APIRouter(prefix="/api/m02/logic-lib", tags=["M02 Logic Lib Read"])

@@ -71,3 +72,9 @@ def post_calc(body: m01.CalcBody) -> dict:
@router.post("/text")
 def post_text(body: m01.CalcBody) -> dict:
    return m01.post_text(body)
+
+
+@router.get("/machine-hourly")
+def get_machine_hourly(key: str) -> dict:
+    """기계(EQ) 한 시간 값 노 · 재 · 경(736-3 · [항목 추가] 기계 고정 줄 단가)."""
+    return machine.hourly(key)
@@ -0,0 +1,72 @@
+"""M02 기계(M01 EQ) 한 시간 값 — [항목 추가] 창에서 기계를 고르면 고정 줄 단가(PLAN 736-3).
+
+기계 줄 = 일위대가 · 단가산출 더한줄의 고정 줄(이음 기계 EQ · 수량 1) — 단가 = 이 값(노 · 재 · 경).
+셈 = M01 「건설기계」 장 기계경비 로직 가운데 그 기종을 받는 짝 차례 첫째
+(`로직(GC, 기계='원문번호')` · 옵션은 기본값). 짝 차례 · 셈은
+`DataFlow/M02_DF_Values._machine_hourly` 와 같은 규칙(그 폴더는 시험 길이라 따로 둠).
+마스터 파일은 읽기만 · 로그인 사용자 모두.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from M01_MasterData import M01_MasterData_Store as store
+
+cm = store.cm
+_PLAIN = {"기계", "지역", "보정작업", "조종원직종"}  # 이 밖의 입력 = 부착 장비 전용
+
+
+def _family() -> list[dict]:
+    """기계 시간당 경비 로직 — 「건설기계」 장 파일 안 · 입력 「기계」 고르기가 있는 돈 로직."""
+    return [
+        row
+        for name, data in store.loaded()[0].items()
+        if data.get("그룹") == "로직" and "건설기계" in name
+        for row in data.get("줄") or []
+        if str(row.get("결과단위") or "").startswith("원")
+        and any(i.get("이름") == "기계" and i.get("고르기") for i in row.get("입력") or [])
+    ]
+
+
+def _codes(row: dict) -> list:
+    return next(i["고르기"] for i in row["입력"] if i.get("이름") == "기계")
+
+
+def _rank(row: dict) -> tuple:
+    """부착 전용 · 손료만 · 보정 · 기종 수 · 키 — 작을수록 먼저."""
+    names = [i.get("이름") for i in row.get("입력") or []]
+    attach = any(n not in _PLAIN for n in names)
+    loss = "지역" not in names
+    return (attach, loss, loss and "보정작업" in names, len(_codes(row)), str(row.get("키")))
+
+
+def hourly(key: str) -> dict[str, Any]:
+    """`{ok, 이름, 규격, 노무비, 재료비, 경비, 계}` · 못 셈 = `{ok: False, reason}`."""
+    if not key.startswith("EQ"):
+        return {"ok": False, "reason": f"「{key}」 는 기계 아님"}
+    try:
+        row = store.loaded()[1].get(key)
+    except cm.mf.FormulaError as e:
+        return {"ok": False, "reason": str(e)}
+    code = str(row.get("원문번호") or "")
+    fit = [r for r in _family() if code in [str(c) for c in _codes(r)]]
+    if not fit:
+        return {"ok": False, "reason": f"「{row.get('이름')}」 은 시간당 경비를 셀 자료가 없음"}
+    logic = min(fit, key=_rank)
+    args = "".join(
+        f", {i['이름']}='{(i.get('고르기') or [''])[0]}'"
+        for i in logic.get("입력") or []
+        if i.get("이름") != "기계"
+    )
+    call = f"로직({logic['키']}, 기계='{code}'{args})"
+    line = {"종류": "로직", "요소": call, "이름": "기계", "단위": "시간", "수량": "1"}
+    holder = {
+        "키": "", "원문번호": "", "이름": "기계 시간", "결과단위": "원/식", "출처": "자체",
+        "입력": [], "중간": [], "호표": [line], "덧줄": [], "끝수": None,
+    }  # fmt: skip
+    got = store.calc("", {}, holder, None)
+    if not got.get("ok") or "sums" not in got:
+        return {"ok": False, "reason": got.get("reason") or "셈 못 함"}
+    sums = {k: float(got["sums"][k]) for k in (*cm.mf.COST_ITEMS, "계")}
+    return {"ok": True, "이름": row.get("이름"), "규격": row.get("규격"), **sums}
@@ -49,6 +49,8 @@ export interface M01Element {
  규격: string;
  단위: string;
  값: number | null;
+  /** 기계(736-3) — 한 시간 노 · 재 · 경(서버 `/logic-lib/machine-hourly` · 고르는 순간 받음) */
+  단가?: Record<"노무비" | "재료비" | "경비", number>;
 }

 /** 고를 수 있는 종류 — logic = M01 단가산출 · 기초 로직 · labor = 인력 · material = 재료 · machine = 기계 · sk = M02 단가산출 · pre = 일위대가 */
@@ -80,6 +82,16 @@ export const logicHeads = (rows: StandardRow[]): StandardRow[] =>

 /** 일위대가 고정 줄(705-1 이음 꼴) — 인력 = 노임 LB · 재료 = 자재 MT · 단가 = 지금 값(셈은 단가 책 값) */
 export function fixedOf(e: M01Element): LaborFixed {
+  if (e.종류 === "기계") {
+    // 736-3 기계 = 이음 기계 EQ · 단가 = 한 시간 노 · 재 · 경(셈은 줄 단가 그대로)
+    return {
+      이름: e.이름,
+      규격: e.규격,
+      단위: e.단위,
+      단가: e.단가 ?? { 노무비: 0, 재료비: 0, 경비: 0 },
+      이음: { 노임: null, 자재: null, 기계: e.코드 },
+    };
+  }
  const labor = e.종류 === "인력";
  return {
    이름: e.이름,
@@ -171,6 +183,8 @@ export function openFindPicker(opt: FindPickOptions): void {
    rowClass: (i) => (shown[i]?.dim ? "is-dim" : null),
    onRowClick: (i) => shown[i]?.go(),
  });
+  const fail = (error: unknown): void =>
+    showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error");
  const take = (f: () => void) => (): void => {
    close();
    f();
@@ -199,6 +213,20 @@ export function openFindPicker(opt: FindPickOptions): void {
        },
      ];
    });
+  /** 기계 고름 — 한 시간 값을 받아 단가로(못 셈 = 까닭 알림 · 창 그대로) */
+  const hourly = async (e: M01Element): Promise<M01Element | null> => {
+    try {
+      const got = await call<{ ok: boolean; reason?: string } & Record<string, number>>(
+        `/logic-lib/machine-hourly?key=${encodeURIComponent(e.코드)}`,
+      );
+      if (!got.ok) throw new Error(got.reason ?? tc("Load_Failed"));
+      const { 노무비, 재료비, 경비, 계 } = got;
+      return { ...e, 값: 계, 단가: { 노무비, 재료비, 경비 } };
+    } catch (error) {
+      fail(error);
+      return null;
+    }
+  };
  const elementLines = (kind: M01Element["종류"], items: PickItem[]): Line[] =>
    items.map((m) => {
      const e: M01Element = {
@@ -223,7 +251,11 @@ export function openFindPicker(opt: FindPickOptions): void {
        구분: join(kind, m.구분, put ? "" : L("M02_FindElementLater")),
        출처: `M01 ${m.ref}`,
        dim: !put,
-        go: put ? take(() => put(e)) : () => showToast(L("M02_FindElementLater"), "warning"),
+        go: !put
+          ? () => showToast(L("M02_FindElementLater"), "warning")
+          : kind === "기계"
+            ? () => void hourly(e).then((x) => x && take(() => put(x))())
+            : take(() => put(e)),
      };
    });
  const docLines = (rows: SangeunRow[], kind: string): Line[] =>
@@ -346,8 +378,6 @@ export function openFindPicker(opt: FindPickOptions): void {
  search.input.focus();
  draw();

-  const fail = (error: unknown): void =>
-    showToast(error instanceof Error ? error.message : tc("Load_Failed"), "error");
  void Promise.all([fetchLibLogics(), fetchStandard().catch(() => null)])
    .then(([l, s]) => {
      logics = l;
@@ -153,6 +153,8 @@ export interface HopyoMatch {
  갈리는칸?: string[];
  별칭?: { 층: Layer; 주인: string | null; 규격다름?: boolean; 근거다름?: boolean };
  뺌?: string;
+  /** 739-1 내 제안(승인 전 회사 · 개인 층 장부 짝) — 자동 아님 · 고르기 창 맨 위 */
+  제안?: { 갈래: string; 짝: LedgerPair[]; 대상: HopyoPart[]; 층: Layer; 때: string | null };
 }

 /** 숫자 판정 셈 — 끝 · 한 블록 · 모두 · 까닭(우리 로직 준비 중 등) */
@@ -405,6 +407,8 @@ export interface LedgerRow extends LedgerEntry {
  층: Layer;
  주인: string | null;
  고침: boolean;
+  /** 739-1 M01 승인 상태 — 마스터 줄 = 승인 */
+  상태?: "승인" | "대기" | "반려";
 }

 const enc = encodeURIComponent;
@@ -189,7 +189,9 @@ function actsCell(line: HopyoLine, parts: HopyoPart[], ctx: RowsContext): HTMLEl
  return el("td", {
    className: "m02-hopyo__acts",
    children: [
-      ...(ctx.canWrite && m.상태 !== "%" ? [ghost("고르기", () => ctx.choose(line))] : []),
+      ...(ctx.canWrite && m.상태 !== "%"
+        ? [ghost(m.제안?.짝.length ? "고르기 · 내 제안" : "고르기", () => ctx.choose(line))]
+        : []),
      ghost("원문 보기", () => ctx.source(line)),
      ...(line.근거 ? [ghost("엑셀 보기", () => ctx.sheet(line.근거!.행))] : []),
      ...options,
@@ -224,6 +224,37 @@ export function openHopyoChoose(opt: ChooseOptions): void {
        ),
      );
      const groups = candGroups(line.맞춤, material);
+      // 739-1 내 제안 — 맨 위 · 한 번 눌러 짝 통째로(입력값 · 배 · 몫 그대로)
+      const mine = line.맞춤.제안?.짝.length ? line.맞춤.제안 : null;
+      const mineRow = mine
+        ? el("div", {
+            attrs: { "data-group": "내 제안" },
+            children: [
+              note("내 제안 — 승인 전(M01 별칭 장부 승인 뒤 자동)"),
+              el("div", {
+                className: "m02-hopyo__cand",
+                attrs: { "data-cand": "내 제안" },
+                children: [
+                  createButton({
+                    label: mine.대상.map((c) => candText(c, new Set())).join(" + "),
+                    variant: "ghost",
+                    size: "sm",
+                    onClick: () =>
+                      finish(
+                        mine.짝.map((p) => ({
+                          ...(p.로직 ? { 로직: p.로직 } : { 자재: p.자재 }),
+                          입력값: p.입력값 ?? {},
+                          배: p.배,
+                          몫: p.몫 ?? null,
+                        })),
+                      ),
+                  }),
+                  el("span", { className: "m02-hopyo__state is-별칭", text: "내 제안" }),
+                ],
+              }),
+            ],
+          })
+        : null;
      const twins = sameNames(groups);
      const row = (c: HopyoTarget): HTMLElement => {
        const share = el("input", {
@@ -332,6 +363,7 @@ export function openHopyoChoose(opt: ChooseOptions): void {
            ? "후보 — 하나 고름 · 여럿은 체크(몫 칸) 뒤 [일괄 적용]"
            : "가까운 것 없음 — 아래 검색",
        ),
+        ...(mineRow ? [mineRow] : []),
        ...sections,
        el("div", { className: "ui-toolbar m02-hopyo__bar", children: [together, ...more] }),
      );
@@ -7,8 +7,11 @@
 *    위 층 줄 [내 층 복사] · 갈래 글 = 확인 창 드롭다운과 같음(짝 · 로직없음 · 사용안함 · 저장 값 그대로)
 *  · 고친 것 = sessionStorage `m02-hopyo-ledger:{층}:{주인}` → [저장] 때만 `PUT`(서버가 짝을 다시 검사)
 *  · 안 둠 = 발주처 칸 · 자동 올림 · 자동 합침 · 쓰인 횟수 · 회사로 올리기.
+ *  · 739-1 중앙 관리 — 회사 · 개인 층 = 「내 제안 목록」(보기 · 고치기 · [거두기] · 승인 상태 대기 · 승인 · 반려) ·
+ *    자동 짝 = 마스터(M01 별칭 장부 승인)만 · 마스터 층(M01 화면) = 별칭 장부 그대로
 * ========================================================================== */

+import { createBadge, type BadgeTone } from "@ui/ui_template_badge";
 import { createButton, el, showToast } from "@ui/ui_template_elements";
 import { loadingError, showLoading } from "@ui/ui_template_loading";
 import { t as L } from "@ui/ui_template_locale";
@@ -38,6 +41,9 @@ export const KIND_TEXT: Record<string, string> = {
  "안 씀": "사용안함",
 };
 const LAYER_TEXT: Record<string, string> = { system: "마스터", company: "회사", personal: "개인" };
+/** 739-1 회사 · 개인 층 장부 화면 제목 */
+export const MINE_TITLE = "내 제안 목록";
+const STATE_TONE: Record<string, BadgeTone> = { 승인: "success", 대기: "warning", 반려: "danger" };
 type Edits = Record<string, LedgerEntry | null>;
 /** 화면 한 줄 — 서버 줄 위에 고친 것 */
 export type LedgerView = LedgerRow & { 고친?: boolean };
@@ -139,6 +145,7 @@ export function buildHopyoLedger(opt: LedgerOptions): HTMLElement {
    attrs: { "data-hopyo-ledger": "" },
  });
  const k = ledgerKey(opt.scope);
+  const master = opt.scope.layer === "system";
  let edits = loadEdits(k);
  let rows: LedgerRow[] = [];
  const search = el("input", {
@@ -249,7 +256,7 @@ export function buildHopyoLedger(opt: LedgerOptions): HTMLElement {
    if (mine)
      acts.push(
        createButton({
-          label: "삭제",
+          label: master ? "삭제" : "거두기",
          variant: "danger",
          size: "sm",
          onClick: () => {
@@ -282,6 +289,10 @@ export function buildHopyoLedger(opt: LedgerOptions): HTMLElement {
        pairCell(r, mine),
        td(when),
        td(r.고침 ? "내 층" : (LAYER_TEXT[r.층] ?? r.층)),
+        el("td", {
+          attrs: { "data-state": r.상태 ?? "" },
+          children: r.고친 || !r.상태 ? [] : [createBadge(r.상태, STATE_TONE[r.상태])],
+        }),
        el("td", { className: "m02-hopyo__acts", children: acts }),
      ],
    });
@@ -296,7 +307,7 @@ export function buildHopyoLedger(opt: LedgerOptions): HTMLElement {
    body.replaceChildren(
      ...(shown.length
        ? shown.map(rowOf)
-        : [el("tr", { children: [el("td", { text: "장부 줄 없음", attrs: { colspan: "8" } })] })]),
+        : [el("tr", { children: [el("td", { text: "장부 줄 없음", attrs: { colspan: "9" } })] })]),
    );
  }
  search.addEventListener("input", paint);
@@ -332,8 +343,12 @@ export function buildHopyoLedger(opt: LedgerOptions): HTMLElement {
      el("div", {
        className: "ui-toolbar m02-hopyo__bar",
        children: [
-          el("strong", { text: LEDGER_TITLE }),
-          note(`${LEDGER_HINT} · ${L("M02_PrecomboTitle")} 생성 때 남음 · 아래 층이 이김`),
+          el("strong", { text: master ? LEDGER_TITLE : MINE_TITLE }),
+          note(
+            master
+              ? `${LEDGER_HINT} · 여기 짝 = 모든 사용자 불러오기에 자동`
+              : `내 층 짝 = 내 제안(다음 불러오기에서 후보 맨 위 · 자동 아님) · M01 별칭 장부 승인 뒤 자동 · ${L("M02_PrecomboTitle")} 생성 때 남음`,
+          ),
          search,
          kind,
          ...(opt.canWrite ? [save, drop] : []),
@@ -356,6 +371,7 @@ export function buildHopyoLedger(opt: LedgerOptions): HTMLElement {
                      "우리 로직 · 배 · 몫 · 옵션",
                      "누가 · 때 · 처음 파일",
                      "층",
+                      "승인",
                      "",
                    ].map((t) => el("th", { text: t })),
                  }),
@@ -336,8 +336,10 @@ export function openHopyoSheet(opt: HopyoSheetOptions): void {

  async function mountSheet(grid: HopyoGrid): Promise<void> {
    const { createSpreadsheet } = await import("../A00_Common/spreadsheet/spreadsheet");
+    const { fillMissingWidths } = await import("../A00_Common/spreadsheet/spreadsheet_autofit");
    if (closed) return;
    const book = structuredClone(grid.책);
+    fillMissingWidths(book); // 엑셀 폭이 없는 열 = 글 길이로 처음 폭
    const first = book.시트.find((s) => s.이름 === ILWI) ?? book.시트[0];
    if (!first) return void left.replaceChildren(note("시트 없음"));
    ilwi = first.id;
@@ -449,7 +449,10 @@ export function createItemCards(opts: ItemCardsOptions): ItemCardsHandle {
      const { createSpreadsheet } = await loadSpreadsheet();
      if (mine !== seq || !c.doc) return;
      if (opts.sheetEdit?.can()) return await paintEditable(c, mine, createSpreadsheet);
-      c.handle = createSpreadsheet(c.host, c.doc, { readOnly: true, tabs: false });
+      c.handle = createSpreadsheet(c.host, structuredClone(c.doc), {
+        readOnly: true,
+        tabs: false,
+      }); // 열 폭을 끌어 바꿔도 원본 안 건드림
    } catch (error) {
      if (mine === seq) c.shell.fail(fill(TEXT.noSheet, why(error)), reload);
    }
@@ -109,6 +109,7 @@ export function openLogicPicker(
      logic: done,
      ref: lib.pick,
      element: fixed && ((e) => fixed(fixedOf(e), e.이름)),
+      machine: fixed && ((e) => fixed(fixedOf(e), e.이름)), // 736-3 기계 = 이음 기계 고정 줄
      material: lib.material,
    });
  }
@@ -9,8 +9,8 @@
 * ========================================================================== */

 import { call, type Layer } from "./M02_MasterTemplete_Api_Fetch";
-import { openFindPicker } from "./M02_MasterTemplete_Find_Pick";
-import type { LaborRef } from "./M02_MasterTemplete_Labor_Calc";
+import { fixedOf, openFindPicker } from "./M02_MasterTemplete_Find_Pick";
+import type { LaborFixed, LaborRef } from "./M02_MasterTemplete_Labor_Calc";

 export const SANGEUN_KIND = "sangeun";
 /** 층 차례 — 위에서 아래 */
@@ -73,7 +73,8 @@ export async function listLayerDocs(
 export type SangeunLine =
  | { 종류: "로직"; 로직: string; 입력값: Record<string, never>; 수량: number }
  | { 참조: LaborRef; 수량: number }
-  | { 종류: "인력" | "재료"; 요소: string; 이름: string | null; 단위: string | null; 수량: number };
+  | { 종류: "인력" | "재료"; 요소: string; 이름: string | null; 단위: string | null; 수량: number }
+  | { 고정: LaborFixed; 이름: string; 단위: string | null; 수량: number };

 /** 단가산출 [항목 추가] — `scope` = 그 SK 문서 층(고를 수 있는 서고 = 위 층만) */
 export function openSangeunLinePicker(
@@ -87,5 +88,7 @@ export function openSangeunLinePicker(
    element: (e) =>
      e.종류 !== "기계" &&
      done({ 종류: e.종류, 요소: e.코드, 이름: e.이름, 단위: e.단위, 수량: 1 }),
+    // 736-3 기계 = 고정 줄(이음 기계 EQ · 단가 = 한 시간 노 · 재 · 경) · 수량 1
+    machine: (e) => done({ 고정: fixedOf(e), 이름: e.이름, 단위: e.단위, 수량: 1 }),
  });
 }