diff --git a/data.db b/data.db
index 24cb51d..41c0d04 100644
Binary files a/data.db and b/data.db differ
diff --git a/main.py b/main.py
index 6c12ebd..70b5246 100644
--- a/main.py
+++ b/main.py
@@ -2,6 +2,8 @@ import os
 import logging
 import json
 import re
+import sqlite3
+import threading
 import time
 import tempfile
 import zipfile
@@ -44,6 +46,12 @@ _HEALTH_PAYLOAD_CACHE: dict[str, Any] = {
     "expires_at": 0.0,
     "payload": None,
 }
+_DB_BACKUP_STATE: dict[str, Any] = {
+    "last_run_at": 0.0,
+}
+_DB_BACKUP_LOCK = threading.Lock()
+DB_BACKUP_MIN_INTERVAL_SECONDS = 900.0
+DB_BACKUP_KEEP_COUNT = 24
 
 app = FastAPI()
 
@@ -51,8 +59,10 @@ BASE_DIR = Path(__file__).resolve().parent
 STATIC_DIR = BASE_DIR / "static"
 TEMPLATES_DIR = BASE_DIR / "templates"
 DB_PATH = BASE_DIR / "data.db"
+BACKUP_DIR = BASE_DIR / "backups"
 
 STATIC_DIR.mkdir(exist_ok=True)
+BACKUP_DIR.mkdir(exist_ok=True)
 templates = Jinja2Templates(directory=str(TEMPLATES_DIR))
 app.mount("/static", StaticFiles(directory=str(STATIC_DIR)), name="static")
 
@@ -180,6 +190,9 @@ DEFAULT_APP_OPTION_ITEMS = {
         ("legacy_variant_cutoff_year", "이전 연도 변경/차수 제외 기준", "23"),
         ("detail_visible_min_year", "세부내역 반영 시작 연도", "2023"),
     ],
+    "project_shared": [
+        ("exec_labor_rates_json", "공통 기준인건비", "{}"),
+    ],
     "dashboard_revenue_metrics": [
         ("design_revenue", "설계", "#4f7cff"),
         ("design_other_revenue", "설계 외", "#67c7c9"),
@@ -594,6 +607,7 @@ def init_db() -> None:
                     group_name TEXT DEFAULT '',
                     grade TEXT DEFAULT '',
                     hours TEXT DEFAULT '',
+                    rate_year TEXT DEFAULT '',
                     dept_name TEXT DEFAULT '',
                     work_name TEXT DEFAULT '',
                     account_code TEXT DEFAULT '',
@@ -622,6 +636,7 @@ def init_db() -> None:
                     group_name TEXT DEFAULT '',
                     grade TEXT DEFAULT '',
                     minutes TEXT DEFAULT '',
+                    rate_year TEXT DEFAULT '',
                     label TEXT DEFAULT '',
                     reference TEXT DEFAULT '',
                     note TEXT DEFAULT '',
@@ -639,6 +654,71 @@ def init_db() -> None:
                 """
             )
         )
+        conn.execute(
+            text(
+                """
+                CREATE TABLE IF NOT EXISTS app_save_events (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    action_key TEXT NOT NULL,
+                    entity_type TEXT NOT NULL,
+                    entity_key TEXT DEFAULT '',
+                    session_id TEXT DEFAULT '',
+                    status TEXT NOT NULL DEFAULT 'ok',
+                    duration_ms INTEGER NOT NULL DEFAULT 0,
+                    payload_json TEXT DEFAULT '{}',
+                    error_message TEXT DEFAULT '',
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+        )
+        conn.execute(
+            text(
+                """
+                CREATE INDEX IF NOT EXISTS idx_app_save_events_lookup
+                ON app_save_events (entity_type, entity_key, created_at DESC)
+                """
+            )
+        )
+        conn.execute(
+            text(
+                """
+                CREATE TABLE IF NOT EXISTS project_status_snapshots (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    support_dept_code TEXT NOT NULL,
+                    action_key TEXT NOT NULL DEFAULT 'project_status_save',
+                    session_id TEXT DEFAULT '',
+                    previous_revision TEXT DEFAULT '',
+                    revision TEXT DEFAULT '',
+                    previous_snapshot_json TEXT DEFAULT '{}',
+                    snapshot_json TEXT DEFAULT '{}',
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+        )
+        conn.execute(
+            text(
+                """
+                CREATE INDEX IF NOT EXISTS idx_project_status_snapshots_code_created
+                ON project_status_snapshots (support_dept_code, created_at DESC)
+                """
+            )
+        )
+        conn.execute(
+            text(
+                """
+                CREATE TABLE IF NOT EXISTS db_backup_history (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    backup_file TEXT NOT NULL,
+                    file_size INTEGER NOT NULL DEFAULT 0,
+                    trigger_action TEXT DEFAULT '',
+                    session_id TEXT DEFAULT '',
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+                """
+            )
+        )
         conn.execute(
             text(
                 """
@@ -1092,6 +1172,18 @@ def init_db() -> None:
         }
         if "link_source" not in related_link_columns:
             conn.execute(text("ALTER TABLE project_related_links ADD COLUMN link_source TEXT DEFAULT 'manual'"))
+        exec_budget_entry_columns = {
+            row[1]
+            for row in conn.execute(text("PRAGMA table_info(project_exec_budget_entries)")).fetchall()
+        }
+        if "rate_year" not in exec_budget_entry_columns:
+            conn.execute(text("ALTER TABLE project_exec_budget_entries ADD COLUMN rate_year TEXT DEFAULT ''"))
+        actual_input_entry_columns = {
+            row[1]
+            for row in conn.execute(text("PRAGMA table_info(project_actual_input_entries)")).fetchall()
+        }
+        if "rate_year" not in actual_input_entry_columns:
+            conn.execute(text("ALTER TABLE project_actual_input_entries ADD COLUMN rate_year TEXT DEFAULT ''"))
         migrate_project_status_entries(conn)
         migrate_project_basic_info(conn)
         ensure_default_app_config(conn)
@@ -1214,10 +1306,255 @@ def get_project_runtime_settings() -> dict[str, str]:
     return {item["item_key"]: str(item.get("value", "")) for item in get_option_items("project_rules")}
 
 
+def get_shared_exec_labor_rates_json() -> str:
+    shared_items = {item["item_key"]: item for item in get_option_items("project_shared")}
+    value = normalize_text((shared_items.get("exec_labor_rates_json") or {}).get("value"))
+    if value and value != "{}":
+        return value
+    with engine.begin() as conn:
+        fallback = normalize_text(
+            conn.execute(
+                text(
+                    """
+                    SELECT COALESCE(exec_labor_rates_json, '{}')
+                    FROM project_basic_info
+                    WHERE COALESCE(exec_labor_rates_json, '{}') <> '{}'
+                    ORDER BY updated_at DESC
+                    LIMIT 1
+                    """
+                )
+            ).scalar()
+        )
+    return fallback or "{}"
+
+
+def get_shared_exec_labor_rates() -> dict[str, Any]:
+    try:
+        parsed = json.loads(get_shared_exec_labor_rates_json())
+        return parsed if isinstance(parsed, dict) else {}
+    except json.JSONDecodeError:
+        return {}
+
+
+def save_shared_exec_labor_rates(conn: Any, exec_labor_rates_json: str) -> None:
+    normalized_json = normalize_text(exec_labor_rates_json) or "{}"
+    conn.execute(
+        text(
+            """
+            INSERT INTO app_option_items (
+                group_key, item_key, label, value_text, sort_order, is_active, meta_json
+            ) VALUES (
+                'project_shared', 'exec_labor_rates_json', '공통 기준인건비', :value_text, 0, 1, '{}'
+            )
+            ON CONFLICT(group_key, item_key) DO UPDATE SET
+                value_text = excluded.value_text,
+                is_active = 1
+            """
+        ),
+        {"value_text": normalized_json},
+    )
+    load_app_config.cache_clear()
+
+
 def get_special_x_classification_rules() -> dict[str, list[str]]:
     return get_keyword_rule_groups("special_x_classification")
 
 
+def _safe_json_dumps(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), default=str)
+
+
+def log_save_event(
+    action_key: str,
+    entity_type: str,
+    entity_key: Any = "",
+    *,
+    session_id: Any = "",
+    status: str = "ok",
+    duration_ms: int = 0,
+    payload: Any = None,
+    error_message: Any = "",
+) -> None:
+    try:
+        with engine.begin() as conn:
+            conn.execute(
+                text(
+                    """
+                    INSERT INTO app_save_events (
+                        action_key, entity_type, entity_key, session_id,
+                        status, duration_ms, payload_json, error_message
+                    ) VALUES (
+                        :action_key, :entity_type, :entity_key, :session_id,
+                        :status, :duration_ms, :payload_json, :error_message
+                    )
+                    """
+                ),
+                {
+                    "action_key": normalize_text(action_key),
+                    "entity_type": normalize_text(entity_type),
+                    "entity_key": normalize_text(entity_key),
+                    "session_id": normalize_text(session_id),
+                    "status": normalize_text(status) or "ok",
+                    "duration_ms": max(int(duration_ms or 0), 0),
+                    "payload_json": _safe_json_dumps(payload or {}),
+                    "error_message": normalize_text(error_message),
+                },
+            )
+    except Exception as exc:
+        logger.warning("저장 이벤트 로그 기록 실패: %s", exc)
+
+
+def prune_old_backups() -> None:
+    backup_files = sorted(
+        (
+            path for path in BACKUP_DIR.glob("data-*.sqlite3")
+            if path.is_file()
+        ),
+        key=lambda path: path.stat().st_mtime,
+        reverse=True,
+    )
+    for stale_path in backup_files[DB_BACKUP_KEEP_COUNT:]:
+        try:
+            stale_path.unlink(missing_ok=True)
+        except Exception as exc:
+            logger.warning("오래된 백업 파일 정리 실패(%s): %s", stale_path.name, exc)
+
+
+def maybe_create_database_backup(trigger_action: str, session_id: Any = "") -> str:
+    now = time.monotonic()
+    if now - float(_DB_BACKUP_STATE.get("last_run_at") or 0.0) < DB_BACKUP_MIN_INTERVAL_SECONDS:
+        return ""
+    if not _DB_BACKUP_LOCK.acquire(blocking=False):
+        return ""
+    try:
+        now = time.monotonic()
+        if now - float(_DB_BACKUP_STATE.get("last_run_at") or 0.0) < DB_BACKUP_MIN_INTERVAL_SECONDS:
+            return ""
+        stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        temp_path = BACKUP_DIR / f".data-{stamp}.tmp"
+        final_path = BACKUP_DIR / f"data-{stamp}.sqlite3"
+        source_conn = sqlite3.connect(DB_PATH)
+        backup_conn = sqlite3.connect(temp_path)
+        try:
+            source_conn.backup(backup_conn)
+        finally:
+            backup_conn.close()
+            source_conn.close()
+        temp_path.replace(final_path)
+        file_size = final_path.stat().st_size if final_path.exists() else 0
+        _DB_BACKUP_STATE["last_run_at"] = time.monotonic()
+        prune_old_backups()
+        try:
+            with engine.begin() as conn:
+                conn.execute(
+                    text(
+                        """
+                        INSERT INTO db_backup_history (
+                            backup_file, file_size, trigger_action, session_id
+                        ) VALUES (
+                            :backup_file, :file_size, :trigger_action, :session_id
+                        )
+                        """
+                    ),
+                    {
+                        "backup_file": final_path.name,
+                        "file_size": int(file_size or 0),
+                        "trigger_action": normalize_text(trigger_action),
+                        "session_id": normalize_text(session_id),
+                    },
+                )
+            log_save_event(
+                "db_backup",
+                "system",
+                final_path.name,
+                session_id=session_id,
+                payload={"trigger_action": trigger_action, "file_size": int(file_size or 0)},
+            )
+        except Exception as exc:
+            logger.warning("DB 백업 이력 저장 실패: %s", exc)
+        return final_path.name
+    except Exception as exc:
+        logger.warning("DB 백업 생성 실패: %s", exc)
+        return ""
+    finally:
+        _DB_BACKUP_LOCK.release()
+
+
+def load_project_status_snapshot_payload(conn: Any, support_dept_code: str) -> dict[str, Any]:
+    normalized_code = normalize_text(support_dept_code)
+    if not normalized_code:
+        return {}
+    row = conn.execute(
+        text("SELECT * FROM project_status WHERE support_dept_code = :support_dept_code"),
+        {"support_dept_code": normalized_code},
+    ).mappings().first()
+    entry_set = load_project_status_entries_for_code(conn, normalized_code)
+    has_entries = any(entry_set.get(key) for key in entry_set)
+    if not row and not has_entries:
+        return {}
+    base = dict(row) if row else {"support_dept_code": normalized_code}
+    return {
+        "support_dept_code": normalized_code,
+        "support_dept_name": normalize_text(base.get("support_dept_name")),
+        "contract_amount": normalize_amount(base.get("contract_amount")),
+        "collection_amount": normalize_amount(base.get("collection_amount")),
+        "progress_rate": normalize_amount(base.get("progress_rate")),
+        "project_type": normalize_text(base.get("project_type")),
+        "expected_as_rate": normalize_amount(base.get("expected_as_rate")),
+        "expected_sga_rate": normalize_amount(base.get("expected_sga_rate")),
+        "expected_as_cost": normalize_amount(base.get("expected_as_cost")),
+        "expected_sga_budget": normalize_amount(base.get("expected_sga_budget")),
+        "change_round": normalize_text(base.get("change_round")),
+        "project_start_date": normalize_text(base.get("project_start_date")),
+        "project_end_date": normalize_text(base.get("project_end_date")),
+        "completion_status": normalize_text(base.get("completion_status")),
+        "notes": normalize_text(base.get("notes")),
+        "updated_at": normalize_text(base.get("updated_at")),
+        "collection_entries": entry_set.get("collection_entries", []),
+        "task_plan_entries": entry_set.get("task_plan_entries", []),
+        "exec_budget_entries": entry_set.get("exec_budget_entries", []),
+        "actual_input_entries": entry_set.get("actual_input_entries", []),
+    }
+
+
+def record_project_status_snapshot(
+    support_dept_code: str,
+    session_id: Any,
+    previous_snapshot: dict[str, Any],
+    next_snapshot: dict[str, Any],
+) -> None:
+    normalized_code = normalize_text(support_dept_code)
+    if not normalized_code:
+        return
+    try:
+        with engine.begin() as conn:
+            conn.execute(
+                text(
+                    """
+                    INSERT INTO project_status_snapshots (
+                        support_dept_code, action_key, session_id,
+                        previous_revision, revision,
+                        previous_snapshot_json, snapshot_json
+                    ) VALUES (
+                        :support_dept_code, 'project_status_save', :session_id,
+                        :previous_revision, :revision,
+                        :previous_snapshot_json, :snapshot_json
+                    )
+                    """
+                ),
+                {
+                    "support_dept_code": normalized_code,
+                    "session_id": normalize_text(session_id),
+                    "previous_revision": normalize_text((previous_snapshot or {}).get("updated_at")),
+                    "revision": normalize_text((next_snapshot or {}).get("updated_at")),
+                    "previous_snapshot_json": _safe_json_dumps(previous_snapshot or {}),
+                    "snapshot_json": _safe_json_dumps(next_snapshot or {}),
+                },
+            )
+    except Exception as exc:
+        logger.warning("프로젝트 스냅샷 기록 실패(%s): %s", normalized_code, exc)
+
+
 def save_project_runtime_setting(item_key: Any, value_text: Any) -> None:
     normalized_item_key = normalize_text(item_key)
     if not normalized_item_key:
@@ -1250,6 +1587,12 @@ def save_project_runtime_setting(item_key: Any, value_text: Any) -> None:
             },
         )
     load_app_config.cache_clear()
+    log_save_event(
+        "project_runtime_setting_save",
+        "project_runtime_setting",
+        normalized_item_key,
+        payload={"value_text": normalize_text(value_text)},
+    )
 
 
 def count_transactions() -> int:
@@ -2134,6 +2477,10 @@ def sync_auto_project_related_links() -> None:
 @app.on_event("startup")
 def on_startup() -> None:
     init_db()
+    with engine.begin() as conn:
+        corrected = sanitize_project_labor_amount_rows(conn)
+    if corrected:
+        logger.info("Sanitized project labor amounts for %s project(s)", corrected)
     auto_import_project_excels()
     sync_auto_project_related_links()
     normalize_all_collection_entry_storage()
@@ -2342,6 +2689,7 @@ def normalize_exec_budget_entry_row(row: dict[str, Any]) -> dict[str, Any]:
         "group": clean_row_text(row.get("group")),
         "grade": clean_row_text(row.get("grade")),
         "hours": clean_row_text(row.get("hours")),
+        "rate_year": clean_row_text(row.get("rate_year")),
         "dept_name": clean_row_text(row.get("dept_name")),
         "work_name": clean_row_text(row.get("work_name")),
         "account_code": clean_row_text(row.get("account_code")),
@@ -2355,6 +2703,7 @@ def normalize_actual_input_entry_row(row: dict[str, Any]) -> dict[str, Any]:
         "group": clean_row_text(row.get("group")),
         "grade": clean_row_text(row.get("grade")),
         "minutes": clean_row_text(row.get("minutes")),
+        "rate_year": clean_row_text(row.get("rate_year")),
         "label": clean_row_text(row.get("label")),
         "reference": clean_row_text(row.get("reference")),
         "note": clean_row_text(row.get("note")),
@@ -2535,10 +2884,10 @@ def replace_project_status_child_entries(
             text(
                 """
                 INSERT INTO project_exec_budget_entries (
-                    support_dept_code, position, group_name, grade, hours, dept_name,
+                    support_dept_code, position, group_name, grade, hours, rate_year, dept_name,
                     work_name, account_code, account_name, amount, updated_at
                 ) VALUES (
-                    :support_dept_code, :position, :group_name, :grade, :hours, :dept_name,
+                    :support_dept_code, :position, :group_name, :grade, :hours, :rate_year, :dept_name,
                     :work_name, :account_code, :account_name, :amount, CURRENT_TIMESTAMP
                 )
                 """
@@ -2549,6 +2898,7 @@ def replace_project_status_child_entries(
                 "group_name": normalized["group"],
                 "grade": normalized["grade"],
                 "hours": normalized["hours"],
+                "rate_year": normalized["rate_year"],
                 "dept_name": normalized["dept_name"],
                 "work_name": normalized["work_name"],
                 "account_code": normalized["account_code"],
@@ -2563,10 +2913,10 @@ def replace_project_status_child_entries(
             text(
                 """
                 INSERT INTO project_actual_input_entries (
-                    support_dept_code, position, group_name, grade, minutes, label,
+                    support_dept_code, position, group_name, grade, minutes, rate_year, label,
                     reference, note, amount, updated_at
                 ) VALUES (
-                    :support_dept_code, :position, :group_name, :grade, :minutes, :label,
+                    :support_dept_code, :position, :group_name, :grade, :minutes, :rate_year, :label,
                     :reference, :note, :amount, CURRENT_TIMESTAMP
                 )
                 """
@@ -2577,6 +2927,7 @@ def replace_project_status_child_entries(
                 "group_name": normalized["group"],
                 "grade": normalized["grade"],
                 "minutes": normalized["minutes"],
+                "rate_year": normalized["rate_year"],
                 "label": normalized["label"],
                 "reference": normalized["reference"],
                 "note": normalized["note"],
@@ -2633,7 +2984,7 @@ def load_project_status_entry_maps(conn: Any) -> dict[str, dict[str, list[dict[s
         text(
             """
             SELECT support_dept_code, position, group_name, grade, hours, dept_name,
-                   work_name, account_code, account_name, amount
+                   rate_year, work_name, account_code, account_name, amount
             FROM project_exec_budget_entries
             ORDER BY support_dept_code, position, id
             """
@@ -2648,6 +2999,7 @@ def load_project_status_entry_maps(conn: Any) -> dict[str, dict[str, list[dict[s
                     "group": row["group_name"],
                     "grade": row["grade"],
                     "hours": row["hours"],
+                    "rate_year": row["rate_year"],
                     "dept_name": row["dept_name"],
                     "work_name": row["work_name"],
                     "account_code": row["account_code"],
@@ -2660,7 +3012,7 @@ def load_project_status_entry_maps(conn: Any) -> dict[str, dict[str, list[dict[s
     actual_rows = conn.execute(
         text(
             """
-            SELECT support_dept_code, position, group_name, grade, minutes, label,
+            SELECT support_dept_code, position, group_name, grade, minutes, rate_year, label,
                    reference, note, amount
             FROM project_actual_input_entries
             ORDER BY support_dept_code, position, id
@@ -2676,6 +3028,7 @@ def load_project_status_entry_maps(conn: Any) -> dict[str, dict[str, list[dict[s
                     "group": row["group_name"],
                     "grade": row["grade"],
                     "minutes": row["minutes"],
+                    "rate_year": row["rate_year"],
                     "label": row["label"],
                     "reference": row["reference"],
                     "note": row["note"],
@@ -2803,6 +3156,7 @@ def migrate_project_basic_info(conn: Any) -> None:
 
 
 def save_project_basic_info_section(conn: Any, payload: dict[str, Any]) -> None:
+    save_shared_exec_labor_rates(conn, normalize_text(payload.get("exec_labor_rates_json")) or "{}")
     conn.execute(
         text(
             """
@@ -2892,7 +3246,7 @@ def load_project_status_entries_for_code(conn: Any, support_dept_code: str) -> d
     exec_rows = conn.execute(
         text(
             """
-            SELECT group_name, grade, hours, dept_name, work_name, account_code, account_name, amount
+            SELECT group_name, grade, hours, rate_year, dept_name, work_name, account_code, account_name, amount
             FROM project_exec_budget_entries
             WHERE support_dept_code = :support_dept_code
             ORDER BY position, id
@@ -2906,6 +3260,7 @@ def load_project_status_entries_for_code(conn: Any, support_dept_code: str) -> d
                 "group": row["group_name"],
                 "grade": row["grade"],
                 "hours": row["hours"],
+                "rate_year": row["rate_year"],
                 "dept_name": row["dept_name"],
                 "work_name": row["work_name"],
                 "account_code": row["account_code"],
@@ -2919,7 +3274,7 @@ def load_project_status_entries_for_code(conn: Any, support_dept_code: str) -> d
     actual_rows = conn.execute(
         text(
             """
-            SELECT group_name, grade, minutes, label, reference, note, amount
+            SELECT group_name, grade, minutes, rate_year, label, reference, note, amount
             FROM project_actual_input_entries
             WHERE support_dept_code = :support_dept_code
             ORDER BY position, id
@@ -2933,6 +3288,7 @@ def load_project_status_entries_for_code(conn: Any, support_dept_code: str) -> d
                 "group": row["group_name"],
                 "grade": row["grade"],
                 "minutes": row["minutes"],
+                "rate_year": row["rate_year"],
                 "label": row["label"],
                 "reference": row["reference"],
                 "note": row["note"],
@@ -3108,6 +3464,121 @@ def sum_row_amounts(rows: list[dict[str, Any]], amount_key: str = "amount") -> f
     return sum(normalize_amount(row.get(amount_key)) for row in rows)
 
 
+def _parse_labor_rates_json(raw_json: Any) -> dict[str, dict[str, float]]:
+    try:
+        parsed = json.loads(normalize_text(raw_json) or "{}")
+    except json.JSONDecodeError:
+        return {}
+    if not isinstance(parsed, dict):
+        return {}
+    normalized: dict[str, dict[str, float]] = {}
+    for year_key, bucket in parsed.items():
+        year_text = normalize_text(year_key)
+        if not year_text or not isinstance(bucket, dict):
+            continue
+        normalized[year_text] = {}
+        for grade_key, amount_value in bucket.items():
+            grade_text = normalize_text(grade_key)
+            if not grade_text:
+                continue
+            normalized[year_text][grade_text] = normalize_amount(amount_value)
+    return normalized
+
+
+def _resolve_labor_rate(
+    rates_by_year: dict[str, dict[str, float]],
+    grade: Any,
+    rate_year: Any,
+    fallback_year: Any = "",
+) -> float:
+    grade_text = normalize_text(grade)
+    if not grade_text:
+        return 0.0
+    year_candidates: list[str] = []
+    for value in (rate_year, fallback_year):
+        text_value = normalize_text(value)
+        if text_value and text_value not in year_candidates:
+            year_candidates.append(text_value)
+    if not year_candidates:
+        year_candidates.append(str(datetime.now().year))
+    for year_text in year_candidates:
+        year_bucket = rates_by_year.get(year_text) or {}
+        amount = normalize_amount(year_bucket.get(grade_text))
+        if amount:
+            return amount
+    return 0.0
+
+
+def _parse_exec_hours_value(value: Any) -> float:
+    digits = "".join(character for character in normalize_text(value) if character.isdigit())
+    if not digits:
+        return 0.0
+    return float(int(digits[:5]))
+
+
+def _parse_minutes_value(value: Any) -> float:
+    digits = "".join(character for character in normalize_text(value) if character.isdigit())
+    if not digits:
+        return 0.0
+    return float(int(digits))
+
+
+def sanitize_project_labor_amount_rows(conn: Any) -> int:
+    shared_rates = _parse_labor_rates_json(get_shared_exec_labor_rates_json())
+    rows = conn.execute(
+        text(
+            """
+            SELECT support_dept_code, COALESCE(exec_labor_rates_json, '{}') AS exec_labor_rates_json
+            FROM project_status
+            WHERE COALESCE(support_dept_code, '') <> ''
+            """
+        )
+    ).mappings().all()
+    updated_count = 0
+    for row in rows:
+        code = normalize_text(row.get("support_dept_code"))
+        if not code:
+            continue
+        entry_set = load_project_status_entries_for_code(conn, code)
+        exec_entries = list(entry_set.get("exec_budget_entries", []))
+        actual_entries = list(entry_set.get("actual_input_entries", []))
+        rates = _parse_labor_rates_json(row.get("exec_labor_rates_json")) or shared_rates
+        changed = False
+
+        for entry in exec_entries:
+            if normalize_text(entry.get("group")) != "labor":
+                continue
+            hours_value = _parse_exec_hours_value(entry.get("hours"))
+            next_amount = _resolve_labor_rate(rates, entry.get("grade"), entry.get("rate_year")) * hours_value
+            if abs(normalize_amount(entry.get("amount")) - next_amount) > 0.5:
+                entry["amount"] = next_amount
+                changed = True
+
+        for entry in actual_entries:
+            if normalize_text(entry.get("group")) != "labor":
+                continue
+            minutes_value = _parse_minutes_value(entry.get("minutes"))
+            next_amount = _resolve_labor_rate(rates, entry.get("grade"), entry.get("rate_year")) * (minutes_value / 60.0 if minutes_value else 0.0)
+            if abs(normalize_amount(entry.get("amount")) - next_amount) > 0.5:
+                entry["amount"] = next_amount
+                changed = True
+
+        if not changed:
+            continue
+
+        replace_project_status_child_entries(
+            conn,
+            code,
+            entry_set.get("collection_entries", []),
+            entry_set.get("task_plan_entries", []),
+            exec_entries,
+            actual_entries,
+        )
+        sync_project_status_cache_row(conn, code)
+        updated_count += 1
+    return updated_count
+
+
 def get_support_department_options() -> list[dict[str, str]]:
     with engine.begin() as conn:
         rows = conn.execute(
@@ -3523,6 +3994,8 @@ def build_transaction_payload(raw: dict[str, Any], source_file: str = "") -> dic
 
 def save_transaction(payload: dict[str, Any], record_id: int | None = None) -> None:
     init_db()
+    started_at = time.perf_counter()
+    normalized_record_id = str(record_id) if record_id is not None else ""
     params = {
         **payload,
         "record_id": record_id,
@@ -3647,6 +4120,21 @@ def save_transaction(payload: dict[str, Any], record_id: int | None = None) -> N
             ),
             params,
         )
+    duration_ms = int((time.perf_counter() - started_at) * 1000)
+    log_save_event(
+        "transaction_save",
+        "transaction",
+        normalized_record_id or normalize_text(payload.get("voucher_number")),
+        session_id=payload.get("client_session_id"),
+        duration_ms=duration_ms,
+        payload={
+            "record_id": normalized_record_id,
+            "voucher_number": normalize_text(payload.get("voucher_number")),
+            "support_dept_code": normalize_text(payload.get("support_dept_code")),
+            "account_code": normalize_text(payload.get("account_code")),
+        },
+    )
+    maybe_create_database_backup("transaction_save", payload.get("client_session_id"))
 
 
 def get_record_for_edit(record_id: int | None) -> dict[str, Any]:
@@ -4015,6 +4503,12 @@ def save_project_comparison_note(support_dept_code: str | None, item_key: str |
                     "item_key": normalized_item_key,
                 },
             )
+    log_save_event(
+        "project_comparison_note_save",
+        "project_comparison_note",
+        f"{code}:{normalized_item_key}",
+        payload={"has_note": bool(normalized_note)},
+    )
 
 
 def get_project_analysis_settings_map() -> dict[str, dict[str, object]]:
@@ -4092,6 +4586,16 @@ def save_project_analysis_settings(
                 "labor_joint_exempt": 1 if next_labor_joint_exempt else 0,
             },
         )
+    log_save_event(
+        "project_analysis_settings_save",
+        "project_analysis_settings",
+        code,
+        payload={
+            "inactive_related_count": len(next_inactive_related_codes),
+            "labor_joint_exempt": next_labor_joint_exempt,
+            "has_detail_note": bool(next_detail_note),
+        },
+    )
 
 
 def get_project_status_for_edit(support_dept_code: str | None) -> dict[str, Any]:
@@ -4251,10 +4755,16 @@ def get_project_status_for_edit(support_dept_code: str | None) -> dict[str, Any]
     result.pop("task_plan_entries_json", None)
     result.pop("exec_budget_entries_json", None)
     result.pop("actual_input_entries_json", None)
+    shared_labor_rates = get_shared_exec_labor_rates()
     try:
-        result["exec_labor_rates"] = json.loads(normalize_text(result.pop("exec_labor_rates_json", "{}")) or "{}")
+        project_labor_rates = json.loads(normalize_text(result.pop("exec_labor_rates_json", "{}")) or "{}")
     except json.JSONDecodeError:
-        result["exec_labor_rates"] = {}
+        project_labor_rates = {}
+    # 기준인건비는 전 프로젝트 공통값을 우선 사용한다.
+    if isinstance(shared_labor_rates, dict) and shared_labor_rates:
+        result["exec_labor_rates"] = shared_labor_rates
+    else:
+        result["exec_labor_rates"] = project_labor_rates if isinstance(project_labor_rates, dict) else {}
     return merge_project_external_fields(
         result,
         contract_info_map.get(normalize_text(result.get("support_dept_code"))),
@@ -4402,6 +4912,18 @@ def save_project_page_state(payload: dict[str, Any]) -> None:
         )
     for base_code, related_codes in related_project_selections.items():
         save_project_related_links(base_code, related_codes)
+    log_save_event(
+        "project_page_state_save",
+        "project_page_state",
+        session_id,
+        session_id=session_id,
+        payload={
+            "selected_code": selected_code,
+            "selected_year": selected_year,
+            "analysis_open": bool(analysis_open),
+            "related_selection_count": len(related_project_selections),
+        },
+    )
 
 
 def get_project_related_links_map() -> dict[str, list[str]]:
@@ -4471,6 +4993,13 @@ def save_project_quick_links(session_id: str | None, codes: list[str]) -> None:
                     "sort_order": sort_order,
                 },
             )
+    log_save_event(
+        "project_quick_links_save",
+        "project_quick_links",
+        "projects",
+        session_id=session_id,
+        payload={"codes": normalized_codes},
+    )
 
 
 def get_process_cost_quick_links() -> list[str]:
@@ -4519,6 +5048,12 @@ def save_process_cost_quick_links(codes: list[str]) -> None:
                     "sort_order": sort_order,
                 },
             )
+    log_save_event(
+        "process_cost_quick_links_save",
+        "project_quick_links",
+        "process_cost",
+        payload={"codes": normalized_codes},
+    )
 
 
 def get_project_uncontracted_classification_map() -> dict[str, str]:
@@ -4570,6 +5105,12 @@ def save_project_uncontracted_classification(support_dept_code: Any, category: A
                 "category": normalized_category,
             },
         )
+    log_save_event(
+        "project_uncontracted_classification_save",
+        "project_uncontracted_classification",
+        normalized_code,
+        payload={"category": normalized_category},
+    )
 
 
 def save_project_related_links(base_support_dept_code: str, related_codes: list[Any]) -> None:
@@ -4619,6 +5160,12 @@ def save_project_related_links(base_support_dept_code: str, related_codes: list[
                     "related_support_dept_code": related_code,
                 },
             )
+    log_save_event(
+        "project_related_links_save",
+        "project_related_links",
+        base_code,
+        payload={"related_codes": normalized_codes},
+    )
 
 
 def get_project_year_options() -> list[int]:
@@ -5099,26 +5646,69 @@ def get_project_account_breakdowns(selected_year: int | None) -> dict[str, dict[
                   AND ({REVENUE_SQL} OR accounting_category IN ('원가', '판관비'))
                   {year_clause}
                 GROUP BY support_dept_code, breakdown_kind, account_code, account_name
-                ORDER BY support_dept_code, breakdown_kind, total_amount DESC, account_code, account_name
+                """
+            ),
+            params,
+        ).mappings().all()
+        cost_detail_rows = conn.execute(
+            text(
+                f"""
+                SELECT
+                    COALESCE(support_dept_code, '') AS support_dept_code,
+                    COALESCE(voucher_number, '') AS voucher_number,
+                    COALESCE(posting_date, '') AS posting_date,
+                    COALESCE(partner_name, '') AS partner_name,
+                    COALESCE(partner_code, '') AS partner_code,
+                    COALESCE(account_code, '') AS account_code,
+                    COALESCE(account_name, '') AS account_name,
+                    COALESCE(amount, 0) AS amount
+                FROM transactions
+                WHERE COALESCE(support_dept_code, '') <> ''
+                  AND support_dept_code NOT IN ('ZZZZZZ')
+                  AND COALESCE(support_dept_name, '') <> ''
+                  AND support_dept_name NOT IN ('공통', '경영지원부', '기술개발센터', '임원실', '기술개발부', '총괄기획실')
+                  AND accounting_category = '원가'
+                  {year_clause}
                 """
             ),
             params,
         ).mappings().all()
 
-    result: dict[str, dict[str, dict[str, float]]] = {}
+    result: dict[str, dict[str, Any]] = {}
     for row in rows:
         code = row["support_dept_code"]
         kind = row["breakdown_kind"]
         if kind == "other":
             continue
         _, _, label = normalize_account_display(row["account_code"], row["account_name"])
-        result.setdefault(code, {"revenue": {}, "cost": {}, "sga": {}})
+        result.setdefault(code, {"revenue": {}, "cost": {}, "sga": {}, "cost_detail": []})
         result[code][kind][label] = result[code][kind].get(label, 0.0) + float(row["total_amount"] or 0)
 
+    for row in cost_detail_rows:
+        code = normalize_text(row["support_dept_code"])
+        if not code:
+            continue
+        account_code, account_name, label = normalize_account_display(row["account_code"], row["account_name"])
+        result.setdefault(code, {"revenue": {}, "cost": {}, "sga": {}, "cost_detail": []})
+        result[code]["cost_detail"].append(
+            {
+                "posting_date": build_transaction_posting_display(row["voucher_number"], row["posting_date"]),
+                "partner_name": normalize_text(row["partner_name"]),
+                "partner_code": normalize_text(row["partner_code"]),
+                "account_code": account_code,
+                "account_name": account_name,
+                "label": label,
+                "amount": float(row["amount"] or 0),
+            }
+        )
+
     normalized_result: dict[str, dict[str, list[dict[str, Any]]]] = {}
     for code, buckets in result.items():
         normalized_result[code] = {}
         for kind, entries in buckets.items():
+            if kind == "cost_detail":
+                normalized_result[code][kind] = list(entries)
+                continue
             normalized_result[code][kind] = [
                 {
                     "label": label,
@@ -5474,26 +6064,34 @@ def _get_project_contract_meta() -> dict[str, dict[str, Any]]:
     return result
 
 
-def _get_project_actual_sga_summary(codes: list[str]) -> dict[str, dict[str, Any]]:
+def _get_project_actual_input_group_summary(
+    codes: list[str],
+    group_names: list[str],
+) -> dict[str, dict[str, Any]]:
     normalized_codes = [normalize_text(code) for code in codes if normalize_text(code)]
-    if not normalized_codes:
+    normalized_groups = [normalize_text(group) for group in group_names if normalize_text(group)]
+    if not normalized_codes or not normalized_groups:
         return {}
-    in_clause, params = build_in_clause("actual_sga_code", normalized_codes)
+    in_clause, params = build_in_clause("actual_input_code", normalized_codes)
+    group_clause, group_params = build_in_clause("actual_input_group", normalized_groups)
+    params.update(group_params)
     with engine.begin() as conn:
         rows = conn.execute(
             text(
                 f"""
                 SELECT
                     support_dept_code,
+                    COALESCE(group_name, '') AS group_name,
                     COALESCE(label, '') AS label,
                     COALESCE(reference, '') AS reference,
                     COALESCE(note, '') AS note,
                     COALESCE(grade, '') AS grade,
                     COALESCE(minutes, '') AS minutes,
-                    COALESCE(amount, 0) AS amount
+                    COALESCE(amount, 0) AS amount,
+                    COALESCE(updated_at, '') AS updated_at
                 FROM project_actual_input_entries
                 WHERE support_dept_code IN ({in_clause})
-                  AND COALESCE(group_name, '') = 'sga'
+                  AND COALESCE(group_name, '') IN ({group_clause})
                 ORDER BY position, id
                 """
             ),
@@ -5527,10 +6125,23 @@ def _get_project_actual_sga_summary(codes: list[str]) -> dict[str, dict[str, Any
             "amount": total_amount,
             "has_detail_trace": has_detail_trace,
             "distinct_labels": distinct_labels,
+            "last_updated_at": max((normalize_text(item.get("updated_at")) for item in code_rows), default=""),
         }
     return result
 
 
+def _get_project_actual_sga_summary(codes: list[str]) -> dict[str, dict[str, Any]]:
+    return _get_project_actual_input_group_summary(codes, ["sga"])
+
+
+def _get_project_actual_labor_summary(codes: list[str]) -> dict[str, dict[str, Any]]:
+    return _get_project_actual_input_group_summary(codes, ["labor", "labor_adjustment", "labor_joint"])
+
+
+def _get_project_actual_as_summary(codes: list[str]) -> dict[str, dict[str, Any]]:
+    return _get_project_actual_input_group_summary(codes, ["as"])
+
+
 def _get_project_exec_budget_summary(codes: list[str]) -> dict[str, dict[str, float]]:
     normalized_codes = [normalize_text(code) for code in codes if normalize_text(code)]
     if not normalized_codes:
@@ -5734,6 +6345,7 @@ def get_process_cost_project_detail(
     selected_year: int | None,
     support_dept_code: str,
     include_related: bool = False,
+    active_related_codes: list[str] | None = None,
 ) -> dict[str, Any]:
     code = normalize_text(support_dept_code)
     if not code:
@@ -5748,9 +6360,20 @@ def get_process_cost_project_detail(
     normalized_source = normalize_text(source).lower()
     contract_meta_map = _get_project_contract_meta()
     contract_meta = contract_meta_map.get(code, {})
-    related_clusters = _build_process_cost_related_clusters() if include_related else {}
-    cluster_codes = related_clusters.get(code, [code]) if include_related else [code]
+    saved_related_codes = get_process_cost_related_codes(code)
+    active_related_codes = [
+        normalize_text(item)
+        for item in (active_related_codes or [])
+        if normalize_text(item)
+    ]
+    active_related_codes = [
+        item for item in active_related_codes
+        if item != code and item in saved_related_codes
+    ]
+    cluster_codes = [code, *active_related_codes] if include_related else [code]
     actual_sga_summary_map = _get_project_actual_sga_summary(cluster_codes)
+    actual_labor_summary_map = _get_project_actual_labor_summary(cluster_codes)
+    actual_as_summary_map = _get_project_actual_as_summary(cluster_codes)
     exec_budget_summary_map = _get_project_exec_budget_summary(cluster_codes)
     if normalized_source == "wehago":
         init_wehago_compare_db(engine)
@@ -5897,18 +6520,40 @@ def get_process_cost_project_detail(
         planned_cost_plan_amount = normalize_amount((exec_budget_summary_map.get(code) or {}).get("cost_plan"))
     revenue_amount = normalize_amount(summary_row.get("revenue_amount"))
     ledger_expense_amount = normalize_amount(summary_row.get("expense_amount"))
-    labor_amount = normalize_amount(summary_row.get("labor_amount"))
+    ledger_labor_amount = normalize_amount(summary_row.get("labor_amount"))
     outsourcing_amount = normalize_amount(summary_row.get("outsourcing_amount"))
     ledger_sga_amount = normalize_amount(summary_row.get("sga_amount"))
+    actual_labor_amount = sum(
+        normalize_amount((actual_labor_summary_map.get(member) or {}).get("amount"))
+        for member in cluster_codes
+    )
     real_project_actual_sga_amount = 0.0
+    actual_input_last_updated_at = ""
+    for member in cluster_codes:
+        updated_at = normalize_text((actual_labor_summary_map.get(member) or {}).get("last_updated_at"))
+        if updated_at and updated_at > actual_input_last_updated_at:
+            actual_input_last_updated_at = updated_at
     for member in cluster_codes:
         member_expected_sga_budget = normalize_amount(contract_meta_map.get(member, {}).get("expected_sga_budget"))
         actual_summary = actual_sga_summary_map.get(member)
         if _is_real_project_actual_sga(actual_summary, member_expected_sga_budget):
             real_project_actual_sga_amount += normalize_amount((actual_summary or {}).get("amount"))
-    sga_amount = ledger_sga_amount + real_project_actual_sga_amount
-    expense_amount = ledger_expense_amount + real_project_actual_sga_amount
-    design_cost_amount = max(ledger_expense_amount - labor_amount - outsourcing_amount - ledger_sga_amount, 0.0)
+        updated_at = normalize_text((actual_summary or {}).get("last_updated_at"))
+        if updated_at and updated_at > actual_input_last_updated_at:
+            actual_input_last_updated_at = updated_at
+    actual_as_amount = sum(
+        normalize_amount((actual_as_summary_map.get(member) or {}).get("amount"))
+        for member in cluster_codes
+    )
+    actual_sga_amount = sum(
+        normalize_amount((actual_sga_summary_map.get(member) or {}).get("amount"))
+        for member in cluster_codes
+    )
+    labor_amount = actual_labor_amount if actual_labor_amount > 0 else ledger_labor_amount
+    as_amount = actual_as_amount if actual_as_amount > 0 else as_cost_amount
+    sga_amount = actual_sga_amount if actual_sga_amount > 0 else ledger_sga_amount
+    design_cost_amount = max(ledger_expense_amount - ledger_labor_amount - outsourcing_amount - ledger_sga_amount, 0.0)
+    expense_amount = labor_amount + outsourcing_amount + design_cost_amount + as_amount + sga_amount
     profit_amount = revenue_amount - expense_amount
 
     target_base = (
@@ -5922,7 +6567,7 @@ def get_process_cost_project_detail(
         {"phase": "직접인건비", "target_amount": planned_labor_amount, "actual_amount": labor_amount},
         {"phase": "외주비", "target_amount": planned_outsource_amount, "actual_amount": outsourcing_amount},
         {"phase": "제경비", "target_amount": planned_cost_plan_amount, "actual_amount": design_cost_amount},
-        {"phase": "A/S비", "target_amount": as_cost_amount, "actual_amount": as_cost_amount},
+        {"phase": "A/S비", "target_amount": as_cost_amount, "actual_amount": as_amount},
         {"phase": "판관비", "target_amount": expected_sga_budget, "actual_amount": sga_amount},
     ]
     for row in phase_rows:
@@ -5932,6 +6577,7 @@ def get_process_cost_project_detail(
     normalized_accounts = []
     for row in account_rows:
         amount = normalize_amount(row.get("amount"))
+        last_posting_date = normalize_text(row.get("last_posting_date")) or normalize_text(summary_row.get("last_posting_date"))
         normalized_accounts.append(
             {
                 "account_code": normalize_text(row.get("account_code")),
@@ -5939,22 +6585,28 @@ def get_process_cost_project_detail(
                 "amount": amount,
                 "row_count": int(row.get("row_count") or 0),
                 "share_rate": _safe_ratio(amount, expense_amount),
-                "last_posting_date": normalize_text(row.get("last_posting_date")),
+                "last_posting_date": last_posting_date[:10] if last_posting_date else "",
             }
         )
-    if real_project_actual_sga_amount > 0:
+    if actual_labor_amount > 0:
         normalized_accounts.append(
             {
-                "account_code": "PROJECT-SGA",
-                "account_name": "판관비(프로젝트 정보)",
-                "amount": real_project_actual_sga_amount,
-                "row_count": sum(len((actual_sga_summary_map.get(member) or {}).get("rows") or []) for member in cluster_codes),
-                "share_rate": _safe_ratio(real_project_actual_sga_amount, expense_amount),
+                "account_code": "PROJECT-LABOR",
+                "account_name": "직접인건비(프로젝트 정보)",
+                "amount": actual_labor_amount,
+                "row_count": sum(len((actual_labor_summary_map.get(member) or {}).get("rows") or []) for member in cluster_codes),
+                "share_rate": _safe_ratio(actual_labor_amount, expense_amount),
                 "last_posting_date": "",
             }
         )
-        normalized_accounts.sort(key=lambda item: (-normalize_amount(item.get("amount")), normalize_text(item.get("account_code"))))
-        normalized_accounts = normalized_accounts[:14]
+    normalized_accounts = [
+        row
+        for row in normalized_accounts
+        if normalize_text(row.get("account_code")) != "PROJECT-SGA"
+        and "판관비" not in normalize_text(row.get("account_name"))
+    ]
+    normalized_accounts.sort(key=lambda item: (-normalize_amount(item.get("amount")), normalize_text(item.get("account_code"))))
+    normalized_accounts = normalized_accounts[:14]
 
     normalized_monthly = []
     for row in monthly_rows:
@@ -5982,13 +6634,14 @@ def get_process_cost_project_detail(
             "profit_rate": _safe_ratio(profit_amount, revenue_amount),
             "target_cost_amount": target_base,
             "execution_rate": _safe_ratio(expense_amount, target_base),
-            "last_posting_date": normalize_text(summary_row.get("last_posting_date")),
+            "last_posting_date": normalize_text(summary_row.get("last_posting_date"))[:10],
             "voucher_count": int(summary_row.get("voucher_count") or 0),
             "row_count": int(summary_row.get("row_count") or 0),
             "included_codes": cluster_codes if include_related else [code],
             "expected_sga_budget": expected_sga_budget,
             "ledger_sga_amount": ledger_sga_amount,
             "project_actual_sga_amount": real_project_actual_sga_amount,
+            "project_actual_labor_amount": actual_labor_amount,
         },
         "phase_rows": phase_rows,
         "account_rows": normalized_accounts,
@@ -6010,6 +6663,7 @@ def render_process_cost_page(
     end_year: int | None = None,
     code: str | None = None,
     include_related: bool = False,
+    active_related: str | None = None,
     message: str = "",
 ) -> HTMLResponse:
     init_db()
@@ -6048,12 +6702,32 @@ def render_process_cost_page(
         (item for item in project_options if normalize_text(item.get("support_dept_code")) == selected_code),
         None,
     )
+    related_codes = get_process_cost_related_codes(selected_code)
+    active_related_codes: list[str] = []
+    if include_related and selected_code:
+        normalized_active_related = normalize_text(active_related)
+        if normalized_active_related in {"-", "__none__"}:
+            active_related_codes = []
+        else:
+            requested_active_codes = [
+                normalize_text(value)
+                for value in normalized_active_related.split(",")
+                if normalize_text(value)
+            ]
+            if requested_active_codes:
+                active_related_codes = [
+                    value for value in requested_active_codes
+                    if value != selected_code and value in related_codes
+                ]
+            else:
+                active_related_codes = list(related_codes)
 
     detail = get_process_cost_project_detail(
         normalized_source,
         None,
         selected_code,
         include_related=include_related,
+        active_related_codes=active_related_codes,
     )
     context = {
         **base_context(request, message),
@@ -6067,7 +6741,8 @@ def render_process_cost_page(
         "process_cost_include_related": include_related,
         "process_cost_projects": project_options,
         "process_cost_detail": detail,
-        "process_cost_related_codes": get_process_cost_related_codes(selected_code),
+        "process_cost_related_codes": related_codes,
+        "process_cost_active_related_codes": active_related_codes,
         "process_cost_quick_link_codes": get_process_cost_quick_links(),
     }
     return templates.TemplateResponse(request, "process_cost.html", context)
@@ -6163,8 +6838,105 @@ def parse_excel_upload(upload_file: UploadFile) -> int:
 
     sheet = workbook.active
     headers = [canonical_header_name(cell.value) for cell in next(sheet.iter_rows(min_row=1, max_row=1))]
-    inserted = 0
+    if import_kind == "transactions":
+        rows_to_insert: list[dict[str, Any]] = []
+        inserted = 0
+        insert_sql = text(
+            """
+            INSERT INTO transactions (
+                approval_status,
+                voucher_number,
+                account_code,
+                account_name,
+                debit_supply,
+                debit_vat,
+                credit_supply,
+                credit_vat,
+                issuing_dept_code,
+                issuing_dept_name,
+                confirmed_voucher_number,
+                support_dept_code,
+                support_dept_name,
+                cost_dept_code,
+                cost_dept_name,
+                memo1,
+                memo2,
+                partner_code,
+                partner_name,
+                tax_code,
+                posting_date,
+                voucher_type,
+                management_item,
+                accounting_category,
+                amount,
+                year,
+                month,
+                day,
+                source_file,
+                last_editor_session_id,
+                last_client_submitted_at
+            ) VALUES (
+                :approval_status,
+                :voucher_number,
+                :account_code,
+                :account_name,
+                :debit_supply,
+                :debit_vat,
+                :credit_supply,
+                :credit_vat,
+                :issuing_dept_code,
+                :issuing_dept_name,
+                :confirmed_voucher_number,
+                :support_dept_code,
+                :support_dept_name,
+                :cost_dept_code,
+                :cost_dept_name,
+                :memo1,
+                :memo2,
+                :partner_code,
+                :partner_name,
+                :tax_code,
+                :posting_date,
+                :voucher_type,
+                :management_item,
+                :accounting_category,
+                :amount,
+                :year,
+                :month,
+                :day,
+                :source_file,
+                '',
+                ''
+            )
+            """
+        )
 
+        for row in sheet.iter_rows(min_row=2, values_only=True):
+            raw: dict[str, Any] = {}
+            has_value = False
+            for index, value in enumerate(row):
+                field_name = headers[index] if index < len(headers) else None
+                if field_name:
+                    raw[field_name] = value
+                if normalize_text(value):
+                    has_value = True
+            if not has_value:
+                continue
+            payload = build_transaction_payload(raw, source_file=upload_file.filename or "")
+            if not payload["voucher_number"] and not payload["account_code"] and not payload["account_name"]:
+                continue
+            rows_to_insert.append(payload)
+            inserted += 1
+
+        with engine.begin() as conn:
+            conn.execute(
+                text("DELETE FROM transactions WHERE COALESCE(source_file, '') <> ''")
+            )
+            if rows_to_insert:
+                conn.execute(insert_sql, rows_to_insert)
+        return inserted
+
+    inserted = 0
     for row in sheet.iter_rows(min_row=2, values_only=True):
         raw: dict[str, Any] = {}
         has_value = False
@@ -6174,16 +6946,13 @@ def parse_excel_upload(upload_file: UploadFile) -> int:
                 raw[field_name] = value
             if normalize_text(value):
                 has_value = True
-
         if not has_value:
             continue
-
         payload = build_transaction_payload(raw, source_file=upload_file.filename or "")
         if not payload["voucher_number"] and not payload["account_code"] and not payload["account_name"]:
             continue
         save_transaction(payload)
         inserted += 1
-
     return inserted
 
 
@@ -6193,13 +6962,118 @@ def import_excel_path(path: Path) -> int:
         return parse_excel_upload(upload)
 
 
+def _extract_filename_date_score(filename: str) -> int:
+    text_name = normalize_text(filename)
+    if not text_name:
+        return 0
+    tokens = re.findall(r"(\d{6,8})", text_name)
+    if not tokens:
+        return 0
+    best = 0
+    for token in tokens:
+        try:
+            if len(token) == 8:
+                score = int(token)
+            elif len(token) == 6:
+                score = int(f"20{token}")
+            else:
+                continue
+        except ValueError:
+            continue
+        if score > best:
+            best = score
+    return best
+
+
+def _transaction_file_priority(path: Path) -> tuple[int, int, float]:
+    name = normalize_text(path.name).lower()
+    voucher_sort_bonus = 1 if "voucher_sort" in name else 0
+    date_score = _extract_filename_date_score(path.name)
+    mtime = 0.0
+    try:
+        mtime = path.stat().st_mtime
+    except OSError:
+        mtime = 0.0
+    return (voucher_sort_bonus, date_score, mtime)
+
+
+def _collect_auto_import_excel_files() -> list[Path]:
+    scan_dirs = [BASE_DIR]
+    extra_roots = [normalize_text(os.getenv("PROJECT_AUTO_IMPORT_DIRS")), normalize_text(os.getenv("WEHAGO_SOURCE_ROOT"))]
+    fallback_wehago_dir = BASE_DIR.parent / "WEHAGO_DB"
+    if fallback_wehago_dir.exists():
+        extra_roots.append(str(fallback_wehago_dir))
+
+    seen_dirs: set[str] = set()
+    for root in extra_roots:
+        if not root:
+            continue
+        for part in root.split(os.pathsep):
+            normalized_part = normalize_text(part)
+            if not normalized_part:
+                continue
+            if normalized_part in seen_dirs:
+                continue
+            seen_dirs.add(normalized_part)
+            candidate = Path(normalized_part)
+            if candidate.exists() and candidate.is_dir():
+                scan_dirs.append(candidate)
+
+    file_map: dict[str, Path] = {}
+    for directory in scan_dirs:
+        for path in sorted(directory.glob("*.xlsx")):
+            if path.name.startswith("~$"):
+                continue
+            if path.name not in file_map:
+                file_map[path.name] = path
+                continue
+            existing = file_map[path.name]
+            if _transaction_file_priority(path) > _transaction_file_priority(existing):
+                file_map[path.name] = path
+    return sorted(file_map.values(), key=lambda item: item.name)
+
+
+def _get_transaction_source_last_updated(source_file: str) -> datetime | None:
+    with engine.begin() as conn:
+        row = conn.execute(
+            text(
+                """
+                SELECT MAX(updated_at) AS last_updated_at
+                FROM transactions
+                WHERE source_file = :source_file
+                """
+            ),
+            {"source_file": normalize_text(source_file)},
+        ).mappings().first()
+    raw_value = normalize_text((row or {}).get("last_updated_at"))
+    if not raw_value:
+        return None
+    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S"):
+        try:
+            return datetime.strptime(raw_value[:19], fmt)
+        except ValueError:
+            continue
+    return None
+
+
+def _should_reimport_transaction_file(path: Path, known_files: set[str]) -> bool:
+    if path.name not in known_files:
+        return True
+    if count_transactions() <= 0:
+        return True
+    db_last_updated = _get_transaction_source_last_updated(path.name)
+    if not db_last_updated:
+        return True
+    try:
+        file_mtime = datetime.fromtimestamp(path.stat().st_mtime)
+    except OSError:
+        return False
+    return file_mtime > db_last_updated
+
+
 def auto_import_project_excels() -> None:
     init_db()
-    excel_files = [
-        path
-        for path in sorted(BASE_DIR.glob("*.xlsx"))
-        if not path.name.startswith("~$")
-    ]
+    excel_files = _collect_auto_import_excel_files()
     if not excel_files:
         return
 
@@ -6218,6 +7092,7 @@ def auto_import_project_excels() -> None:
         ):
             return
 
+    transaction_candidates: list[Path] = []
     for excel_path in excel_files:
         if not zipfile.is_zipfile(excel_path):
             logger.warning("Skipping non-Excel or temporary workbook during auto-import: %s", excel_path.name)
@@ -6231,6 +7106,9 @@ def auto_import_project_excels() -> None:
             logger.exception("Failed to inspect workbook during auto-import: %s", excel_path.name)
             continue
         import_kind = detect_excel_import_kind(workbook, excel_path.name)
+        if import_kind == "transactions":
+            transaction_candidates.append(excel_path)
+            continue
         if import_kind == "contract_status" and excel_path.name in known_contract_files:
             continue
         if import_kind == "change_contract_summary" and excel_path.name in known_change_summary_files:
@@ -6249,6 +7127,25 @@ def auto_import_project_excels() -> None:
         except Exception:
             logger.exception("Failed to auto-import workbook: %s", excel_path.name)
 
+    if not transaction_candidates:
+        return
+
+    selected_transaction_file = max(transaction_candidates, key=_transaction_file_priority)
+    if not _should_reimport_transaction_file(selected_transaction_file, known_files):
+        return
+    try:
+        with selected_transaction_file.open("rb") as excel_file:
+            upload = UploadFile(filename=selected_transaction_file.name, file=excel_file)
+            inserted = parse_excel_upload(upload)
+        logger.info(
+            "Auto-imported %s transaction rows from %s (selected from %s candidates)",
+            inserted,
+            selected_transaction_file,
+            len(transaction_candidates),
+        )
+    except Exception:
+        logger.exception("Failed to auto-import transaction workbook: %s", selected_transaction_file.name)
+
 
 def normalize_all_collection_entry_storage() -> None:
     with engine.begin() as conn:
@@ -6469,15 +7366,44 @@ def build_project_status_payload(payload: dict[str, Any]) -> dict[str, Any]:
         row["group"] = "joint"
     task_plan_rows = task_plan_department_rows + task_plan_outsource_rows + task_plan_joint_rows
 
-    exec_labor_rows = build_triplet_amount_rows(
-        payload.get("exec_labor_grade[]", []),
-        payload.get("exec_labor_hours[]", []),
-        payload.get("exec_labor_amount[]", []),
-        first_key="grade",
-        second_key="hours",
+    exec_labor_grades = payload.get("exec_labor_grade[]", [])
+    exec_labor_hours = payload.get("exec_labor_hours[]", [])
+    exec_labor_amounts = payload.get("exec_labor_amount[]", [])
+    exec_labor_rate_years = payload.get("exec_labor_rate_year[]", [])
+    labor_rates_by_year = _parse_labor_rates_json(payload.get("exec_labor_rates_json"))
+    if not labor_rates_by_year:
+        labor_rates_by_year = _parse_labor_rates_json(get_shared_exec_labor_rates_json())
+    fallback_rate_year = normalize_text(payload.get("year")) or str(datetime.now().year)
+
+    exec_labor_rows: list[dict[str, Any]] = []
+    exec_labor_max_length = max(
+        len(exec_labor_grades),
+        len(exec_labor_hours),
+        len(exec_labor_amounts),
+        len(exec_labor_rate_years),
     )
-    for row in exec_labor_rows:
-        row["group"] = "labor"
+    for index in range(exec_labor_max_length):
+        row = {
+            "grade": exec_labor_grades[index] if index < len(exec_labor_grades) else "",
+            "hours": exec_labor_hours[index] if index < len(exec_labor_hours) else "",
+            "rate_year": exec_labor_rate_years[index] if index < len(exec_labor_rate_years) else "",
+            "amount": exec_labor_amounts[index] if index < len(exec_labor_amounts) else "",
+        }
+        normalized_row = {key: clean_row_text(value) for key, value in row.items()}
+        amount = normalize_amount(normalized_row.get("amount"))
+        has_other_value = any(value for key, value in normalized_row.items() if key != "amount")
+        if amount or has_other_value:
+            hours_value = _parse_exec_hours_value(normalized_row.get("hours"))
+            normalized_row["hours"] = str(int(hours_value)) if hours_value else ""
+            computed_amount = _resolve_labor_rate(
+                labor_rates_by_year,
+                normalized_row.get("grade"),
+                normalized_row.get("rate_year"),
+                fallback_rate_year,
+            ) * hours_value
+            normalized_row["amount"] = computed_amount if computed_amount else amount
+            normalized_row["group"] = "labor"
+            exec_labor_rows.append(normalized_row)
     exec_outsource_rows = build_triplet_amount_rows(
         payload.get("exec_outsource_dept[]", []),
         payload.get("exec_outsource_work[]", []),
@@ -6501,17 +7427,20 @@ def build_project_status_payload(payload: dict[str, Any]) -> dict[str, Any]:
     actual_labor_grades = payload.get("actual_labor_grade[]", [])
     actual_labor_minutes = payload.get("actual_labor_minutes[]", [])
     actual_labor_amounts = payload.get("actual_labor_amount[]", [])
+    actual_labor_rate_years = payload.get("actual_labor_rate_year[]", [])
     actual_labor_rows: list[dict[str, Any]] = []
     actual_labor_max_length = max(
         len(actual_labor_grades),
         len(actual_labor_minutes),
         len(actual_labor_amounts),
+        len(actual_labor_rate_years),
     )
     for index in range(actual_labor_max_length):
         row = {
             "grade": actual_labor_grades[index] if index < len(actual_labor_grades) else "",
             "minutes": actual_labor_minutes[index] if index < len(actual_labor_minutes) else "",
             "amount": actual_labor_amounts[index] if index < len(actual_labor_amounts) else "",
+            "rate_year": actual_labor_rate_years[index] if index < len(actual_labor_rate_years) else "",
         }
         normalized_row = {key: clean_row_text(value) for key, value in row.items()}
         amount = normalize_amount(normalized_row.get("amount"))
@@ -6520,7 +7449,15 @@ def build_project_status_payload(payload: dict[str, Any]) -> dict[str, Any]:
             if key != "amount"
         )
         if amount or has_other_value:
-            normalized_row["amount"] = amount
+            minutes_value = _parse_minutes_value(normalized_row.get("minutes"))
+            normalized_row["minutes"] = str(int(minutes_value)) if minutes_value else ""
+            computed_amount = _resolve_labor_rate(
+                labor_rates_by_year,
+                normalized_row.get("grade"),
+                normalized_row.get("rate_year"),
+                fallback_rate_year,
+            ) * (minutes_value / 60.0 if minutes_value else 0.0)
+            normalized_row["amount"] = computed_amount if computed_amount else amount
             actual_labor_rows.append(normalized_row)
     for row in actual_labor_rows:
         row["group"] = "labor"
@@ -6681,10 +7618,13 @@ def save_project_status(payload: dict[str, Any]) -> None:
     support_dept_code = normalize_text(normalized_payload.get("support_dept_code"))
     if not support_dept_code:
         return
+    started_at = time.perf_counter()
+    session_id = normalize_text(payload.get("client_session_id"))
     collection_rows = normalized_payload.pop("_collection_rows", [])
     task_plan_rows = normalized_payload.pop("_task_plan_rows", [])
     exec_budget_rows = normalized_payload.pop("_exec_budget_rows", [])
     actual_input_rows = normalized_payload.pop("_actual_input_rows", [])
+    previous_snapshot: dict[str, Any] = {}
 
     basic_info_field_keys = (
         "support_dept_name",
@@ -6727,6 +7667,7 @@ def save_project_status(payload: dict[str, Any]) -> None:
     exec_budget_field_keys = (
         "exec_labor_grade[]",
         "exec_labor_hours[]",
+        "exec_labor_rate_year[]",
         "exec_labor_amount[]",
         "exec_outsource_dept[]",
         "exec_outsource_work[]",
@@ -6739,6 +7680,7 @@ def save_project_status(payload: dict[str, Any]) -> None:
         "actual_labor_grade[]",
         "actual_labor_minutes[]",
         "actual_labor_amount[]",
+        "actual_labor_rate_year[]",
         "actual_labor_adjustment_total",
         "actual_labor_joint_label[]",
         "actual_labor_joint_amount[]",
@@ -6752,6 +7694,7 @@ def save_project_status(payload: dict[str, Any]) -> None:
         return any(key in payload for key in keys)
 
     with engine.begin() as conn:
+        previous_snapshot = load_project_status_snapshot_payload(conn, support_dept_code)
         existing_row = conn.execute(
             text("SELECT * FROM project_status WHERE support_dept_code = :support_dept_code"),
             {"support_dept_code": support_dept_code},
@@ -6789,7 +7732,7 @@ def save_project_status(payload: dict[str, Any]) -> None:
             exec_budget_rows = existing_entry_set["exec_budget_entries"]
         else:
             existing_exec_rows = existing_entry_set["exec_budget_entries"]
-            if not payload_has_any(("exec_labor_grade[]", "exec_labor_hours[]", "exec_labor_amount[]")):
+            if not payload_has_any(("exec_labor_grade[]", "exec_labor_hours[]", "exec_labor_rate_year[]", "exec_labor_amount[]")):
                 exec_budget_rows.extend(row for row in existing_exec_rows if normalize_text(row.get("group")) == "labor")
             if not payload_has_any(("exec_outsource_dept[]", "exec_outsource_work[]", "exec_outsource_amount[]")):
                 exec_budget_rows.extend(row for row in existing_exec_rows if normalize_text(row.get("group")) == "outsource")
@@ -6799,7 +7742,7 @@ def save_project_status(payload: dict[str, Any]) -> None:
             actual_input_rows = existing_entry_set["actual_input_entries"]
         else:
             existing_actual_rows = existing_entry_set["actual_input_entries"]
-            if not payload_has_any(("actual_labor_grade[]", "actual_labor_minutes[]", "actual_labor_amount[]")):
+            if not payload_has_any(("actual_labor_grade[]", "actual_labor_minutes[]", "actual_labor_amount[]", "actual_labor_rate_year[]")):
                 actual_input_rows.extend(row for row in existing_actual_rows if normalize_text(row.get("group")) == "labor")
             if "actual_labor_adjustment_total" not in payload:
                 actual_input_rows.extend(row for row in existing_actual_rows if normalize_text(row.get("group")) == "labor_adjustment")
@@ -6854,6 +7797,27 @@ def save_project_status(payload: dict[str, Any]) -> None:
             actual_input_rows,
         )
         sync_project_status_cache_row(conn, support_dept_code)
+    next_snapshot = get_project_status_for_edit(support_dept_code)
+    duration_ms = int((time.perf_counter() - started_at) * 1000)
+    record_project_status_snapshot(support_dept_code, session_id, previous_snapshot, next_snapshot)
+    log_save_event(
+        "project_status_save",
+        "project_status",
+        support_dept_code,
+        session_id=session_id,
+        duration_ms=duration_ms,
+        payload={
+            "support_dept_name": normalize_text(next_snapshot.get("support_dept_name")),
+            "selected_revision": normalize_text(payload.get("edit_revision")),
+            "saved_revision": normalize_text(next_snapshot.get("updated_at")),
+            "collection_count": len(collection_rows),
+            "task_plan_count": len(task_plan_rows),
+            "exec_budget_count": len(exec_budget_rows),
+            "actual_input_count": len(actual_input_rows),
+            "save_scope": normalize_text(payload.get("save_scope")) or "all",
+        },
+    )
+    maybe_create_database_backup("project_status_save", session_id)
 
 
 def base_context(request: Request, message: str = "") -> dict[str, Any]:
@@ -7478,6 +8442,7 @@ async def process_cost(
     end_year: str | None = None,
     code: str | None = None,
     include_related: str | None = None,
+    active_related: str | None = None,
 ):
     try:
         return render_process_cost_page(
@@ -7487,6 +8452,7 @@ async def process_cost(
             end_year=parse_optional_year(end_year),
             code=code,
             include_related=normalize_text(include_related) in {"1", "true", "y", "yes", "on"},
+            active_related=active_related,
         )
     except Exception as exc:
         logger.exception("프로세스 원가 페이지 에러: %s", exc)
@@ -7896,8 +8862,52 @@ async def save_project_json(request: Request):
                 }
             )
         )
+    except ValueError as exc:
+        code = normalize_text(form_data.get("support_dept_code"))
+        logger.warning("사업현황 JSON 저장 충돌/검증 오류(%s): %s", code, exc)
+        log_save_event(
+            "project_status_save",
+            "project_status",
+            code,
+            session_id=form_data.get("client_session_id"),
+            status="error",
+            error_message=str(exc),
+            payload={
+                "selected_revision": normalize_text(form_data.get("edit_revision")),
+                "support_dept_code": code,
+                "save_scope": normalize_text(form_data.get("save_scope")) or "all",
+            },
+        )
+        status_code = 409 if "먼저 수정" in str(exc) else 400
+        return JSONResponse(
+            status_code=status_code,
+            content=jsonable_encoder(
+                {
+                    "ok": False,
+                    "error": str(exc) or "사업현황 저장 중 오류가 발생했습니다.",
+                    "conflict": status_code == 409,
+                    "support_dept_code": code,
+                    "project_edit": get_project_status_for_edit(code),
+                    "project_row": get_project_status_row_for_code(code),
+                }
+            ),
+        )
     except Exception as exc:
         logger.exception("사업현황 JSON 저장 에러: %s", exc)
+        code = normalize_text(form_data.get("support_dept_code"))
+        log_save_event(
+            "project_status_save",
+            "project_status",
+            code,
+            session_id=form_data.get("client_session_id"),
+            status="error",
+            error_message=str(exc),
+            payload={
+                "selected_revision": normalize_text(form_data.get("edit_revision")),
+                "support_dept_code": code,
+                "save_scope": normalize_text(form_data.get("save_scope")) or "all",
+            },
+        )
         return JSONResponse(
             status_code=500,
             content={
diff --git a/templates/base.html b/templates/base.html
index 41cbefb..773f3f1 100644
--- a/templates/base.html
+++ b/templates/base.html
@@ -390,6 +390,72 @@
             stroke: #a93a3a;
         }
 
+        .modal-backdrop {
+            position: fixed;
+            inset: 0;
+            display: none;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+            background: rgba(20, 33, 47, 0.5);
+            z-index: 10000;
+            isolation: isolate;
+        }
+
+        .modal-backdrop.open,
+        .modal-backdrop.is-open {
+            display: flex;
+        }
+
+        .modal-card,
+        .related-modal-card {
+            position: relative;
+            z-index: 1;
+            background: #ffffff;
+            border: 1px solid var(--line);
+            box-shadow: 0 24px 64px rgba(21, 24, 29, 0.18);
+        }
+
+        .related-modal-card {
+            width: min(680px, 100%);
+            max-height: min(70vh, 760px);
+            overflow: hidden;
+            border-radius: 16px;
+            padding: 14px;
+            display: flex;
+            flex-direction: column;
+            gap: 12px;
+        }
+
+        .related-modal-head {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            gap: 12px;
+            flex-wrap: wrap;
+        }
+
+        .related-modal-head--singleline {
+            flex-wrap: nowrap;
+            align-items: center;
+            justify-content: space-between;
+        }
+
+        .related-modal-title {
+            margin: 0;
+            font-size: 16px;
+            font-weight: 800;
+            line-height: 1.2;
+        }
+
+        .related-modal-body {
+            display: grid;
+            gap: 10px;
+            overflow: auto;
+            min-height: 0;
+            overscroll-behavior: contain;
+        }
+
         .sr-only {
             position: absolute;
             width: 1px;
@@ -799,7 +865,7 @@
         }
 
         function hasOpenModal() {
-            return Boolean(document.querySelector(".modal-backdrop.open"));
+            return Boolean(document.querySelector(".modal-backdrop.open, .modal-backdrop.is-open"));
         }
 
         function shouldDelayRefresh() {
diff --git a/templates/process_cost.html b/templates/process_cost.html
index 598f8ed..2d077f3 100644
--- a/templates/process_cost.html
+++ b/templates/process_cost.html
@@ -333,6 +333,10 @@
         min-width: 0;
     }
 
+    .pc-selected-card[hidden] {
+        display: none;
+    }
+
     .pc-selected-head {
         display: flex;
         align-items: center;
@@ -452,6 +456,16 @@
         min-height: 32px;
     }
 
+    .pc-chip-link {
+        color: inherit;
+        text-decoration: none;
+        font-weight: 700;
+    }
+
+    .pc-chip-link:hover {
+        text-decoration: underline;
+    }
+
     .pc-chip button {
         border: none;
         background: transparent;
@@ -463,6 +477,33 @@
         cursor: pointer;
     }
 
+    .pc-related-include {
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        width: 18px;
+        min-width: 18px;
+        height: 18px;
+        border-radius: 999px;
+        border: 1px solid rgba(217, 221, 227, 0.9);
+        background: #fff;
+        color: var(--muted);
+        font-size: 12px;
+        font-weight: 800;
+        padding: 0;
+        line-height: 1;
+    }
+
+    .pc-related-include.is-active {
+        color: #1f6f3d;
+        background: #eefbf3;
+    }
+
+    .pc-related-include:disabled {
+        opacity: 0.42;
+        cursor: default;
+    }
+
     .pc-related-form {
         display: grid;
         grid-template-columns: minmax(0, 1fr) auto auto;
@@ -686,12 +727,12 @@
     <div class="pc-toolbar">
         <div class="pc-tab-row">
             <div class="pc-source-tabs">
-                <a href="/process-cost?source=hanmac{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}{% if process_cost_selected_code %}&code={{ process_cost_selected_code }}{% endif %}{% if process_cost_include_related %}&include_related=1{% endif %}" class="{% if process_cost_source == 'hanmac' %}active{% endif %}">Hanmac ERP</a>
-                <a href="/process-cost?source=wehago{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}{% if process_cost_selected_code %}&code={{ process_cost_selected_code }}{% endif %}{% if process_cost_include_related %}&include_related=1{% endif %}" class="{% if process_cost_source == 'wehago' %}active{% endif %}">WEHAGO</a>
+                <a href="/process-cost?source=hanmac{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}{% if process_cost_selected_code %}&code={{ process_cost_selected_code }}{% endif %}{% if process_cost_include_related %}&include_related=1&active_related={% if process_cost_active_related_codes %}{{ process_cost_active_related_codes|join(',') }}{% elif process_cost_related_codes %}{{ process_cost_related_codes|join(',') }}{% else %}-{% endif %}{% endif %}" class="{% if process_cost_source == 'hanmac' %}active{% endif %}">Hanmac ERP</a>
+                <a href="/process-cost?source=wehago{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}{% if process_cost_selected_code %}&code={{ process_cost_selected_code }}{% endif %}{% if process_cost_include_related %}&include_related=1&active_related={% if process_cost_active_related_codes %}{{ process_cost_active_related_codes|join(',') }}{% elif process_cost_related_codes %}{{ process_cost_related_codes|join(',') }}{% else %}-{% endif %}{% endif %}" class="{% if process_cost_source == 'wehago' %}active{% endif %}">WEHAGO</a>
             </div>
             <div class="pc-source-tabs">
                 <a href="/process-cost?source={{ process_cost_source }}{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}{% if process_cost_selected_code %}&code={{ process_cost_selected_code }}{% endif %}" class="{% if not process_cost_include_related %}active{% endif %}">연계 미반영</a>
-                <a href="/process-cost?source={{ process_cost_source }}{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}{% if process_cost_selected_code %}&code={{ process_cost_selected_code }}{% endif %}&include_related=1" class="{% if process_cost_include_related %}active{% endif %}">연계 반영</a>
+                <a href="/process-cost?source={{ process_cost_source }}{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}{% if process_cost_selected_code %}&code={{ process_cost_selected_code }}{% endif %}&include_related=1&active_related={% if process_cost_active_related_codes %}{{ process_cost_active_related_codes|join(',') }}{% elif process_cost_related_codes %}{{ process_cost_related_codes|join(',') }}{% else %}-{% endif %}" class="{% if process_cost_include_related %}active{% endif %}">연계 반영</a>
             </div>
         </div>
         <form method="get" action="/process-cost" class="pc-filter">
@@ -699,6 +740,7 @@
             <input type="hidden" name="code" value="{{ process_cost_selected_code }}">
             {% if process_cost_include_related %}
                 <input type="hidden" name="include_related" value="1">
+                <input type="hidden" name="active_related" value="{% if process_cost_active_related_codes %}{{ process_cost_active_related_codes|join(',') }}{% else %}-{% endif %}">
             {% endif %}
             <select name="start_year" aria-label="시작 연도 선택" id="processCostStartYear">
                 {% if not process_cost_years %}
@@ -758,7 +800,7 @@
                             <div class="pc-project-dropdown" id="projectList" hidden>
                                 {% for item in process_cost_projects %}
                                     <a
-                                        href="/process-cost?source={{ process_cost_source }}{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}&code={{ item.support_dept_code }}{% if process_cost_include_related %}&include_related=1{% endif %}"
+                                        href="/process-cost?source={{ process_cost_source }}{% if process_cost_selected_start_year %}&start_year={{ process_cost_selected_start_year }}{% endif %}{% if process_cost_selected_end_year %}&end_year={{ process_cost_selected_end_year }}{% endif %}&code={{ item.support_dept_code }}{% if process_cost_include_related %}&include_related=1&active_related={% if process_cost_active_related_codes %}{{ process_cost_active_related_codes|join(',') }}{% else %}-{% endif %}{% endif %}"
                                         class="pc-project-item {% if process_cost_selected_code == item.support_dept_code %}active{% endif %}"
                                         data-project-search="{{ (item.support_dept_code ~ ' ' ~ item.support_dept_name ~ ' ' ~ (item.client_name or ''))|lower }}"
                                         data-project-kind="{{ item.project_kind_code|lower }}"
@@ -777,8 +819,8 @@
                                 <div class="pc-note" id="projectListEmpty" hidden style="padding: 12px;">검색 결과가 없습니다.</div>
                             </div>
                         </div>
-                        {% if selected_project %}
-                            <div class="pc-selected-card">
+                        {% if selected_project and (selected_project.support_dept_code not in (process_cost_quick_link_codes or [])) %}
+                            <div class="pc-selected-card" id="selectedProjectCard">
                                 <div class="pc-selected-head">
                                     <div class="pc-selected-title">{{ selected_project.support_dept_code }}</div>
                                     <button
@@ -835,7 +877,7 @@
                     <span class="meta">목표원가 {{ "{:,.0f}".format(overview.target_cost_amount|default(0)) }}원</span>
                 </article>
                 <article class="pc-card">
-                    <span class="label">예상 영업수지</span>
+                    <span class="label">영업수지</span>
                     <strong class="value">{{ "{:,.0f}".format(overview.profit_amount|default(0)) }}원</strong>
                     <span class="meta">마진율 {{ "{:.1f}".format(overview.profit_rate|default(0)) }}%</span>
                 </article>
@@ -872,14 +914,14 @@
             </section>
 
             <section class="pc-block">
-                <h3>설계 프로세스별 원가 현황</h3>
+                <h3>지출 내역</h3>
                 <div class="pc-table-wrap">
                     <table class="pc-table">
                         <thead>
                             <tr>
                                 <th>구분</th>
                                 <th>목표 원가</th>
-                                <th>실제 집행</th>
+                                <th>실지출</th>
                                 <th>차이(목표-실제)</th>
                                 <th>집행률</th>
                             </tr>
@@ -905,13 +947,13 @@
             </section>
 
             <section class="pc-block">
-                <h3>계정별 집행 상위 항목</h3>
+                <h3>지출 상위 항목</h3>
                 <div class="pc-table-wrap">
                     <table class="pc-table">
                         <thead>
                             <tr>
                                 <th>계정</th>
-                                <th>집행금액</th>
+                                <th>실지출</th>
                                 <th>비중</th>
                                 <th>전표건수</th>
                                 <th>최근 증빙일</th>
@@ -1007,6 +1049,7 @@
         const selectedCode = {{ process_cost_selected_code | tojson }};
         const selectedProject = {{ (process_cost_selected_project or {}) | tojson }};
         const initialRelatedCodes = {{ (process_cost_related_codes or []) | tojson }};
+        const initialActiveRelatedCodes = {{ (process_cost_active_related_codes or []) | tojson }};
         const initialQuickLinkCodes = {{ (process_cost_quick_link_codes or []) | tojson }};
         const searchInput = document.getElementById("projectSearchInput");
         const list = document.getElementById("projectList");
@@ -1020,9 +1063,11 @@
         const processModalNote = document.getElementById("processFlowModalNote");
         const processModalClose = document.getElementById("processFlowModalClose");
         const processButtons = document.querySelectorAll("[data-process-modal]");
+        const includeRelatedEnabled = {{ 1 if process_cost_include_related else 0 }};
         let bookmarkedCodes = Array.isArray(initialQuickLinkCodes) ? [...initialQuickLinkCodes] : [];
+        let activeRelatedCodes = Array.isArray(initialActiveRelatedCodes) ? [...initialActiveRelatedCodes] : [];
 
-        function buildProcessCostUrl(code) {
+        function buildProcessCostUrl(code, options = {}) {
             const params = new URLSearchParams();
             params.set("source", {{ process_cost_source | tojson }});
             if ({{ process_cost_selected_start_year | tojson }}) {
@@ -1034,8 +1079,15 @@
             if (code) {
                 params.set("code", code);
             }
-            if ({{ 1 if process_cost_include_related else 0 }}) {
+            const includeRelated = Object.prototype.hasOwnProperty.call(options, "includeRelated")
+                ? Boolean(options.includeRelated)
+                : Boolean(includeRelatedEnabled);
+            const relatedCodes = Array.isArray(options.activeRelatedCodes)
+                ? options.activeRelatedCodes
+                : activeRelatedCodes;
+            if (includeRelated) {
                 params.set("include_related", "1");
+                params.set("active_related", relatedCodes.length ? relatedCodes.join(",") : "-");
             }
             return `/process-cost?${params.toString()}`;
         }
@@ -1072,11 +1124,20 @@
             selectedProjectBookmark.setAttribute("title", active ? "바로가기 해제" : "바로가기 저장");
         }
 
+        function syncSelectedProjectCard() {
+            const selectedProjectCard = document.getElementById("selectedProjectCard");
+            if (!selectedProjectCard || !selectedProject || !selectedProject.support_dept_code) {
+                return;
+            }
+            selectedProjectCard.hidden = isBookmarked(selectedProject.support_dept_code);
+        }
+
         function renderQuickLinks() {
             if (!quickLinksContainer) return;
             const items = getBookmarkedProjects();
             if (!items.length) {
                 quickLinksContainer.innerHTML = "";
+                syncSelectedProjectCard();
                 return;
             }
             quickLinksContainer.innerHTML = items.map((item) => `
@@ -1102,6 +1163,7 @@
                         .then(() => {
                             renderQuickLinks();
                             syncBookmarkButton();
+                            syncSelectedProjectCard();
                             closeProjectList();
                             filterProjectList();
                         })
@@ -1110,6 +1172,7 @@
                         });
                 });
             });
+            syncSelectedProjectCard();
         }
 
         function getVisibleProjectItems() {
@@ -1228,6 +1291,7 @@
 
         renderQuickLinks();
         syncBookmarkButton();
+        syncSelectedProjectCard();
         filterProjectList();
 
         if (selectedProjectBookmark) {
@@ -1242,6 +1306,7 @@
                     await persistBookmarkedCodes(nextCodes);
                     renderQuickLinks();
                     syncBookmarkButton();
+                    syncSelectedProjectCard();
                     closeProjectList();
                     filterProjectList();
                 } catch (error) {
@@ -1266,19 +1331,57 @@
         function renderRelatedChips() {
             if (!relatedChipRow) return;
             const fixedHead = selectedCode ? `<span class="pc-chip">${selectedCode} 기준</span>` : "";
-            const chips = [...relatedSet].sort().map((code) => `
+            const chips = [...relatedSet].sort().map((code) => {
+                const isActive = activeRelatedCodes.includes(code);
+                const nextActiveCodes = isActive
+                    ? activeRelatedCodes.filter((item) => item !== code)
+                    : [...activeRelatedCodes, code];
+                const openActiveCodes = [...new Set(
+                    [selectedCode, ...activeRelatedCodes]
+                        .filter((item) => item && item !== code)
+                )];
+                return `
                 <span class="pc-chip" data-related-code="${code}">
-                    <span>${code}</span>
+                    <a
+                        href="${buildProcessCostUrl(code, { activeRelatedCodes: openActiveCodes, includeRelated: includeRelatedEnabled })}"
+                        class="pc-chip-link"
+                    >${code}</a>
+                    <button
+                        type="button"
+                        class="pc-related-include ${isActive ? "is-active" : ""}"
+                        data-related-toggle="${code}"
+                        data-related-active="${isActive ? "1" : "0"}"
+                        aria-label="${isActive ? "합산 제외" : "합산 포함"}"
+                        title="${isActive ? "합산 제외" : "합산 포함"}"
+                        ${includeRelatedEnabled ? "" : "disabled"}
+                    >${isActive ? "−" : "+"}</button>
                     <button type="button" class="pc-related-remove" data-related-remove="${code}">x</button>
                 </span>
-            `).join("");
+            `;
+            }).join("");
             const empty = "";
             relatedChipRow.innerHTML = fixedHead + chips + empty;
+            relatedChipRow.querySelectorAll("[data-related-toggle]").forEach((button) => {
+                button.addEventListener("click", () => {
+                    if (!includeRelatedEnabled) return;
+                    const code = button.getAttribute("data-related-toggle") || "";
+                    if (!code) return;
+                    const currentlyActive = button.getAttribute("data-related-active") === "1";
+                    const nextActiveCodes = currentlyActive
+                        ? activeRelatedCodes.filter((item) => item !== code)
+                        : [...activeRelatedCodes, code];
+                    window.location.href = buildProcessCostUrl(selectedCode, {
+                        includeRelated: true,
+                        activeRelatedCodes: [...new Set(nextActiveCodes)],
+                    });
+                });
+            });
             relatedChipRow.querySelectorAll("[data-related-remove]").forEach((button) => {
                 button.addEventListener("click", () => {
                     const code = button.dataset.relatedRemove || "";
                     if (code) {
                         relatedSet.delete(code);
+                        activeRelatedCodes = activeRelatedCodes.filter((item) => item !== code);
                         renderRelatedChips();
                     }
                 });
@@ -1338,6 +1441,7 @@
                 for (const code of initialRelatedCodes || []) {
                     relatedSet.add(code);
                 }
+                activeRelatedCodes = Array.isArray(initialActiveRelatedCodes) ? [...initialActiveRelatedCodes] : [];
                 if (relatedSearchInput) relatedSearchInput.value = "";
                 if (relatedSuggestList) {
                     relatedSuggestList.classList.remove("active");
diff --git a/templates/projects.html b/templates/projects.html
index f3702b0..4930353 100644
--- a/templates/projects.html
+++ b/templates/projects.html
@@ -785,6 +785,57 @@
         gap: 0;
     }
 
+    .comparison-detail-table-wrap {
+        overflow: auto;
+        border-top: 1px solid #eef2f5;
+    }
+
+    .comparison-detail-table {
+        width: 100%;
+        min-width: 520px;
+        border-collapse: collapse;
+        font-size: 12px;
+    }
+
+    .comparison-detail-table th,
+    .comparison-detail-table td {
+        padding: 8px 10px;
+        border-top: 1px solid #eef2f5;
+        text-align: left;
+        white-space: nowrap;
+    }
+
+    .comparison-detail-table thead th {
+        background: #f8fafc;
+        color: #547085;
+        font-weight: 800;
+        border-top: 0;
+    }
+
+    .comparison-detail-table td:last-child,
+    .comparison-detail-table th:last-child {
+        text-align: right;
+    }
+
+    .comparison-inline-detail {
+        display: none;
+        padding: 0 10px 10px;
+        border-top: 1px solid #eef2f5;
+        background: #fbfcfd;
+    }
+
+    .comparison-inline-detail.is-open {
+        display: block;
+    }
+
+    .comparison-inline-detail-note {
+        padding: 12px 0;
+        color: var(--muted);
+        font-size: 12px;
+        line-height: 1.6;
+        text-align: center;
+    }
+
     .comparison-detail-split {
         display: grid;
         grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -834,6 +885,13 @@
         text-align: right;
     }
 
+    .comparison-inline-toggle {
+        cursor: pointer;
+        text-decoration: underline;
+        text-decoration-color: rgba(44, 95, 150, 0.28);
+        text-underline-offset: 2px;
+    }
+
     .comparison-detail-item.is-subtotal,
     .comparison-detail-item.is-total {
         background: #f8fafc;
@@ -921,12 +979,13 @@
     }
 
     .analysis-kpi {
-        border: 1px solid #dfe6ee;
-        border-radius: 14px;
-        padding: 12px 10px;
+        border: 0;
+        border-bottom: 1px solid #dfe6ee;
+        border-radius: 0;
+        padding: 0 0 12px;
         display: grid;
         gap: 4px;
-        background: #fbfcfd;
+        background: transparent;
         min-width: 0;
     }
 
@@ -1595,10 +1654,11 @@
     }
 
     .info-chip {
-        background: rgba(248, 249, 251, 0.98);
-        border: 1px solid var(--line);
-        border-radius: 14px;
-        padding: 12px 14px;
+        background: transparent;
+        border: 0;
+        border-bottom: 1px solid rgba(217, 221, 227, 0.9);
+        border-radius: 0;
+        padding: 0 0 12px;
     }
 
     .info-chip .label {
@@ -1620,10 +1680,11 @@
     }
 
     .detail-block {
-        background: rgba(255, 255, 255, 0.94);
-        border: 1px solid var(--line);
-        border-radius: 16px;
-        padding: 14px;
+        background: transparent;
+        border: 0;
+        border-top: 1px solid var(--line);
+        border-radius: 0;
+        padding: 14px 0 0;
     }
 
     .detail-block h4 {
@@ -1679,7 +1740,8 @@
         align-items: center;
         justify-content: center;
         padding: 20px;
-        z-index: 50;
+        z-index: 10000;
+        isolation: isolate;
     }
 
     .modal-backdrop.open {
@@ -1690,11 +1752,13 @@
         width: min(1280px, 100%);
         max-height: 90vh;
         overflow: auto;
+        position: relative;
+        z-index: 1;
         background: #ffffff;
-        border-radius: 14px;
-        border: 1px solid var(--line);
-        box-shadow: 0 24px 64px rgba(21, 24, 29, 0.18);
-        padding: 12px;
+        border-radius: 20px;
+        border: 0;
+        box-shadow: 0 28px 72px rgba(21, 24, 29, 0.16);
+        padding: 14px 18px 18px;
     }
 
     .modal-form {
@@ -1712,7 +1776,7 @@
     .modal-card select,
     .modal-card textarea {
         padding: 6px 8px;
-        border-radius: 8px;
+        border-radius: 10px;
         min-height: 34px;
         font-size: 12px;
         line-height: 1.2;
@@ -1723,10 +1787,11 @@
     }
 
     .form-section-block {
-        border: 1px solid var(--line);
-        border-radius: 12px;
-        padding: 12px;
-        background: rgba(250, 251, 252, 0.92);
+        border: 0;
+        border-top: 1px solid var(--line);
+        border-radius: 0;
+        padding: 12px 0 0;
+        background: transparent;
         display: grid;
         gap: 10px;
     }
@@ -1739,6 +1804,13 @@
         flex-wrap: wrap;
     }
 
+    .form-section-actions {
+        display: inline-flex;
+        align-items: center;
+        gap: 8px;
+        flex-wrap: wrap;
+    }
+
     .form-section-head h3 {
         font-size: 14px;
     }
@@ -1784,10 +1856,11 @@
 
     .readonly-output {
         min-height: 34px;
-        border: 1px solid var(--line);
-        background: #f5f7fa;
-        border-radius: 8px;
-        padding: 7px 9px;
+        border: 0;
+        border-bottom: 1px solid var(--line);
+        background: transparent;
+        border-radius: 0;
+        padding: 7px 0;
         display: flex;
         align-items: center;
         justify-content: flex-start;
@@ -1807,7 +1880,7 @@
         top: calc(100% + 6px);
         left: 0;
         right: 0;
-        z-index: 2800;
+        z-index: 12000;
         border: 1px solid var(--line);
         border-radius: 10px;
         background: #ffffff;
@@ -1969,6 +2042,39 @@
         width: 10%;
     }
 
+    .exec-labor-table col:nth-child(1) {
+        width: 18%;
+    }
+
+    .exec-labor-table col:nth-child(2) {
+        width: 16%;
+    }
+
+    .exec-labor-table col:nth-child(3) {
+        width: 30%;
+    }
+
+    .exec-labor-table col:nth-child(4) {
+        width: 26%;
+    }
+
+    .exec-labor-table col:nth-child(5) {
+        width: 10%;
+    }
+
+    .exec-labor-table .exec-labor-grade {
+        max-width: 90px;
+    }
+
+    .exec-labor-table .exec-labor-hours {
+        max-width: 88px;
+        text-align: right;
+    }
+
+    .exec-labor-table .exec-labor-rate-year {
+        max-width: 104px;
+    }
+
     .section-columns {
         display: grid;
         grid-template-columns: repeat(3, minmax(0, 1fr));
@@ -2029,18 +2135,22 @@
     }
 
     .actual-labor-table col:nth-child(1) {
-        width: 21%;
+        width: 19%;
     }
 
     .actual-labor-table col:nth-child(2) {
-        width: 33%;
+        width: 29%;
     }
 
     .actual-labor-table col:nth-child(3) {
-        width: 30%;
+        width: 24%;
     }
 
     .actual-labor-table col:nth-child(4) {
+        width: 20%;
+    }
+
+    .actual-labor-table col:nth-child(5) {
         width: 8%;
     }
 
@@ -2069,6 +2179,11 @@
         margin-left: 0;
     }
 
+    .actual-labor-table .actual-labor-rate-year {
+        width: 100%;
+        max-width: 116px;
+    }
+
     .row-table.compact th,
     .row-table.compact td {
         padding: 6px;
@@ -2515,7 +2630,9 @@
                 <div class="modal-header-actions">
                     <button type="button" id="saveProjectModal" class="button-icon" title="사업현황 저장" aria-label="사업현황 저장">
                         <svg viewBox="0 0 24 24" aria-hidden="true">
-                            <path d="M5 12l5 5 9-10"></path>
+                            <path d="M6 4h10l4 4v12H6z"></path>
+                            <path d="M9 4v6h6V4"></path>
+                            <path d="M9 20v-6h6v6"></path>
                         </svg>
                         <span class="sr-only">사업현황 저장</span>
                     </button>
@@ -2533,10 +2650,12 @@
             <input type="hidden" id="support_dept_code" name="support_dept_code" value="{{ project_edit.support_dept_code }}">
             <input type="hidden" id="exec_labor_rates_json" name="exec_labor_rates_json" value='{{ project_edit.exec_labor_rates | tojson | e }}'>
 
-            <section class="form-section-block">
+            <section class="form-section-block" data-save-scope-section="basic_info">
                 <div class="form-section-head">
                     <h3>기본 정보</h3>
-                    <div class="section-help">진행율은 계약금액 대비 수금액 합계로 자동 계산됩니다.</div>
+                    <div class="form-section-actions">
+                        <button type="button" class="button-link button-secondary mini-button" data-save-scope-button="basic_info">기본 정보 저장</button>
+                    </div>
                 </div>
                 <div id="projectImportReviewBanner" class="import-review-banner{% if project_edit.review_tag %} is-visible{% endif %}">
                     <strong id="projectImportReviewTag">{{ project_edit.review_tag }}</strong>
@@ -2592,20 +2711,23 @@
                 </div>
             </section>
 
-            <section class="form-section-block">
+            <section class="form-section-block" data-save-scope-section="collection">
                 <div class="form-section-head">
                     <h3>수금 정보</h3>
                     <div class="table-tools">
                         <div class="actions">
                             <div class="section-chip">계약금액 <strong id="collectionContractInlineDisplay">{{ "{:,.0f}".format(project_edit.contract_amount or 0) }}원</strong></div>
                         </div>
-                        <button type="button" class="button-link button-secondary mini-button button-icon" data-add-row="collection" title="수금 행 추가" aria-label="수금 행 추가">
-                            <svg viewBox="0 0 24 24" aria-hidden="true">
-                                <path d="M12 5v14"></path>
-                                <path d="M5 12h14"></path>
-                            </svg>
-                            <span class="sr-only">수금 행 추가</span>
-                        </button>
+                        <div class="form-section-actions">
+                            <button type="button" class="button-link button-secondary mini-button" data-save-scope-button="collection">수금 정보 저장</button>
+                            <button type="button" class="button-link button-secondary mini-button button-icon" data-add-row="collection" title="수금 행 추가" aria-label="수금 행 추가">
+                                <svg viewBox="0 0 24 24" aria-hidden="true">
+                                    <path d="M12 5v14"></path>
+                                    <path d="M5 12h14"></path>
+                                </svg>
+                                <span class="sr-only">수금 행 추가</span>
+                            </button>
+                        </div>
                     </div>
                 </div>
                 <div class="collection-entry-list" id="collectionRows">
@@ -2688,9 +2810,12 @@
                 </div>
             </section>
 
-            <section class="form-section-block">
+            <section class="form-section-block" data-save-scope-section="task_plan">
                 <div class="form-section-head">
                     <h3>과업수행계획</h3>
+                    <div class="form-section-actions">
+                        <button type="button" class="button-link button-secondary mini-button" data-save-scope-button="task_plan">과업수행계획 저장</button>
+                    </div>
                 </div>
                 <div class="table-total">계획 합계: <span id="taskPlanTotalDisplay">0</span>원</div>
                 <div class="section-columns">
@@ -2790,9 +2915,12 @@
                 </div>
             </section>
 
-            <section class="form-section-block">
+            <section class="form-section-block" data-save-scope-section="exec_budget">
                 <div class="form-section-head">
                     <h3>실행예산계획</h3>
+                    <div class="form-section-actions">
+                        <button type="button" class="button-link button-secondary mini-button" data-save-scope-button="exec_budget">실행예산 저장</button>
+                    </div>
                 </div>
                 <div class="table-total">실행예산 합계: <span id="execBudgetTotalDisplay">0</span>원</div>
                 <div class="section-columns">
@@ -2811,18 +2939,20 @@
                             </div>
                         </div>
                         <div class="row-table-wrap">
-                            <table class="row-table compact">
+                            <table class="row-table compact exec-labor-table">
                                 <colgroup>
-                                    <col class="modal-col-dept">
-                                    <col class="modal-col-work">
-                                    <col class="modal-col-amount">
-                                    <col class="modal-col-remove">
+                                    <col>
+                                    <col>
+                                    <col>
+                                    <col>
+                                    <col>
                                 </colgroup>
                                 <thead>
                                     <tr>
                                         <th>직급</th>
                                         <th>투입시간</th>
                                         <th>금액(원)</th>
+                                        <th>연도</th>
                                         <th></th>
                                     </tr>
                                 </thead>
@@ -2895,9 +3025,12 @@
                 </div>
             </section>
 
-            <section class="form-section-block">
+            <section class="form-section-block" data-save-scope-section="actual_input">
                 <div class="form-section-head">
                     <h3>실투입 관리</h3>
+                    <div class="form-section-actions">
+                        <button type="button" class="button-link button-secondary mini-button" data-save-scope-button="actual_input">실투입 저장</button>
+                    </div>
                 </div>
                 <div class="table-total">실투입 합계: <span id="actualInputTotalDisplay">0</span>원</div>
                 <div class="actual-input-layout">
@@ -2923,12 +3056,14 @@
                                     <col>
                                     <col>
                                     <col>
+                                    <col>
                                 </colgroup>
                                 <thead>
                                     <tr>
                                         <th>직급</th>
                                         <th>투입시간</th>
                                         <th>금액(원)</th>
+                                        <th>기준연도</th>
                                         <th></th>
                                     </tr>
                                 </thead>
@@ -3017,9 +3152,12 @@
                 </div>
             </section>
 
-            <section class="form-section-block">
+            <section class="form-section-block" data-save-scope-section="allocation">
                 <div class="form-section-head">
                     <h3>예상 배분 설정</h3>
+                    <div class="form-section-actions">
+                        <button type="button" class="button-link button-secondary mini-button" data-save-scope-button="allocation">배분 설정 저장</button>
+                    </div>
                 </div>
                 <div class="section-grid">
                     <div class="field">
@@ -3049,9 +3187,12 @@
                 </div>
             </section>
 
-            <section class="form-section-block">
+            <section class="form-section-block" data-save-scope-section="notes">
                 <div class="form-section-head">
                     <h3>비고</h3>
+                    <div class="form-section-actions">
+                        <button type="button" class="button-link button-secondary mini-button" data-save-scope-button="notes">비고 저장</button>
+                    </div>
                 </div>
                 <div class="field field-full">
                     <label for="notes">메모</label>
@@ -3066,6 +3207,18 @@
     <div class="related-modal-card" style="max-width:720px;">
         <div class="related-modal-head">
             <h3 class="related-modal-title">기준인건비</h3>
+            <div style="display:inline-flex; align-items:center; gap:8px;">
+                <label for="laborRateYearSelect" style="font-size:12px; color:var(--muted);">연도</label>
+                <select id="laborRateYearSelect" class="inline-input" style="min-width:96px;"></select>
+            </div>
+            <button type="button" class="button-secondary button-icon" id="saveLaborRateYearButton" title="기준인건비 연도 저장" aria-label="기준인건비 연도 저장">
+                <svg viewBox="0 0 24 24" aria-hidden="true">
+                    <path d="M6 4h10l4 4v12H6z"></path>
+                    <path d="M9 4v6h6V4"></path>
+                    <path d="M9 20v-6h6v6"></path>
+                </svg>
+                <span class="sr-only">기준인건비 연도 저장</span>
+            </button>
             <button type="button" class="button-secondary button-icon" id="closeLaborRateModal" title="닫기" aria-label="닫기">
                 <svg viewBox="0 0 24 24" aria-hidden="true">
                     <path d="M6 6l12 12"></path>
@@ -3084,7 +3237,7 @@
                     <thead>
                         <tr>
                             <th>직급</th>
-                            <th>기준인건비</th>
+                            <th>기준인건비(연도별)</th>
                         </tr>
                     </thead>
                     <tbody id="laborRateRows"></tbody>
@@ -3397,6 +3550,7 @@
 {% block script %}
 <script>
     const selectedYear = {{ selected_year or "null" }};
+    const projectYearOptions = {{ (project_year_options or []) | tojson }};
     const yearFilter = document.getElementById("year");
     const supportDepartmentOptions = {{ support_department_options | tojson }};
     const costDepartmentOptions = {{ cost_department_options | tojson }};
@@ -3468,6 +3622,8 @@
     const execLaborRatesInput = document.getElementById("exec_labor_rates_json");
     const laborRateModal = document.getElementById("laborRateModal");
     const laborRateRows = document.getElementById("laborRateRows");
+    const laborRateYearSelect = document.getElementById("laborRateYearSelect");
+    const saveLaborRateYearButton = document.getElementById("saveLaborRateYearButton");
     const openLaborRateModalButton = document.getElementById("openLaborRateModal");
     const closeLaborRateModalButton = document.getElementById("closeLaborRateModal");
     const detailYearSettingModal = document.getElementById("detailYearSettingModal");
@@ -3478,6 +3634,96 @@
     const closeExcludedDetailItemsModalButton = document.getElementById("closeExcludedDetailItemsModal");
     const excludedDetailItemsSummary = document.getElementById("excludedDetailItemsSummary");
     const excludedDetailItemsRows = document.getElementById("excludedDetailItemsRows");
+    const PROJECT_STATUS_DRAFT_STORAGE_PREFIX = "project-status-draft-v1";
+    const PROJECT_STATUS_SCOPE_FIELDS = {
+        basic_info: [
+            "support_dept_code",
+            "support_dept_name",
+            "project_type",
+            "contract_amount",
+            "completion_status",
+            "change_round",
+            "project_start_date",
+            "project_end_date",
+        ],
+        collection: [
+            "collection_progress_type[]",
+            "collection_billing_round[]",
+            "collection_billing_type[]",
+            "collection_billing_date[]",
+            "collection_billed_amount[]",
+            "collection_round[]",
+            "collection_date[]",
+            "collection_amount_row[]",
+        ],
+        task_plan: [
+            "task_plan_department_dept[]",
+            "task_plan_department_work[]",
+            "task_plan_department_amount[]",
+            "task_plan_outsource_dept[]",
+            "task_plan_outsource_work[]",
+            "task_plan_outsource_amount[]",
+            "task_plan_joint_dept[]",
+            "task_plan_joint_work[]",
+            "task_plan_joint_amount[]",
+        ],
+        exec_budget: [
+            "exec_labor_rates_json",
+            "exec_labor_grade[]",
+            "exec_labor_hours[]",
+            "exec_labor_rate_year[]",
+            "exec_labor_amount[]",
+            "exec_outsource_dept[]",
+            "exec_outsource_work[]",
+            "exec_outsource_amount[]",
+            "exec_cost_plan_code[]",
+            "exec_cost_plan_name[]",
+            "exec_cost_plan_amount[]",
+        ],
+        actual_input: [
+            "actual_labor_grade[]",
+            "actual_labor_minutes[]",
+            "actual_labor_amount[]",
+            "actual_labor_rate_year[]",
+            "actual_labor_adjustment_total",
+            "actual_labor_joint_label[]",
+            "actual_labor_joint_amount[]",
+            "actual_as_label[]",
+            "actual_as_amount[]",
+            "actual_sga_label[]",
+            "actual_sga_amount[]",
+        ],
+        allocation: [
+            "expected_as_rate",
+            "expected_as_cost",
+            "expected_sga_rate",
+            "expected_sga_budget",
+        ],
+        notes: [
+            "notes",
+        ],
+    };
+    const PROJECT_STATUS_COMMON_FIELDS = [
+        "selected_year",
+        "edit_revision",
+        "support_dept_code",
+        "support_dept_name",
+        "client_session_id",
+        "client_submitted_at",
+    ];
+    const projectStatusDraftContainers = {
+        collectionRows,
+        taskPlanDepartmentRows,
+        taskPlanOutsourceRows,
+        taskPlanJointRows,
+        execLaborRows,
+        execOutsourceRows,
+        execCostPlanRows,
+        actualLaborRows,
+        actualLaborJointRows,
+        actualAsRows,
+        actualSgaRows,
+    };
     const uncontractedTransactionModal = document.getElementById("uncontractedTransactionModal");
     const closeUncontractedTransactionModalButton = document.getElementById("closeUncontractedTransactionModal");
     const uncontractedTransactionModalTitle = document.getElementById("uncontractedTransactionModalTitle");
@@ -3498,12 +3744,14 @@
     let uncontractedDetailSort = { key: "code", direction: "asc" };
     let uncontractedTransactionSort = { key: "posting_date", direction: "desc" };
     let vendorTransactionSort = { key: "posting_date", direction: "desc" };
+    let projectStatusDraftTimer = null;
     let latestUncontractedTransactionRows = [];
     let latestVendorTransactionRows = [];
     let latestTransactionModalContext = { type: "uncontracted" };
     let latestVendorModalContext = { type: "uncontracted" };
     let uncontractedDashboardDataRevision = 0;
     const uncontractedDashboardDataCache = new Map();
+    const comparisonInlineDetailCache = new Map();
 
     function bumpUncontractedDashboardRevision() {
         uncontractedDashboardDataRevision += 1;
@@ -3843,10 +4091,16 @@
         return Number.isFinite(numeric) ? numeric : 0;
     }
 
+    function parseExecHoursDigits(value) {
+        const digits = String(value ?? "").replace(/[^\d]/g, "").slice(0, 5);
+        const numeric = Number(digits);
+        return Number.isFinite(numeric) ? numeric : 0;
+    }
+
     function formatHourInputValue(value) {
-        const numeric = parseHours(value);
+        const numeric = parseExecHoursDigits(value);
         if (!numeric) return "";
-        return String(Number(numeric.toFixed(2)));
+        return formatNumber(Math.round(numeric));
     }
 
     const collectionProgressTypeOptions = {{ collection_progress_type_options | tojson }};
@@ -3907,35 +4161,87 @@
         };
     }
 
+    function getLaborRateYears() {
+        const years = new Set();
+        const currentYear = new Date().getFullYear();
+        for (let year = currentYear - 5; year <= currentYear + 2; year += 1) {
+            years.add(String(year));
+        }
+        projectYearOptions.forEach((year) => {
+            const numericYear = Number(year || 0);
+            if (numericYear) years.add(String(numericYear));
+        });
+        Object.keys(currentLaborRates || {}).forEach((yearKey) => {
+            if (/^\d{4}$/.test(String(yearKey || ""))) years.add(String(yearKey));
+        });
+        return [...years].sort((a, b) => Number(a) - Number(b));
+    }
+
+    function getDefaultLaborRateYear() {
+        const selected = Number(selectedYear || 0);
+        if (selected) return String(selected);
+        const existingYears = Object.keys(currentLaborRates || {})
+            .filter((yearKey) => /^\d{4}$/.test(String(yearKey || "")))
+            .sort((a, b) => Number(b) - Number(a));
+        if (existingYears.length) return String(existingYears[0]);
+        return String(new Date().getFullYear());
+    }
+
+    function normalizeLaborRates(rawRates) {
+        const source = rawRates && typeof rawRates === "object" ? rawRates : {};
+        const next = {};
+        const defaultYear = getDefaultLaborRateYear();
+        Object.entries(source).forEach(([key, value]) => {
+            if (/^\d{4}$/.test(String(key || "")) && value && typeof value === "object" && !Array.isArray(value)) {
+                const yearBucket = {};
+                laborGradeOptions.forEach((grade) => {
+                    yearBucket[grade] = Number(value?.[grade] || 0);
+                });
+                next[String(key)] = yearBucket;
+            }
+        });
+        const hasYearBuckets = Object.keys(next).length > 0;
+        if (!hasYearBuckets) {
+            const migrated = {};
+            laborGradeOptions.forEach((grade) => {
+                migrated[grade] = Number(source?.[grade] || 0);
+            });
+            next[defaultYear] = migrated;
+        }
+        return next;
+    }
+
     function readLaborRates() {
         try {
-            return JSON.parse(execLaborRatesInput?.value || "{}") || {};
+            return normalizeLaborRates(JSON.parse(execLaborRatesInput?.value || "{}") || {});
         } catch (error) {
-            return {};
+            return normalizeLaborRates({});
         }
     }
 
     function writeLaborRates(nextRates) {
-        currentLaborRates = { ...nextRates };
+        currentLaborRates = normalizeLaborRates(nextRates);
         if (execLaborRatesInput) {
             execLaborRatesInput.value = JSON.stringify(currentLaborRates);
         }
     }
 
-    function getLaborRate(grade) {
-        const direct = Number(currentLaborRates?.[grade] || 0);
+    function getLaborRate(grade, year = "") {
+        const yearKey = String(year || getDefaultLaborRateYear());
+        const yearRates = currentLaborRates?.[yearKey] || {};
+        const direct = Number(yearRates?.[grade] || 0);
         if (direct) return direct;
         const gradeIndex = laborGradeOptions.indexOf(grade);
         if (gradeIndex === -1) return 0;
         for (let index = gradeIndex + 1; index < laborGradeOptions.length; index += 1) {
-            const fallback = Number(currentLaborRates?.[laborGradeOptions[index]] || 0);
+            const fallback = Number(yearRates?.[laborGradeOptions[index]] || 0);
             if (fallback) return fallback;
         }
         return 0;
     }
 
-    function calculateLaborAmount(grade, hours) {
-        return getLaborRate(grade) * parseHours(hours);
+    function calculateLaborAmount(grade, hours, year = "") {
+        return getLaborRate(grade, year) * parseHours(hours);
     }
 
     function formatDateInputValue(value) {
@@ -4172,8 +4478,10 @@
     function createExecBudgetRow(group, row = {}) {
         if (group === "labor") {
             const selectedGrade = row.grade || row.dept_name || "";
+            const selectedRateYear = String(row.rate_year || getDefaultLaborRateYear());
             const inputHours = row.hours || row.work_name || "";
-            const amountValue = row.amount || calculateLaborAmount(selectedGrade, inputHours);
+            const amountValue = row.amount || calculateLaborAmount(selectedGrade, parseExecHoursDigits(inputHours), selectedRateYear);
+            const rateYearOptions = getLaborRateYears();
             return `
                 <tr data-group="${group}">
                     <td>
@@ -4182,8 +4490,13 @@
                             ${laborGradeOptions.map((grade) => `<option value="${escapeHtml(grade)}" ${selectedGrade === grade ? "selected" : ""}>${escapeHtml(grade)}</option>`).join("")}
                         </select>
                     </td>
-                    <td><input class="inline-input exec-labor-hours" type="text" inputmode="decimal" name="exec_labor_hours[]" value="${escapeHtml(formatHourInputValue(inputHours))}"></td>
+                    <td><input class="inline-input exec-labor-hours" type="text" inputmode="numeric" name="exec_labor_hours[]" value="${escapeHtml(formatHourInputValue(inputHours))}"></td>
                     <td><input class="inline-input amount-input formatted-amount-input exec-labor-amount" data-amount-input type="text" inputmode="numeric" name="exec_labor_amount[]" value="${escapeHtml(formatAmountInputValue(amountValue))}" readonly></td>
+                    <td>
+                        <select class="inline-input exec-labor-rate-year" name="exec_labor_rate_year[]">
+                            ${rateYearOptions.map((year) => `<option value="${escapeHtml(String(year))}" ${selectedRateYear === String(year) ? "selected" : ""}>${escapeHtml(String(year))}</option>`).join("")}
+                        </select>
+                    </td>
                     <td><button type="button" class="button-link danger-lite mini-button button-icon row-remove-button" data-remove-row title="행 삭제" aria-label="행 삭제">
                         <svg viewBox="0 0 24 24" aria-hidden="true">
                             <path d="M6 12h12"></path>
@@ -4236,9 +4549,11 @@
 
     function createActualLaborRow(row = {}) {
         const selectedGrade = row.grade || "";
+        const selectedRateYear = String(row.rate_year || getDefaultLaborRateYear());
         const inputMinutes = Number(row.minutes || row.work_name || 0);
         const splitDuration = splitDurationMinutes(inputMinutes);
-        const amountValue = row.amount || calculateLaborAmount(selectedGrade, inputMinutes / 60);
+        const amountValue = row.amount || calculateLaborAmount(selectedGrade, inputMinutes / 60, selectedRateYear);
+        const rateYearOptions = getLaborRateYears();
         return `
             <tr data-group="labor">
                 <td>
@@ -4257,6 +4572,11 @@
                     <input class="actual-labor-minutes" type="hidden" name="actual_labor_minutes[]" value="${escapeHtml(String(inputMinutes || ""))}">
                 </td>
                 <td><input class="inline-input amount-input formatted-amount-input actual-labor-amount" data-amount-input type="text" inputmode="numeric" name="actual_labor_amount[]" value="${escapeHtml(formatAmountInputValue(amountValue))}" readonly></td>
+                <td>
+                    <select class="inline-input actual-labor-rate-year" name="actual_labor_rate_year[]">
+                        ${rateYearOptions.map((year) => `<option value="${escapeHtml(year)}" ${selectedRateYear === String(year) ? "selected" : ""}>${escapeHtml(String(year))}</option>`).join("")}
+                    </select>
+                </td>
                 <td><button type="button" class="button-link danger-lite mini-button button-icon row-remove-button" data-remove-row title="행 삭제" aria-label="행 삭제">
                     <svg viewBox="0 0 24 24" aria-hidden="true">
                         <path d="M6 12h12"></path>
@@ -4288,6 +4608,7 @@
     function recalculateActualLaborAmounts() {
         actualLaborRows.querySelectorAll("tr").forEach((row) => {
             const grade = row.querySelector(".actual-labor-grade")?.value || "";
+            const rateYear = row.querySelector(".actual-labor-rate-year")?.value || getDefaultLaborRateYear();
             const hoursInput = row.querySelector(".actual-labor-hours");
             const minuteInput = row.querySelector(".actual-labor-minute-part");
             const hours = Number(String(hoursInput?.value || "").replace(/[^\d]/g, "")) || 0;
@@ -4307,7 +4628,7 @@
                 hiddenMinutesInput.value = String(minutes || "");
             }
             if (amountInput) {
-                amountInput.value = formatAmountInputValue(calculateLaborAmount(grade, minutes / 60));
+                amountInput.value = formatAmountInputValue(calculateLaborAmount(grade, minutes / 60, rateYear));
             }
         });
     }
@@ -4418,6 +4739,20 @@
                 };
             });
         }
+        if (container === execLaborRows) {
+            container.querySelectorAll(".exec-labor-hours").forEach((input) => {
+                input.oninput = () => {
+                    const digits = String(input.value || "").replace(/[^\d]/g, "").slice(0, 5);
+                    input.value = formatHourInputValue(digits);
+                    recalculateExecLaborAmounts();
+                };
+                input.onblur = () => {
+                    const digits = String(input.value || "").replace(/[^\d]/g, "").slice(0, 5);
+                    input.value = formatHourInputValue(digits);
+                    recalculateExecLaborAmounts();
+                };
+            });
+        }
     }
 
     function addRow(target, row = {}) {
@@ -4578,28 +4913,59 @@
 
     function renderLaborRateRows() {
         if (!laborRateRows) return;
+        const selectedRateYear = String(laborRateYearSelect?.value || getDefaultLaborRateYear());
+        const yearRates = currentLaborRates?.[selectedRateYear] || {};
         laborRateRows.innerHTML = laborGradeOptions.map((grade) => `
             <tr>
                 <td>${escapeHtml(grade)}</td>
-                <td><input class="inline-input amount-input formatted-amount-input labor-rate-input" type="text" inputmode="numeric" data-grade="${escapeHtml(grade)}" value="${escapeHtml(formatAmountInputValue(currentLaborRates?.[grade] || ""))}"></td>
+                <td><input class="inline-input amount-input formatted-amount-input labor-rate-input" type="text" inputmode="numeric" data-grade="${escapeHtml(grade)}" value="${escapeHtml(formatAmountInputValue(yearRates?.[grade] || ""))}"></td>
             </tr>
         `).join("");
         bindCollectionFieldBehaviors(laborRateRows);
         laborRateRows.querySelectorAll(".labor-rate-input").forEach((input) => {
             input.addEventListener("input", () => {
                 const grade = input.dataset.grade || "";
-                currentLaborRates[grade] = parseAmount(input.value);
+                const targetYear = String(laborRateYearSelect?.value || getDefaultLaborRateYear());
+                const nextYearRates = { ...(currentLaborRates?.[targetYear] || {}) };
+                nextYearRates[grade] = parseAmount(input.value);
+                currentLaborRates[targetYear] = nextYearRates;
                 writeLaborRates(currentLaborRates);
                 recalculateExecLaborAmounts();
+                recalculateActualLaborAmounts();
             });
         });
     }
 
     function openLaborRateModal() {
+        if (laborRateYearSelect) {
+            const years = getLaborRateYears();
+            const activeYear = String(laborRateYearSelect.value || getDefaultLaborRateYear());
+            laborRateYearSelect.innerHTML = years
+                .map((year) => `<option value="${escapeHtml(String(year))}" ${String(year) === activeYear ? "selected" : ""}>${escapeHtml(String(year))}</option>`)
+                .join("");
+            if (!laborRateYearSelect.value || !years.includes(String(laborRateYearSelect.value))) {
+                laborRateYearSelect.value = activeYear;
+            }
+        }
         renderLaborRateRows();
         laborRateModal?.classList.add("open");
     }
 
+    function saveLaborRateYear() {
+        const targetYear = String(laborRateYearSelect?.value || getDefaultLaborRateYear());
+        const nextYearRates = { ...(currentLaborRates?.[targetYear] || {}) };
+        laborRateRows?.querySelectorAll(".labor-rate-input").forEach((input) => {
+            const grade = String(input.dataset.grade || "").trim();
+            if (!grade) return;
+            nextYearRates[grade] = parseAmount(input.value);
+        });
+        currentLaborRates[targetYear] = nextYearRates;
+        writeLaborRates(currentLaborRates);
+        recalculateExecLaborAmounts();
+        recalculateActualLaborAmounts();
+        window.alert(`${targetYear}년 기준인건비를 저장했습니다.`);
+    }
+
     function closeLaborRateModal() {
         laborRateModal?.classList.remove("open");
     }
@@ -4607,10 +4973,16 @@
     function recalculateExecLaborAmounts() {
         execLaborRows.querySelectorAll("tr").forEach((row) => {
             const grade = row.querySelector(".exec-labor-grade")?.value || "";
-            const hours = row.querySelector(".exec-labor-hours")?.value || "";
+            const hoursRaw = row.querySelector(".exec-labor-hours")?.value || "";
+            const hours = parseExecHoursDigits(hoursRaw);
+            const rateYear = row.querySelector(".exec-labor-rate-year")?.value || getDefaultLaborRateYear();
             const amountInput = row.querySelector(".exec-labor-amount");
+            const hourInput = row.querySelector(".exec-labor-hours");
+            if (hourInput) {
+                hourInput.value = formatHourInputValue(String(hourInput.value || "").replace(/[^\d]/g, "").slice(0, 5));
+            }
             if (amountInput) {
-                amountInput.value = formatAmountInputValue(calculateLaborAmount(grade, hours));
+                amountInput.value = formatAmountInputValue(calculateLaborAmount(grade, hours, rateYear));
             }
         });
         updateComputedFields();
@@ -4854,6 +5226,7 @@
             applyProjectEditData(payload);
             window.__suspendAutoRefresh = true;
             modal?.classList.add("open");
+            restoreProjectStatusDraftIfPresent(normalizedCode);
         } catch (error) {
             console.error(error);
             if (projectEditCache.has(normalizedCode)) {
@@ -4862,6 +5235,7 @@
                 applyProjectEditData(cachedData);
                 window.__suspendAutoRefresh = true;
                 modal?.classList.add("open");
+                restoreProjectStatusDraftIfPresent(normalizedCode);
                 return;
             }
             window.alert("사업현황 데이터를 불러오지 못했습니다.");
@@ -4876,6 +5250,7 @@
         applyProjectEditData(emptyData);
         window.__suspendAutoRefresh = true;
         modal?.classList.add("open");
+        restoreProjectStatusDraftIfPresent(normalizedCode);
     }
 
     function closeProjectModal() {
@@ -4889,6 +5264,142 @@
         document.activeElement?.blur?.();
     }
 
+    function getProjectStatusDraftCode(code = "") {
+        return String(code || supportDeptCodeInput?.value || currentSelectedProjectCode || "__new__").trim() || "__new__";
+    }
+
+    function getProjectStatusDraftKey(code = "") {
+        return `${PROJECT_STATUS_DRAFT_STORAGE_PREFIX}:${getProjectStatusDraftCode(code)}`;
+    }
+
+    function buildProjectStatusDraftPayload() {
+        if (!(projectStatusForm instanceof HTMLFormElement)) return null;
+        const formData = new FormData(projectStatusForm);
+        const formEntries = [];
+        formData.forEach((value, key) => {
+            formEntries.push([key, String(value)]);
+        });
+        const containers = {};
+        Object.entries(projectStatusDraftContainers).forEach(([key, container]) => {
+            containers[key] = container?.innerHTML || "";
+        });
+        return {
+            code: getProjectStatusDraftCode(),
+            saved_at: new Date().toISOString(),
+            form_entries: formEntries,
+            containers,
+        };
+    }
+
+    function persistProjectStatusDraftNow() {
+        try {
+            const draft = buildProjectStatusDraftPayload();
+            if (!draft) return;
+            window.localStorage.setItem(getProjectStatusDraftKey(draft.code), JSON.stringify(draft));
+        } catch (error) {
+            console.warn("사업현황 임시 저장에 실패했습니다.", error);
+        }
+    }
+
+    function scheduleProjectStatusDraftSave() {
+        window.clearTimeout(projectStatusDraftTimer);
+        projectStatusDraftTimer = window.setTimeout(() => {
+            persistProjectStatusDraftNow();
+        }, 180);
+    }
+
+    function clearProjectStatusDraft(code = "") {
+        const keys = new Set([
+            getProjectStatusDraftKey(code),
+            getProjectStatusDraftKey(),
+            `${PROJECT_STATUS_DRAFT_STORAGE_PREFIX}:__new__`,
+        ]);
+        keys.forEach((key) => {
+            try {
+                window.localStorage.removeItem(key);
+            } catch (error) {
+                console.warn("사업현황 임시 저장 삭제에 실패했습니다.", error);
+            }
+        });
+    }
+
+    function applyProjectStatusDraftEntries(entries) {
+        if (!(projectStatusForm instanceof HTMLFormElement) || !Array.isArray(entries)) return;
+        const grouped = new Map();
+        entries.forEach((entry) => {
+            if (!Array.isArray(entry) || entry.length < 2) return;
+            const name = String(entry[0] || "");
+            if (!name) return;
+            const values = grouped.get(name) || [];
+            values.push(String(entry[1] || ""));
+            grouped.set(name, values);
+        });
+        grouped.forEach((values, name) => {
+            const fields = [...projectStatusForm.querySelectorAll(`[name="${CSS.escape(name)}"]`)];
+            fields.forEach((field, index) => {
+                const value = values[index] ?? "";
+                if (field instanceof HTMLInputElement || field instanceof HTMLTextAreaElement || field instanceof HTMLSelectElement) {
+                    field.value = value;
+                }
+            });
+        });
+    }
+
+    function restoreProjectStatusDraftIfPresent(code = "") {
+        try {
+            const raw = window.localStorage.getItem(getProjectStatusDraftKey(code));
+            if (!raw) return false;
+            const draft = JSON.parse(raw);
+            const containers = draft?.containers || {};
+            Object.entries(projectStatusDraftContainers).forEach(([key, container]) => {
+                if (!container || typeof containers[key] !== "string") return;
+                container.innerHTML = containers[key];
+            });
+            applyProjectStatusDraftEntries(draft?.form_entries || []);
+            Object.values(projectStatusDraftContainers).forEach((container) => {
+                if (container) attachTableEvents(container);
+            });
+            bindDateTextInputs(document);
+            recalculateExecLaborAmounts();
+            recalculateActualLaborAmounts();
+            updateComputedFields();
+            return true;
+        } catch (error) {
+            console.warn("사업현황 임시 저장 복원에 실패했습니다.", error);
+            return false;
+        }
+    }
+
+    function buildScopedProjectStatusBody(scope = "all") {
+        if (!(projectStatusForm instanceof HTMLFormElement)) {
+            return new URLSearchParams();
+        }
+        const formData = new FormData(projectStatusForm);
+        if (selectedYear) {
+            formData.set("selected_year", String(selectedYear));
+        }
+        const body = new URLSearchParams();
+        if (scope === "all") {
+            formData.forEach((value, key) => {
+                body.append(key, String(value));
+            });
+            body.set("save_scope", "all");
+            return body;
+        }
+        const scopedNames = new Set([
+            ...PROJECT_STATUS_COMMON_FIELDS,
+            ...(PROJECT_STATUS_SCOPE_FIELDS[scope] || []),
+        ]);
+        scopedNames.forEach((name) => {
+            const values = formData.getAll(name);
+            values.forEach((value) => {
+                body.append(name, String(value));
+            });
+        });
+        body.set("save_scope", scope);
+        return body;
+    }
+
     bindSupportLookup(supportDeptCodeLookup, supportDeptCodeResults);
     bindSupportLookup(supportDeptNameInput, supportDeptNameResults);
     bindDateTextInputs(document);
@@ -4928,9 +5439,15 @@
             setTimeout(() => resultBox?.classList.remove("open"), 120);
         }
     });
+    projectStatusForm?.addEventListener("input", scheduleProjectStatusDraftSave);
+    projectStatusForm?.addEventListener("change", scheduleProjectStatusDraftSave);
 
     openLaborRateModalButton?.addEventListener("click", openLaborRateModal);
+    saveLaborRateYearButton?.addEventListener("click", saveLaborRateYear);
     closeLaborRateModalButton?.addEventListener("click", closeLaborRateModal);
+    laborRateYearSelect?.addEventListener("change", () => {
+        renderLaborRateRows();
+    });
     laborRateModal?.addEventListener("click", (event) => {
         if (event.target === laborRateModal) {
             closeLaborRateModal();
@@ -4983,7 +5500,7 @@
     }
     applyProjectEditData(projectEdit);
 
-    async function handleProjectStatusSave(event) {
+    async function handleProjectStatusSave(event, scope = "all") {
         event?.preventDefault?.();
         event?.stopPropagation?.();
         event?.stopImmediatePropagation?.();
@@ -4991,7 +5508,15 @@
         resolveSupportDepartmentFromLookup();
         const form = projectStatusForm;
         if (!(form instanceof HTMLFormElement)) return;
-        const saveButtons = [...form.querySelectorAll('button[type="submit"]')];
+        const submittedAtInput = form.querySelector('input[name="client_submitted_at"]');
+        if (submittedAtInput instanceof HTMLInputElement) {
+            submittedAtInput.value = new Date().toISOString();
+        }
+        const projectPageHelpers = window.__projectPageHelpers || null;
+        const saveButtons = [
+            ...form.querySelectorAll('button[type="submit"]'),
+            ...form.querySelectorAll("[data-save-scope-button]"),
+        ];
         if (saveProjectModalButton) {
             saveButtons.push(saveProjectModalButton);
         }
@@ -4999,14 +5524,9 @@
             button.disabled = true;
         });
         try {
+            persistProjectStatusDraftNow();
             const formData = new FormData(form);
-            if (selectedYear) {
-                formData.set("selected_year", String(selectedYear));
-            }
-            const body = new URLSearchParams();
-            formData.forEach((value, key) => {
-                body.append(key, String(value));
-            });
+            const body = buildScopedProjectStatusBody(scope);
             const response = await fetch("/projects/save-json", {
                 method: "POST",
                 credentials: "same-origin",
@@ -5018,7 +5538,10 @@
             });
             const payload = await response.json().catch(() => ({}));
             if (!response.ok || payload?.ok === false) {
-                throw new Error(payload?.error || `HTTP ${response.status}`);
+                const saveError = new Error(payload?.error || `HTTP ${response.status}`);
+                saveError.payload = payload;
+                saveError.status = response.status;
+                throw saveError;
             }
             const updatedEdit = cloneProjectEditData(payload?.project_edit || {});
             const updatedRow = payload?.project_row || null;
@@ -5035,11 +5558,15 @@
                 projectEdit = updatedEdit;
                 modalOriginalEdit = cloneProjectEditData(updatedEdit);
                 projectEditCache.set(updatedEdit.support_dept_code, updatedEdit);
-                applyProjectEditData(updatedEdit);
+                if (editRevisionInput) {
+                    editRevisionInput.value = updatedEdit.updated_at || "";
+                }
+                if (scope === "all") {
+                    applyProjectEditData(updatedEdit);
+                }
             }
             if (updatedRow?.support_dept_code) {
                 bumpUncontractedDashboardRevision();
-                const projectPageHelpers = window.__projectPageHelpers || null;
                 if (projectPageHelpers?.upsertProjectStatusRow) {
                     projectPageHelpers.upsertProjectStatusRow(updatedRow);
                 }
@@ -5051,13 +5578,11 @@
                 selectedCode = savedCode;
                 currentSelectedProjectCode = savedCode;
                 analysisOpen = true;
-                const refreshedItem = getAnalysisItem(savedCode) || updatedRow || projectStatusMap[savedCode] || null;
-                if (refreshedItem) {
-                    if (input) {
-                        input.value = refreshedItem.support_dept_name || "";
-                    }
-                    setAnalysisVisibility(true);
-                    renderAnalysis(refreshedItem);
+                if (projectPageHelpers?.refreshAnalysisForCode) {
+                    projectPageHelpers.refreshAnalysisForCode(savedCode);
+                }
+                if (scope === "all") {
+                    clearProjectStatusDraft(savedCode);
                 }
                 try {
                     const nextUrl = new URL(window.location.href);
@@ -5079,9 +5604,26 @@
                     console.warn("저장 후 페이지 상태를 저장하지 못했습니다.", stateError);
                 }
             }
+            const scopeLabelMap = {
+                all: "사업현황",
+                basic_info: "기본 정보",
+                collection: "수금 정보",
+                task_plan: "과업수행계획",
+                exec_budget: "실행예산",
+                actual_input: "실투입",
+                allocation: "배분 설정",
+                notes: "비고",
+            };
+            const scopeLabel = scopeLabelMap[String(scope || "all")] || "사업현황";
+            window.alert(`${scopeLabel} 저장이 완료되었습니다.`);
         } catch (error) {
             console.error(error);
-            window.alert(error?.message || "사업현황 저장 중 오류가 발생했습니다.");
+            const payload = error?.payload || null;
+            if (payload?.conflict) {
+                window.alert(`${error?.message || "다른 사용자가 먼저 수정했습니다."}\n현재 입력값은 이 브라우저에 임시 보전되었습니다.`);
+            } else {
+                window.alert(error?.message || "사업현황 저장 중 오류가 발생했습니다.");
+            }
         } finally {
             saveButtons.forEach((button) => {
                 button.disabled = false;
@@ -5091,6 +5633,12 @@
 
     projectStatusForm?.addEventListener("submit", handleProjectStatusSave);
     saveProjectModalButton?.addEventListener("click", handleProjectStatusSave);
+    document.querySelectorAll("[data-save-scope-button]").forEach((button) => {
+        button.addEventListener("click", (event) => {
+            const scope = button.getAttribute("data-save-scope-button") || "all";
+            handleProjectStatusSave(event, scope);
+        });
+    });
 
     function renderRevenueLegend(items) {
         const legend = document.getElementById("revenueLegend");
@@ -5206,7 +5754,7 @@
         const totalExpense = Number((statusItem?.total_cost || 0) + (statusItem?.total_sga || 0) || costItem?.expense_amount || 0);
         const plannedTaskTotal = Number(statusItem?.task_plan_department_budget || 0) + Number(statusItem?.task_plan_outsource_budget || 0) + Number(statusItem?.task_plan_joint_operating_cost || 0);
         const execBudgetTotal = Number(statusItem?.exec_budget_labor_by_grade || 0) + Number(statusItem?.exec_budget_outsource || 0) + Number(statusItem?.exec_budget_cost_plan || 0);
-        return {
+        const mergedItem = {
             ...costItem,
             ...statusItem,
             support_dept_name: supportDeptName,
@@ -5220,6 +5768,8 @@
             operating_balance: totalRevenue - totalExpense,
             year_range: formatYearRange(costItem || statusItem || {}),
         };
+        mergedItem.item_investment = sumActualInputInvestment(mergedItem);
+        return mergedItem;
     }
 
     function getProjectContractState(item) {
@@ -5583,6 +6133,128 @@
         `;
     }
 
+    function renderTransactionDetailTable(entries, columns) {
+        const rows = Array.isArray(entries) ? entries : [];
+        if (!rows.length) {
+            return `<div class="comparison-detail-item"><span>세부 내역 없음</span><strong>-</strong></div>`;
+        }
+        return `
+            <div class="comparison-detail-table-wrap">
+                <table class="comparison-detail-table">
+                    <thead>
+                        <tr>
+                            ${columns.map((column) => `<th>${escapeHtml(column.label)}</th>`).join("")}
+                        </tr>
+                    </thead>
+                    <tbody>
+                        ${rows.map((row) => `
+                            <tr>
+                                ${columns.map((column) => {
+                                    const rawValue = row?.[column.key];
+                                    const value = column.formatter ? column.formatter(rawValue, row) : rawValue;
+                                    return `<td>${escapeHtml(String(value ?? "-"))}</td>`;
+                                }).join("")}
+                            </tr>
+                        `).join("")}
+                    </tbody>
+                </table>
+            </div>
+        `;
+    }
+
+    function buildInlineComparisonDetailKey(meta) {
+        const code = meta?.support_dept_code || "";
+        const group = meta?.group || "";
+        const accountLabel = meta?.account_label || "";
+        const codes = Array.isArray(meta?.codes) ? meta.codes.join(",") : "";
+        return `${code}__${group}__${accountLabel}__${codes}`;
+    }
+
+    function renderOutsourceComparisonDetails(plannedEntries, actualEntries) {
+        const rows = (actualEntries || []).map((entry) => ({
+            posting_date: entry.posting_date || "-",
+            project_code: entry.project_code || "-",
+            account_label: entry.account_label || entry.account_name || entry.label || "-",
+            partner_name: entry.partner_name || "-",
+            amount: Number(entry.amount || 0),
+        }));
+        return `
+            <div class="comparison-detail-grid">
+                <section class="comparison-detail-group">
+                    <h5>계획/입력 세부</h5>
+                    <div class="comparison-detail-list">
+                        ${renderComparisonDetailList(plannedEntries, "")}
+                        <div class="comparison-detail-item is-total">
+                            <span>총계</span>
+                            <strong>${formatNumber(sumEntryAmounts(plannedEntries))}</strong>
+                        </div>
+                    </div>
+                </section>
+                <section class="comparison-detail-group">
+                    <h5>실제 집행 세부</h5>
+                    ${renderTransactionDetailTable(rows, [
+                        { key: "posting_date", label: "일자" },
+                        { key: "project_code", label: "프로젝트코드" },
+                        { key: "account_label", label: "계정" },
+                        { key: "partner_name", label: "거래처명" },
+                        { key: "amount", label: "금액", formatter: (value) => formatNumber(value || 0) },
+                    ])}
+                </section>
+            </div>
+        `;
+    }
+
+    function renderOverheadComparisonDetails(plannedEntries, actualEntries) {
+        const grouped = buildGroupedComparisonEntries(plannedEntries);
+        const actualRows = (actualEntries || []).map((entry) => {
+            const meta = entry.clickMeta || {};
+            return {
+                entry,
+                inlineKey: buildInlineComparisonDetailKey(meta),
+            };
+        });
+        return `
+            <div class="comparison-detail-grid">
+                <section class="comparison-detail-group">
+                    <h5>계획/입력 세부</h5>
+                    <div class="comparison-detail-list">
+                        ${renderComparisonDetailList(plannedEntries, "")}
+                        <div class="comparison-detail-item is-total">
+                            <span>총계</span>
+                            <strong>${formatNumber(grouped.total)}</strong>
+                        </div>
+                    </div>
+                </section>
+                <section class="comparison-detail-group">
+                    <h5>실제 집행 세부</h5>
+                    <div class="comparison-detail-list">
+                        ${actualRows.length ? actualRows.map(({ entry, inlineKey }) => `
+                            <div class="comparison-detail-item">
+                                <span>${escapeHtml(entry.label || "-")}</span>
+                                <strong
+                                    class="comparison-inline-toggle"
+                                    role="button"
+                                    tabindex="0"
+                                    aria-expanded="false"
+                                    data-comparison-inline-toggle="${escapeHtml(inlineKey)}"
+                                    data-support-dept-code="${escapeHtml(entry.clickMeta?.support_dept_code || "")}"
+                                    data-codes="${escapeHtml((entry.clickMeta?.codes || []).join(","))}"
+                                    data-comparison-group="${escapeHtml(entry.clickMeta?.group || "")}"
+                                    data-account-label="${escapeHtml(entry.clickMeta?.account_label || "")}"
+                                >${formatNumber(entry.amount || 0)}</strong>
+                            </div>
+                            <div class="comparison-inline-detail" data-comparison-inline-detail="${escapeHtml(inlineKey)}"></div>
+                        `).join("") : `<div class="comparison-detail-item"><span>세부 내역 없음</span><strong>-</strong></div>`}
+                        <div class="comparison-detail-item is-total">
+                            <span>총계</span>
+                            <strong>${formatNumber(sumEntryAmounts(actualEntries))}</strong>
+                        </div>
+                    </div>
+                </section>
+            </div>
+        `;
+    }
+
     function renderLaborComparisonDetails(baseCode, plannedEntries, erpEntries, jointEntries) {
         const plannedGrouped = buildGroupedComparisonEntries(plannedEntries);
         const erpGrouped = buildGroupedComparisonEntries(erpEntries);
@@ -5763,6 +6435,11 @@
         return (entries || []).reduce((sum, entry) => sum + Number(entry?.amount || 0), 0);
     }
 
+    function sumActualInputInvestment(item) {
+        if (!Array.isArray(item?.actual_input_entries)) return 0;
+        return item.actual_input_entries.reduce((sum, entry) => sum + Number(entry?.amount || 0), 0);
+    }
+
     function getExecBudgetGroupEntries(item, group, fallbackLabel) {
         const entries = Array.isArray(item?.exec_budget_entries)
             ? item.exec_budget_entries.filter((entry) => (entry?.group || "labor") === group)
@@ -5828,6 +6505,10 @@
         return Array.isArray(projectAccountBreakdowns?.[code]?.cost) ? projectAccountBreakdowns[code].cost : [];
     }
 
+    function getCostTransactionEntries(code) {
+        return Array.isArray(projectAccountBreakdowns?.[code]?.cost_detail) ? projectAccountBreakdowns[code].cost_detail : [];
+    }
+
     function sumNumericFields(target, source, keys) {
         keys.forEach((key) => {
             target[key] = Number(target[key] || 0) + Number(source?.[key] || 0);
@@ -5950,6 +6631,13 @@
         return label.includes("기술협력비");
     }
 
+    function escapeSelectorValue(value) {
+        if (window.CSS?.escape) {
+            return window.CSS.escape(String(value || ""));
+        }
+        return String(value || "").replace(/(["\\])/g, "\\$1");
+    }
+
     function formatComparisonCell(value) {
         return value === null || value === undefined ? "" : formatNumber(value);
     }
@@ -5974,6 +6662,11 @@
         const overheadInputActual = getActualGroupEntries(item, "overhead", "실투입 제경비");
         const asActual = getActualGroupEntries(item, "as", "실투입 A/S비");
         const sgaInputActual = getActualGroupEntries(item, "sga", "실투입 판관비");
+        const costTransactionEntries = aggregateCodes.flatMap((code) => getCostTransactionEntries(code).map((entry) => ({
+            ...entry,
+            project_code: code,
+            account_label: entry.label || [entry.account_code, entry.account_name].filter(Boolean).join(" · ") || "-",
+        })));
         const costEntries = aggregateCodes.flatMap((code) => getCostBreakdownEntries(code).map((entry) => ({
             label: `${code} · ${entry.label || "-"}`,
             amount: Number(entry.amount || 0),
@@ -5984,18 +6677,14 @@
         })));
         const outsourceActual = [
             ...outsourceInputActual,
-            ...costEntries
+            ...costTransactionEntries
             .filter(isDesignOutsourceEntry)
             .map((entry) => ({
-                ...entry,
-                clickMeta: {
-                    support_dept_code: item.support_dept_code,
-                    codes: aggregateCodes,
-                    group: "outsource",
-                    account_label: entry.account_label || entry.account_name || "",
-                    project_code: item.support_dept_code,
-                    project_name: item.support_dept_name,
-                },
+                posting_date: entry.posting_date || "-",
+                project_code: entry.project_code || item.support_dept_code,
+                partner_name: entry.partner_name || "-",
+                account_label: entry.account_label || entry.account_name || "",
+                amount: Number(entry.amount || 0),
             })),
         ];
         const overheadActual = [
@@ -6601,7 +7290,7 @@
     function renderAnalysisMetrics(item) {
         const details = buildComparisonDetails(item);
         const actualExecutionCost = getActualExecutionCostFromDetails(details);
-        const operatingBalance = Number(item.collection_amount || 0) - actualExecutionCost;
+        const operatingBalance = Number(item.total_revenue || item.revenue_amount || 0) - actualExecutionCost;
         return `
             <h4>핵심 비교 지표</h4>
             <div class="analysis-kpis">
@@ -6663,7 +7352,11 @@
                         const plannedEntries = detail?.planned || [];
                         const actualEntries = detail?.actual || [];
                         const analysisSetting = getProjectAnalysisSetting(item.support_dept_code);
-                        const showLaborJointPending = key === "labor" && !analysisSetting.labor_joint_exempt;
+                        const laborJointActualEntries = detail?.actual_joint || [];
+                        const hasLaborJointInput = laborJointActualEntries.some((entry) => {
+                            return Number(entry?.amount || 0) !== 0 || String(entry?.label || "").trim() !== "";
+                        });
+                        const showLaborJointPending = key === "labor" && !analysisSetting.labor_joint_exempt && !hasLaborJointInput;
                         return `
                             <tr class="comparison-main-row${hasDetail ? "" : " no-detail"}" ${hasDetail ? `data-detail-target="${key}"` : ""}>
                                 <td>
@@ -6701,12 +7394,22 @@
                                                     detail?.actual_joint || [],
                                                 )}
                                             `
-                                            : renderPairedComparisonDetails(
-                                                plannedEntries,
-                                                actualEntries,
-                                                "",
-                                                "",
-                                            )}
+                                            : key === "outsource"
+                                                ? renderOutsourceComparisonDetails(
+                                                    plannedEntries,
+                                                    actualEntries,
+                                                )
+                                                : key === "overhead"
+                                                    ? renderOverheadComparisonDetails(
+                                                        plannedEntries,
+                                                        actualEntries,
+                                                    )
+                                                    : renderPairedComparisonDetails(
+                                                        plannedEntries,
+                                                        actualEntries,
+                                                        "",
+                                                        "",
+                                                    )}
                                     </div>
                                 </td>
                             </tr>` : ""}
@@ -6718,6 +7421,10 @@
     }
 
     function renderAnalysisNotes(item) {
+        const details = buildComparisonDetails(item);
+        const actualLaborAmount = sumEntryAmounts(details.labor?.actual) + sumEntryAmounts(details.labor?.actual_joint);
+        const actualOutsourceAmount = sumEntryAmounts(details.outsource?.actual);
+        const actualInvestmentAmount = sumActualInputInvestment(item);
         return `
             <h4>프로젝트 세부 입력 정보</h4>
             <div class="analysis-note-grid">
@@ -6726,9 +7433,9 @@
                         <div class="detail-item"><span>차수변경</span><strong>${detailValue(item.change_round)}</strong></div>
                         <div class="detail-item"><span>예상 A/S비</span><strong>${formatNumber(item.expected_as_cost || 0)}</strong></div>
                         <div class="detail-item"><span>예상 판관비</span><strong>${formatNumber(item.expected_sga_budget || 0)}</strong></div>
-                        <div class="detail-item"><span>실집행 인건비</span><strong>${formatNumber((sumEntryAmounts(getActualGroupEntries(item, "labor", "실투입 인건비")) + sumEntryAmounts(getActualGroupEntries(item, "labor_joint", "실투입 인건비(합사)"))) || 0)}</strong></div>
-                        <div class="detail-item"><span>실집행 외주비</span><strong>${formatNumber(item.actual_outsource || 0)}</strong></div>
-                        <div class="detail-item"><span>항목별투입액</span><strong>${formatNumber(item.item_investment || 0)}</strong></div>
+                        <div class="detail-item"><span>실집행 인건비</span><strong>${formatNumber(actualLaborAmount || 0)}</strong></div>
+                        <div class="detail-item"><span>실집행 외주비</span><strong>${formatNumber(actualOutsourceAmount || 0)}</strong></div>
+                        <div class="detail-item"><span>항목별투입액</span><strong>${formatNumber(actualInvestmentAmount || 0)}</strong></div>
                         <div class="detail-item"><span>청구합계</span><strong>${formatNumber(item.billed_amount || 0)}</strong></div>
                         <div class="detail-item"><span>수금잔액</span><strong>${formatNumber(item.collection_balance_amount || 0)}</strong></div>
                         <div class="detail-item"><span>비고</span><strong>${detailValue(item.notes)}</strong></div>
@@ -7025,6 +7732,10 @@
     }
 
     function renderDetailCard(item) {
+        const details = buildComparisonDetails(item);
+        const actualLaborAmount = sumEntryAmounts(details.labor?.actual) + sumEntryAmounts(details.labor?.actual_joint);
+        const actualOutsourceAmount = sumEntryAmounts(details.outsource?.actual);
+        const actualInvestmentAmount = sumActualInputInvestment(item);
         const periodLabel = item.project_duration_days !== null && item.project_duration_days !== undefined
             ? `${item.project_duration_days}일`
             : "-";
@@ -7085,7 +7796,7 @@
                             <div class="detail-item"><span>원가계정별 비용계획</span><strong>${formatNumber(item.exec_budget_cost_plan)}</strong></div>
                             <div class="detail-item"><span>예상 A/S비</span><strong>${formatNumber(item.expected_as_cost)}</strong></div>
                             <div class="detail-item"><span>예상 판관비</span><strong>${formatNumber(item.expected_sga_budget)}</strong></div>
-                            <div class="detail-item"><span>항목별투입액</span><strong>${formatNumber(item.item_investment)}</strong></div>
+                            <div class="detail-item"><span>항목별투입액</span><strong>${formatNumber(actualInvestmentAmount)}</strong></div>
                         </div>
                     </div>
                     <div class="detail-block">
@@ -7094,8 +7805,8 @@
                             <div class="detail-item"><span>실집행 수익</span><strong>${formatNumber(item.total_revenue)}</strong></div>
                             <div class="detail-item"><span>실집행 원가</span><strong>${formatNumber(item.total_cost)}</strong></div>
                             <div class="detail-item"><span>실집행 판관비</span><strong>${formatNumber(sumEntryAmounts(getActualGroupEntries(item, "sga", "실투입 판관비")))}</strong></div>
-                            <div class="detail-item"><span>실집행 인건비</span><strong>${formatNumber(sumEntryAmounts(getActualGroupEntries(item, "labor", "실투입 인건비")) + sumEntryAmounts(getActualGroupEntries(item, "labor_joint", "실투입 인건비(합사)")))}</strong></div>
-                            <div class="detail-item"><span>실집행 외주비</span><strong>${formatNumber(item.actual_outsource)}</strong></div>
+                            <div class="detail-item"><span>실집행 인건비</span><strong>${formatNumber(actualLaborAmount)}</strong></div>
+                            <div class="detail-item"><span>실집행 외주비</span><strong>${formatNumber(actualOutsourceAmount)}</strong></div>
                             <div class="detail-item"><span>비고</span><strong>${detailValue(item.notes)}</strong></div>
                         </div>
                     </div>
@@ -7530,6 +8241,71 @@
         }
     }
 
+    async function toggleComparisonInlineDetail(trigger) {
+        const inlineKey = String(trigger?.dataset.comparisonInlineToggle || "").trim();
+        const container = inlineKey
+            ? comparisonBox?.querySelector(`[data-comparison-inline-detail="${escapeSelectorValue(inlineKey)}"]`)
+            : null;
+        if (!inlineKey || !container) return;
+
+        const isOpen = container.classList.contains("is-open");
+        if (isOpen) {
+            container.classList.remove("is-open");
+            container.innerHTML = "";
+            trigger.setAttribute("aria-expanded", "false");
+            return;
+        }
+
+        trigger.setAttribute("aria-expanded", "true");
+        container.classList.add("is-open");
+        container.innerHTML = `<div class="comparison-inline-detail-note">거래내역을 불러오는 중입니다.</div>`;
+
+        if (comparisonInlineDetailCache.has(inlineKey)) {
+            const cachedRows = comparisonInlineDetailCache.get(inlineKey) || [];
+            container.innerHTML = renderTransactionDetailTable(cachedRows, [
+                { key: "posting_date", label: "일자" },
+                { key: "account_label", label: "계정" },
+                { key: "partner_name", label: "거래처명" },
+                { key: "amount", label: "금액", formatter: (value) => formatNumber(value || 0) },
+            ]);
+            return;
+        }
+
+        const params = new URLSearchParams({
+            support_dept_code: String(trigger.dataset.supportDeptCode || "").trim(),
+            codes: String(trigger.dataset.codes || "").trim(),
+            group: String(trigger.dataset.comparisonGroup || "").trim(),
+            account_label: String(trigger.dataset.accountLabel || "").trim(),
+        });
+
+        try {
+            const response = await fetch(`/projects/comparison-actual-transactions?${params.toString()}`, {
+                credentials: "same-origin",
+                headers: { Accept: "application/json" },
+            });
+            const payload = await response.json();
+            if (!response.ok || payload?.error) {
+                throw new Error(payload?.error || `HTTP ${response.status}`);
+            }
+            const rows = Array.isArray(payload?.rows) ? payload.rows.map((row) => ({
+                posting_date: row.posting_date || "-",
+                account_label: row.account_label || row.account_name || "-",
+                partner_name: row.partner_name || "-",
+                amount: Number(row.amount || 0),
+            })) : [];
+            comparisonInlineDetailCache.set(inlineKey, rows);
+            container.innerHTML = renderTransactionDetailTable(rows, [
+                { key: "posting_date", label: "일자" },
+                { key: "account_label", label: "계정" },
+                { key: "partner_name", label: "거래처명" },
+                { key: "amount", label: "금액", formatter: (value) => formatNumber(value || 0) },
+            ]);
+        } catch (error) {
+            console.error(error);
+            container.innerHTML = `<div class="comparison-inline-detail-note">거래내역을 불러오지 못했습니다.</div>`;
+        }
+    }
+
     async function openVendorTransactionModal(partnerCode, partnerName, projectCode, projectName) {
         const normalizedPartnerCode = String(partnerCode || "").trim();
         const normalizedPartnerName = String(partnerName || "").trim();
@@ -7962,6 +8738,19 @@
                     openModal();
                 });
             });
+            comparisonBox.querySelectorAll("[data-comparison-inline-toggle]").forEach((trigger) => {
+                trigger.addEventListener("click", async (event) => {
+                    event.preventDefault();
+                    event.stopPropagation();
+                    await toggleComparisonInlineDetail(trigger);
+                });
+                trigger.addEventListener("keydown", async (event) => {
+                    if (event.key !== "Enter" && event.key !== " ") return;
+                    event.preventDefault();
+                    event.stopPropagation();
+                    await toggleComparisonInlineDetail(trigger);
+                });
+            });
         }
 
         window.__projectPageHelpers = {