diff --git a/.gitea/workflows/snapshot_admin.yml b/.gitea/workflows/snapshot_admin.yml
new file mode 100644
index 0000000..dbbfc6f
--- /dev/null
+++ b/.gitea/workflows/snapshot_admin.yml
@@ -0,0 +1,44 @@
+name: Snapshot Admin Web Validation
+
+on:
+  workflow_dispatch:
+  push:
+    paths:
+      - "src/quant_engine/snapshot_admin_server_v1.py"
+      - "src/quant_engine/snapshot_admin_store_v1.py"
+      - "tools/run_snapshot_admin_server_v1.py"
+      - "tools/validate_snapshot_admin_workflow_v1.py"
+      - "tools/validate_snapshot_admin_web_v1.py"
+      - "spec/15_account_snapshot_contract.yaml"
+      - "spec/18_settings_contract.yaml"
+      - "GatherTradingData.json"
+
+jobs:
+  validate-snapshot-admin:
+    runs-on: self-hosted
+    steps:
+      - name: Checkout Code
+        run: |
+          if [ -d .git ]; then
+            git remote set-url origin http://x-access-token:${{ secrets.GITHUB_TOKEN }}@192.168.123.100:8418/KimJaeHyun/myfinance.git
+          else
+            git init
+            git remote add origin http://x-access-token:${{ secrets.GITHUB_TOKEN }}@192.168.123.100:8418/KimJaeHyun/myfinance.git
+          fi
+          git fetch origin main --depth=1
+          git reset --hard FETCH_HEAD
+
+      - name: Validate Snapshot Admin Workflow
+        run: python3 tools/validate_snapshot_admin_workflow_v1.py
+
+      - name: Validate Snapshot Admin Web UI
+        run: python3 tools/validate_snapshot_admin_web_v1.py
+
+      - name: Notify Run Result
+        if: always()
+        run: |
+          STATUS="${{ job.status }}"
+          echo "=== Snapshot Admin Web Validation ==="
+          echo "status: $STATUS"
+          echo "workflow validation: Temp/snapshot_admin_workflow_v1.json"
+          echo "web validation: Temp/snapshot_admin_web_validation_v1.json"
diff --git a/src/quant_engine/snapshot_admin_server_v1.py b/src/quant_engine/snapshot_admin_server_v1.py
new file mode 100644
index 0000000..a9f2663
--- /dev/null
+++ b/src/quant_engine/snapshot_admin_server_v1.py
@@ -0,0 +1,3007 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sqlite3
+import subprocess
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+from hashlib import sha256
+from typing import Any
+from urllib.parse import urlparse, parse_qs
+
+ROOT = Path(__file__).resolve().parents[2]
+SNAPSHOT_ADMIN_VERSION = "snapshot-admin-web-v6"
+KIS_COLLECTION_DB = ROOT / "outputs" / "kis_data_collection" / "kis_data_collection.db"
+KIS_COLLECTION_REPORT = ROOT / "Temp" / "kis_data_collection_v1.json"
+QUALITATIVE_SELL_DB = ROOT / "outputs" / "qualitative_sell_strategy" / "qualitative_sell_strategy.db"
+
+# WBS-7.9 부속 — 테이블별 그리드 조회(Tabler). 화이트리스트에 없는 테이블명은
+# SQL에 절대 보간되지 않는다(요청 테이블명을 그대로 SELECT 문에 넣지 않고
+# 아래 레지스트리 키와 정확히 일치할 때만 허용).
+WORKSPACE_BROWSABLE_TABLES = (
+    "settings",
+    "account_snapshot",
+    "workspace_change_log",
+    "workspace_approval_v2",
+    "workspace_lock",
+    "workspace_meta",
+)
+COLLECTION_BROWSABLE_TABLES = (
+    "collection_runs",
+    "collection_snapshots",
+    "collection_source_errors",
+)
+QUALITATIVE_SELL_BROWSABLE_TABLES = (
+    "sell_strategy_results",
+    "satellite_recommendations",
+)
+
+
+def _resolve_table_db(table: str, workspace_db_path: Path) -> Path | None:
+    if table in WORKSPACE_BROWSABLE_TABLES:
+        return Path(workspace_db_path)
+    if table in COLLECTION_BROWSABLE_TABLES:
+        return KIS_COLLECTION_DB
+    if table in QUALITATIVE_SELL_BROWSABLE_TABLES:
+        return QUALITATIVE_SELL_DB
+    return None
+
+
+def list_browsable_tables(workspace_db_path: Path) -> list[dict[str, Any]]:
+    tables: list[dict[str, Any]] = []
+    for table in (
+        *WORKSPACE_BROWSABLE_TABLES,
+        *COLLECTION_BROWSABLE_TABLES,
+        *QUALITATIVE_SELL_BROWSABLE_TABLES,
+    ):
+        db_path = _resolve_table_db(table, workspace_db_path)
+        exists = bool(db_path and db_path.exists())
+        row_count = 0
+        if exists:
+            try:
+                with sqlite3.connect(db_path) as conn:
+                    row_count = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]  # noqa: S608 - table is whitelist-checked above
+            except sqlite3.OperationalError:
+                exists = False
+        tables.append({"table": table, "db": str(db_path) if db_path else "", "exists": exists, "row_count": row_count})
+    return tables
+
+
+def fetch_table_rows(table: str, workspace_db_path: Path, *, limit: int = 50, offset: int = 0) -> dict[str, Any]:
+    db_path = _resolve_table_db(table, workspace_db_path)
+    if db_path is None:
+        raise ValueError(f"unknown or non-browsable table: {table}")
+    if not db_path.exists():
+        return {"table": table, "db": str(db_path), "columns": [], "rows": [], "total": 0, "limit": limit, "offset": offset}
+    with sqlite3.connect(db_path) as conn:
+        conn.row_factory = sqlite3.Row
+        total = conn.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]  # noqa: S608 - whitelisted table name
+        cursor = conn.execute(
+            f"SELECT * FROM {table} ORDER BY rowid DESC LIMIT ? OFFSET ?",  # noqa: S608 - whitelisted table name
+            (limit, offset),
+        )
+        rows = [dict(row) for row in cursor.fetchall()]
+        columns = [description[0] for description in cursor.description] if cursor.description else []
+    return {"table": table, "db": str(db_path), "columns": columns, "rows": rows, "total": total, "limit": limit, "offset": offset}
+SNAPSHOT_ADMIN_VERSION_FILES = (
+    ROOT / "src" / "quant_engine" / "snapshot_admin_server_v1.py",
+    ROOT / "src" / "quant_engine" / "snapshot_admin_store_v1.py",
+    ROOT / "src" / "quant_engine" / "data_collection_store_v1.py",
+    ROOT / "tools" / "run_snapshot_admin_server_v1.py",
+    ROOT / "tools" / "validate_snapshot_admin_web_v1.py",
+    ROOT / "tests" / "unit" / "test_snapshot_admin_web_v1.py",
+    ROOT / "package.json",
+)
+
+from .snapshot_admin_store_v1 import (
+    ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS,
+    DEFAULT_DB,
+    DEFAULT_SEED_JSON,
+    export_payload,
+    clear_lock,
+    import_seed_json,
+    is_locked,
+    load_account_snapshot_rows,
+    load_approval_for_domain,
+    load_approval_rows,
+    load_change_log_rows,
+    load_locks,
+    load_settings_rows,
+    normalize_db_path,
+    now_kst_iso,
+    open_connection,
+    parse_account_snapshot_tsv,
+    parse_scalar,
+    record_change_log,
+    validate_account_snapshot_rows,
+    validate_settings_rows,
+    build_validation_suggestions,
+    build_safe_autofix_actions,
+    apply_safe_autofix_action,
+    lock_conflicts_for_rows,
+    set_approval,
+    set_lock,
+    replace_account_snapshot,
+    replace_settings,
+    undo_last_change,
+    summarize_workspace,
+)
+from .data_collection_store_v1 import load_collection_dashboard_state
+
+
+def _strip_internal_fields(row: dict[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in row.items() if not key.startswith("_")}
+
+
+def _snapshot_columns_from_rows(rows: list[dict[str, Any]]) -> list[str]:
+    columns = list(ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS)
+    extras = sorted(
+        {
+            key
+            for row in rows
+            for key in row.keys()
+            if not key.startswith("_") and key not in ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS
+        }
+    )
+    for key in extras:
+        if key not in columns:
+            columns.append(key)
+    return columns
+
+
+def _write_json(path: Path, payload: dict[str, Any]) -> Path:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    return path
+
+
+def _render_approval_packet_md(packet: dict[str, Any]) -> str:
+    pending = packet.get("pending_targets") if isinstance(packet.get("pending_targets"), list) else []
+    summary = packet.get("summary") if isinstance(packet.get("summary"), dict) else {}
+    lines = [
+        "# Snapshot Admin Approval Packet",
+        "",
+        "## Summary",
+        "",
+        f"- settings_changed: {summary.get('settings_changed', 0)}",
+        f"- account_snapshot_changed: {summary.get('account_snapshot_changed', 0)}",
+        f"- pending_target_count: {summary.get('pending_target_count', 0)}",
+        "",
+        "## Pending Targets",
+        "",
+    ]
+    if pending:
+        for item in pending[:100]:
+            if not isinstance(item, dict):
+                continue
+            lines.append(f"- {item.get('domain', '')}:{item.get('target_ref', '')} ({item.get('change_type', '')})")
+    else:
+        lines.append("_none_")
+    return "\n".join(lines)
+
+
+def write_approval_packet_artifacts(packet: dict[str, Any]) -> dict[str, str]:
+    json_path = ROOT / "Temp" / "snapshot_admin_approval_packet_v1.json"
+    md_path = ROOT / "Temp" / "snapshot_admin_approval_packet_v1.md"
+    _write_json(json_path, packet)
+    md_path.parent.mkdir(parents=True, exist_ok=True)
+    md_path.write_text(_render_approval_packet_md(packet), encoding="utf-8")
+    return {"json_path": str(json_path), "md_path": str(md_path)}
+
+
+def _git_info() -> dict[str, Any]:
+    try:
+        commit = subprocess.check_output(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=str(ROOT),
+            text=True,
+            stderr=subprocess.DEVNULL,
+        ).strip()
+        status = subprocess.check_output(
+            ["git", "status", "--porcelain"],
+            cwd=str(ROOT),
+            text=True,
+            stderr=subprocess.DEVNULL,
+        )
+        return {
+            "commit": commit,
+            "dirty": bool(status.strip()),
+            "tree_state": "DIRTY" if status.strip() else "CLEAN",
+        }
+    except Exception:
+        return {
+            "commit": "",
+            "dirty": False,
+            "tree_state": "UNKNOWN",
+        }
+
+
+def _source_fingerprint() -> dict[str, Any]:
+    digest = sha256()
+    latest_mtime = 0.0
+    for path in SNAPSHOT_ADMIN_VERSION_FILES:
+        if not path.exists():
+            continue
+        try:
+            data = path.read_bytes()
+            digest.update(path.as_posix().encode("utf-8"))
+            digest.update(b"\0")
+            digest.update(data)
+            latest_mtime = max(latest_mtime, path.stat().st_mtime)
+        except OSError:
+            continue
+    return {
+        "fingerprint": digest.hexdigest()[:16],
+        "latest_mtime": latest_mtime,
+    }
+
+
+def _approval_entry_from_conn(conn, domain: str, target_ref: str = "*") -> dict[str, Any] | None:
+    ensure_schema(conn)
+    row = conn.execute(
+        f"""
+        SELECT domain, target_ref, status, approved_by, approved_at, note, updated_at
+        FROM {APPROVAL_TABLE}
+        WHERE domain = ? AND target_ref = ?
+        LIMIT 1
+        """,
+        (domain, target_ref or "*"),
+    ).fetchone()
+    return dict(row) if row is not None else None
+
+
+def _lock_entry_from_conn(conn, domain: str, target_ref: str = "*") -> dict[str, Any] | None:
+    ensure_schema(conn)
+    row = conn.execute(
+        f"""
+        SELECT domain, target_ref, locked_by, reason, locked_at
+        FROM {LOCK_TABLE}
+        WHERE domain = ? AND target_ref = ?
+        LIMIT 1
+        """,
+        (domain, target_ref or "*"),
+    ).fetchone()
+    return dict(row) if row is not None else None
+
+
+def build_ui_state(db_path: Path | str | None = None) -> dict[str, Any]:
+    summary = summarize_workspace(db_path)
+    settings_rows = load_settings_rows(db_path)
+    account_rows = [_strip_internal_fields(row) for row in load_account_snapshot_rows(db_path)]
+    settings_errors = validate_settings_rows(settings_rows)
+    snapshot_errors = validate_account_snapshot_rows(account_rows)
+    suggestions = build_validation_suggestions(settings_rows, account_rows)
+    autofix_actions = build_safe_autofix_actions(settings_rows, account_rows)
+    collection = load_collection_dashboard_state(KIS_COLLECTION_DB, KIS_COLLECTION_REPORT)
+    return {
+        "version": {
+            "app": SNAPSHOT_ADMIN_VERSION,
+            "git": _git_info(),
+            "source": _source_fingerprint(),
+        },
+        "summary": summary,
+        "approval_rows": load_approval_rows(db_path),
+        "approval_settings": load_approval_for_domain(db_path, "settings"),
+        "approval_account_snapshot": load_approval_for_domain(db_path, "account_snapshot"),
+        "locks": load_locks(db_path),
+        "recent_changes": load_change_log_rows(db_path, limit=12),
+        "history_counts": {
+            "changes": len(load_change_log_rows(db_path, limit=200)),
+            "approvals": len(load_approval_rows(db_path)),
+            "locks": len(load_locks(db_path)),
+        },
+        "settings_rows": settings_rows,
+        "account_snapshot_rows": account_rows,
+        "account_snapshot_columns": _snapshot_columns_from_rows(account_rows),
+        "validation": {
+            "settings": settings_errors,
+            "account_snapshot": snapshot_errors,
+            "suggestions": suggestions,
+        },
+        "autofix_actions": autofix_actions,
+        "collection": collection,
+        "generated_at": now_kst_iso(),
+    }
+
+
+def _json_response(handler: BaseHTTPRequestHandler, status: int, payload: Any) -> None:
+    body = json.dumps(payload, ensure_ascii=False, indent=2).encode("utf-8")
+    handler.send_response(status)
+    handler.send_header("Content-Type", "application/json; charset=utf-8")
+    handler.send_header("Content-Length", str(len(body)))
+    handler.end_headers()
+    handler.wfile.write(body)
+
+
+def _text_response(handler: BaseHTTPRequestHandler, status: int, text: str, content_type: str = "text/plain; charset=utf-8") -> None:
+    body = text.encode("utf-8")
+    handler.send_response(status)
+    handler.send_header("Content-Type", content_type)
+    handler.send_header("Content-Length", str(len(body)))
+    handler.end_headers()
+    handler.wfile.write(body)
+
+
+def _read_json_body(handler: BaseHTTPRequestHandler) -> dict[str, Any]:
+    length = int(handler.headers.get("Content-Length") or "0")
+    raw = handler.rfile.read(length).decode("utf-8") if length else "{}"
+    payload = json.loads(raw or "{}")
+    if not isinstance(payload, dict):
+        raise ValueError("JSON body must be an object")
+    return payload
+
+
+def render_index_html() -> str:
+    return """<!doctype html>
+<html lang="ko">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Snapshot Admin</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --bg: #0f172a;
+      --panel: #111827;
+      --panel-2: #0b1220;
+      --line: #243047;
+      --text: #e5e7eb;
+      --muted: #9ca3af;
+      --accent: #38bdf8;
+      --accent-2: #22c55e;
+      --danger: #fb7185;
+      --warn: #f59e0b;
+      --chip: #172036;
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      font-family: ui-sans-serif, system-ui, -apple-system, Segoe UI, Roboto, "Noto Sans KR", sans-serif;
+      background:
+        radial-gradient(circle at top left, rgba(56,189,248,.10), transparent 28%),
+        radial-gradient(circle at top right, rgba(34,197,94,.08), transparent 20%),
+        linear-gradient(180deg, #08101f 0%, #0b1220 100%);
+      color: var(--text);
+    }
+    header {
+      padding: 24px 24px 14px;
+      border-bottom: 1px solid rgba(255,255,255,.06);
+      background: rgba(5, 10, 20, .5);
+      position: sticky;
+      top: 0;
+      backdrop-filter: blur(10px);
+      z-index: 10;
+    }
+    h1 { margin: 0; font-size: 22px; letter-spacing: .01em; }
+    .subline { color: var(--muted); margin-top: 6px; font-size: 13px; }
+    .wrap { padding: 20px 24px 40px; max-width: 1600px; margin: 0 auto; }
+    .grid {
+      display: grid;
+      grid-template-columns: 1fr;
+      gap: 18px;
+    }
+    .panel {
+      border: 1px solid rgba(255,255,255,.08);
+      background: linear-gradient(180deg, rgba(17,24,39,.94), rgba(10,16,28,.95));
+      border-radius: 18px;
+      box-shadow: 0 16px 48px rgba(0,0,0,.24);
+      overflow: hidden;
+    }
+    .panel-head {
+      display: flex;
+      flex-wrap: wrap;
+      align-items: center;
+      justify-content: space-between;
+      gap: 12px;
+      padding: 16px 16px 10px;
+      border-bottom: 1px solid rgba(255,255,255,.06);
+    }
+    .panel-head h2 { margin: 0; font-size: 16px; }
+    .actions { display: flex; flex-wrap: wrap; gap: 8px; }
+    button, .btn {
+      border: 1px solid rgba(255,255,255,.12);
+      background: var(--chip);
+      color: var(--text);
+      padding: 8px 12px;
+      border-radius: 10px;
+      cursor: pointer;
+      font-size: 13px;
+    }
+    button.primary { background: linear-gradient(135deg, var(--accent), #0ea5e9); color: #fff; }
+    button.good { background: linear-gradient(135deg, var(--accent-2), #16a34a); color: #fff; }
+    button.danger { background: linear-gradient(135deg, #f87171, #fb7185); color: #fff; }
+    button:hover { filter: brightness(1.06); }
+    .status {
+      padding: 10px 16px;
+      color: var(--muted);
+      border-bottom: 1px solid rgba(255,255,255,.06);
+      font-size: 13px;
+      display: flex;
+      flex-wrap: wrap;
+      gap: 10px;
+    }
+    .version {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 8px;
+      font-size: 12px;
+      color: var(--muted);
+    }
+    .status strong { color: var(--text); }
+    .filter-row {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin: 10px 0 0;
+    }
+    .filter-row input {
+      background: rgba(3, 7, 18, .45);
+      color: var(--text);
+      border: 1px solid rgba(255,255,255,.10);
+      border-radius: 10px;
+      padding: 8px 10px;
+      font-size: 12px;
+      min-width: 180px;
+    }
+    .tiny {
+      font-size: 11px;
+      color: var(--muted);
+    }
+    .pane-body { padding: 14px 16px 18px; }
+    .grid-wrap {
+      overflow: auto;
+      border: 1px solid rgba(255,255,255,.08);
+      border-radius: 14px;
+      background: rgba(3, 7, 18, .45);
+    }
+    table.sheet {
+      width: 100%;
+      border-collapse: collapse;
+      min-width: 100%;
+    }
+    .sheet th, .sheet td {
+      border-bottom: 1px solid rgba(255,255,255,.06);
+      border-right: 1px solid rgba(255,255,255,.04);
+      padding: 0;
+      vertical-align: top;
+      font-size: 12px;
+    }
+    .sheet th {
+      position: sticky;
+      top: 0;
+      background: rgba(15, 23, 42, .98);
+      text-align: left;
+      padding: 10px 8px;
+      color: #cbd5e1;
+      white-space: nowrap;
+      z-index: 2;
+    }
+    .sheet td[contenteditable="true"] {
+      min-width: 120px;
+      padding: 8px 8px;
+      outline: none;
+      white-space: pre-wrap;
+      word-break: break-word;
+    }
+    .sheet td[contenteditable="true"]:focus {
+      background: rgba(56,189,248,.12);
+      box-shadow: inset 0 0 0 1px rgba(56,189,248,.35);
+    }
+    .sheet td.rownum, .sheet th.rownum {
+      min-width: 54px;
+      width: 54px;
+      text-align: right;
+      color: var(--muted);
+      padding-right: 10px;
+      background: rgba(15, 23, 42, .85);
+      position: sticky;
+      left: 0;
+      z-index: 1;
+    }
+    .sheet th.rownum { z-index: 3; }
+    .note-box {
+      margin-top: 12px;
+      display: grid;
+      gap: 10px;
+      grid-template-columns: 1fr;
+    }
+    textarea {
+      width: 100%;
+      min-height: 120px;
+      resize: vertical;
+      background: rgba(3, 7, 18, .45);
+      color: var(--text);
+      border: 1px solid rgba(255,255,255,.10);
+      border-radius: 12px;
+      padding: 10px 12px;
+      font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+      font-size: 12px;
+    }
+    .muted { color: var(--muted); }
+    .warn { color: var(--warn); }
+    .error { color: var(--danger); }
+    .tiny {
+      font-size: 11px;
+      color: var(--muted);
+    }
+    .chip {
+      display: inline-flex;
+      gap: 6px;
+      align-items: center;
+      padding: 4px 8px;
+      border-radius: 999px;
+      background: rgba(255,255,255,.06);
+      color: var(--muted);
+      font-size: 12px;
+    }
+    .toolbar {
+      display: flex;
+      gap: 10px;
+      flex-wrap: wrap;
+      align-items: center;
+    }
+    .two-col {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 18px;
+    }
+    .row-actions {
+      display: flex;
+      gap: 6px;
+      flex-wrap: wrap;
+    }
+    .sheet tr.selected td {
+      background: rgba(56, 189, 248, .10);
+    }
+    .sheet tr.selected td.rownum {
+      background: rgba(56, 189, 248, .18);
+      color: #e0f2fe;
+    }
+    .diff-list {
+      display: grid;
+      gap: 8px;
+      margin-top: 8px;
+    }
+    .diff-item {
+      padding: 10px;
+      border: 1px solid rgba(255,255,255,.08);
+      border-radius: 12px;
+      background: rgba(3, 7, 18, .42);
+      font-size: 12px;
+    }
+    .diff-item strong { color: var(--text); }
+    .diff-item code {
+      display: block;
+      white-space: pre-wrap;
+      margin-top: 6px;
+      color: #cbd5e1;
+    }
+    .history-list {
+      display: grid;
+      gap: 8px;
+      margin-top: 10px;
+      max-height: 260px;
+      overflow: auto;
+    }
+    .history-item {
+      border: 1px solid rgba(255,255,255,.08);
+      border-radius: 12px;
+      background: rgba(3, 7, 18, .42);
+      padding: 10px;
+      font-size: 12px;
+    }
+    .history-item code {
+      display: block;
+      margin-top: 6px;
+      white-space: pre-wrap;
+      color: #cbd5e1;
+    }
+    .inspector {
+      display: grid;
+      gap: 10px;
+    }
+    .inspector-grid {
+      display: grid;
+      grid-template-columns: 1.1fr .9fr;
+      gap: 12px;
+    }
+    .inspector-pre {
+      margin: 0;
+      white-space: pre-wrap;
+      max-height: 280px;
+      overflow: auto;
+      background: rgba(3,7,18,.45);
+      border: 1px solid rgba(255,255,255,.08);
+      border-radius: 12px;
+      padding: 10px;
+    }
+    .view-controls {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 8px;
+      align-items: center;
+    }
+    .view-controls select, .view-controls input {
+      background: rgba(3, 7, 18, .45);
+      color: var(--text);
+      border: 1px solid rgba(255,255,255,.10);
+      border-radius: 10px;
+      padding: 8px 10px;
+      font-size: 12px;
+      min-width: 120px;
+    }
+    .collection-grid {
+      display: grid;
+      grid-template-columns: 1.1fr .9fr;
+      gap: 12px;
+    }
+    .collection-panel {
+      display: grid;
+      gap: 10px;
+    }
+    .collection-filter-row {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 8px;
+      align-items: center;
+    }
+    .collection-filter-row input {
+      background: rgba(3, 7, 18, .45);
+      color: var(--text);
+      border: 1px solid rgba(255,255,255,.10);
+      border-radius: 10px;
+      padding: 8px 10px;
+      font-size: 12px;
+      min-width: 180px;
+    }
+    .collection-list {
+      display: grid;
+      gap: 8px;
+      margin-top: 8px;
+    }
+    .collection-item {
+      width: 100%;
+      text-align: left;
+      border: 1px solid rgba(255,255,255,.08);
+      border-radius: 12px;
+      padding: 10px;
+      background: rgba(3, 7, 18, .42);
+      color: var(--text);
+      font-size: 12px;
+      cursor: pointer;
+    }
+    .collection-item.selected {
+      border-color: rgba(96, 165, 250, .8);
+      box-shadow: 0 0 0 1px rgba(96, 165, 250, .35) inset;
+    }
+    .collection-item code {
+      display: block;
+      margin-top: 6px;
+      white-space: pre-wrap;
+      color: #cbd5e1;
+    }
+    .collection-metrics {
+      display: grid;
+      grid-template-columns: repeat(3, minmax(0, 1fr));
+      gap: 8px;
+      margin-top: 10px;
+    }
+    .metric-card {
+      border: 1px solid rgba(255,255,255,.08);
+      border-radius: 12px;
+      padding: 10px;
+      background: rgba(3, 7, 18, .42);
+      font-size: 12px;
+    }
+    .metric-card strong {
+      display: block;
+      font-size: 16px;
+      margin-top: 4px;
+      color: var(--text);
+    }
+    .compact-log {
+      margin: 0;
+      white-space: pre-wrap;
+      max-height: 220px;
+      overflow: auto;
+      background: rgba(3,7,18,.45);
+      border: 1px solid rgba(255,255,255,.08);
+      border-radius: 12px;
+      padding: 10px;
+      font-size: 12px;
+    }
+    .shortcut-hint {
+      color: var(--muted);
+      font-size: 11px;
+      margin-top: 8px;
+    }
+    .log-filter-row {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+      margin-top: 8px;
+      align-items: center;
+    }
+    .log-filter-row input {
+      background: rgba(3, 7, 18, .45);
+      color: var(--text);
+      border: 1px solid rgba(255,255,255,.10);
+      border-radius: 10px;
+      padding: 8px 10px;
+      font-size: 12px;
+      min-width: 220px;
+    }
+    @media (max-width: 1080px) {
+      .two-col { grid-template-columns: 1fr; }
+      .inspector-grid { grid-template-columns: 1fr; }
+      .collection-grid { grid-template-columns: 1fr; }
+      .collection-metrics { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>Snapshot Admin</h1>
+    <div class="subline">SQLite canonical editor for <code>settings</code> and <code>account_snapshot</code>. Save via API only; xlsx stays as export surface.</div>
+    <div class="toolbar" style="margin-top:10px;">
+      <a class="btn" href="/collection">Open collection dashboard</a>
+      <a class="btn" href="/tables">Open table browser</a>
+    </div>
+    <div class="version" id="versionSummary"></div>
+  </header>
+  <main class="wrap">
+    <div class="grid">
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Workspace</h2>
+          <div class="actions">
+            <button class="primary" onclick="reloadState()">Reload</button>
+            <button class="good" onclick="seedWorkspace()">Seed from GatherTradingData.json</button>
+            <button onclick="downloadExport()">Download JSON</button>
+            <button class="danger" onclick="undoLastChange('settings')">Undo settings</button>
+            <button class="danger" onclick="undoLastChange('account_snapshot')">Undo snapshot</button>
+            <button class="good" onclick="runAutofix()">Apply safe autofix</button>
+          </div>
+        </div>
+        <div class="status" id="workspaceStatus">Loading...</div>
+        <div class="pane-body">
+          <div class="two-col">
+            <div>
+              <div class="tiny">Validation</div>
+              <pre id="validationBox" style="margin:8px 0 0; white-space:pre-wrap; max-height:180px; overflow:auto; background:rgba(3,7,18,.45); border:1px solid rgba(255,255,255,.08); border-radius:12px; padding:10px;"></pre>
+              <div class="tiny" style="margin-top:10px;">Suggestions</div>
+              <pre id="suggestionBox" style="margin:8px 0 0; white-space:pre-wrap; max-height:180px; overflow:auto; background:rgba(3,7,18,.45); border:1px solid rgba(255,255,255,.08); border-radius:12px; padding:10px;"></pre>
+            </div>
+            <div>
+              <div class="tiny">Diff preview</div>
+              <pre id="diffPreview" style="margin:8px 0 0; white-space:pre-wrap; max-height:180px; overflow:auto; background:rgba(3,7,18,.45); border:1px solid rgba(255,255,255,.08); border-radius:12px; padding:10px;"></pre>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Approval & Locks</h2>
+          <div class="actions">
+            <button onclick="lockDomain('settings')">Lock settings</button>
+            <button onclick="unlockDomain('settings')">Unlock settings</button>
+            <button onclick="lockDomain('account_snapshot')">Lock snapshot</button>
+            <button onclick="unlockDomain('account_snapshot')">Unlock snapshot</button>
+            <button class="good" onclick="approveDomain('settings')">Approve settings</button>
+            <button class="good" onclick="approveDomain('account_snapshot')">Approve snapshot</button>
+          </div>
+        </div>
+        <div class="pane-body">
+          <div class="two-col">
+            <div>
+              <div class="chip" id="approvalSettingsChip">settings approval</div>
+              <div class="chip" id="approvalSnapshotChip">snapshot approval</div>
+              <div class="muted" id="lockSummary" style="margin-top:10px;"></div>
+              <div class="muted" id="approvalRowSummary" style="margin-top:8px;"></div>
+              <div class="muted" id="historySummary" style="margin-top:8px;"></div>
+              <div class="toolbar" style="margin-top:12px;">
+                <input id="lockDomainInput" value="settings" aria-label="lock domain" />
+                <input id="lockTargetInput" placeholder="target_ref (key or ticker)" aria-label="lock target" />
+                <button onclick="lockTargetFromInput()">Lock target</button>
+                <button onclick="unlockTargetFromInput()">Unlock target</button>
+                <button class="good" onclick="approvePendingChanges()">Approve pending</button>
+                <button onclick="previewDiff()">Refresh diff</button>
+                <button class="primary" onclick="exportApprovalPacket()">Export approval packet</button>
+              </div>
+            </div>
+            <div>
+              <div class="muted">Recent change log</div>
+              <div class="log-filter-row">
+                <input id="changeLogFilter" placeholder="Filter change log" oninput="renderMeta()" />
+                <button onclick="clearChangeLogFilter()">Clear filter</button>
+              </div>
+              <pre id="changeLog" style="margin:10px 0 0; white-space:pre-wrap; max-height:240px; overflow:auto; background:rgba(3,7,18,.45); border:1px solid rgba(255,255,255,.08); border-radius:12px; padding:10px;"></pre>
+              <div class="muted" style="margin-top:10px;">Timeline</div>
+              <div id="changeTimeline" class="history-list"></div>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>KIS Collection</h2>
+          <div class="actions">
+            <button class="primary" onclick="reloadState()">Refresh collection</button>
+            <button onclick="copyCollectionStatus()">Copy status</button>
+          </div>
+        </div>
+        <div class="pane-body collection-panel">
+          <div class="collection-grid">
+            <div>
+              <div class="chip" id="collectionChip">collection: loading...</div>
+              <div class="muted" id="collectionSummary" style="margin-top:10px;"></div>
+              <div class="collection-metrics" id="collectionMetrics"></div>
+              <div class="collection-filter-row">
+                <input id="collectionFilter" placeholder="Filter runs / snapshots / errors" oninput="applyCollectionFilter()" />
+                <button onclick="clearCollectionFilter()">Clear filter</button>
+              </div>
+            </div>
+            <div>
+              <div class="muted">Recent collector runs</div>
+              <div id="collectionRuns" class="collection-list"></div>
+              <div class="muted" style="margin-top:10px;">Recent collector snapshots</div>
+              <div id="collectionSnapshots" class="collection-list"></div>
+              <div class="muted" style="margin-top:10px;">Recent collector errors</div>
+              <div id="collectionErrors" class="collection-list"></div>
+              <div class="muted" style="margin-top:10px;">Collection detail</div>
+              <pre id="collectionDetail" class="inspector-pre"></pre>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Selection Inspector</h2>
+          <div class="actions">
+            <button onclick="focusSelectedRow()">Focus row</button>
+            <button onclick="copySelectedTarget()">Copy target</button>
+            <button class="good" onclick="approveSelectedRow()">Approve selected</button>
+            <button onclick="lockSelectedRow()">Lock selected</button>
+            <button onclick="unlockSelectedRow()">Unlock selected</button>
+          </div>
+        </div>
+        <div class="pane-body inspector">
+          <div class="inspector-grid">
+            <div>
+              <div class="muted" id="selectedRowSummary">No row selected.</div>
+              <pre id="selectedRowDetail" class="inspector-pre"></pre>
+              <div class="tiny" style="margin-top:10px;">Recent row history</div>
+              <pre id="selectedRowHistory" class="inspector-pre"></pre>
+            </div>
+            <div>
+              <div class="muted">Batch paste</div>
+              <div class="view-controls">
+                <select id="batchDomainSelect" onchange="syncBatchDomain()">
+                  <option value="settings">settings</option>
+                  <option value="account_snapshot">account_snapshot</option>
+                </select>
+                <button onclick="applyBatchPaste()">Apply TSV to selection</button>
+              </div>
+              <textarea id="batchPasteTsv" placeholder="Paste TSV here to apply from selected row onward."></textarea>
+              <div class="tiny">Tip: clipboard paste still works directly in the grid. This panel is for multi-row batch edit against the selected row.</div>
+              <div class="shortcut-hint">Shortcuts: `Ctrl+S` save current domain, `Ctrl+Enter` save current domain, `Delete` remove selected row.</div>
+            </div>
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Settings</h2>
+          <div class="actions">
+            <button onclick="addSettingRow()">Add row</button>
+            <button class="primary" onclick="saveSettings()">Save settings</button>
+          </div>
+        </div>
+        <div class="pane-body">
+          <div class="view-controls">
+            <input id="settingsSortField" placeholder="sort field" list="settingsSortFields" oninput="applyViewPreferences('settings')" />
+            <select id="settingsSortDirection" onchange="applyViewPreferences('settings')">
+              <option value="asc">asc</option>
+              <option value="desc">desc</option>
+            </select>
+            <button onclick="saveViewPreset('settings')">Save view</button>
+            <select id="settingsViewPreset" onchange="loadViewPreset('settings')"></select>
+            <button onclick="clearViewPreset('settings')">Delete view</button>
+          </div>
+          <datalist id="settingsSortFields">
+            <option value="ordinal"></option>
+            <option value="key"></option>
+            <option value="value"></option>
+            <option value="note"></option>
+            <option value="updated_at"></option>
+          </datalist>
+          <div class="grid-wrap" id="settingsWrap"></div>
+          <div class="filter-row">
+            <input id="settingsFilter" placeholder="Filter settings key / note" oninput="applyFilters()" />
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-head">
+          <h2>Account Snapshot</h2>
+          <div class="actions">
+            <button onclick="addSnapshotRow()">Add row</button>
+            <button class="primary" onclick="saveSnapshot()">Save snapshot</button>
+          </div>
+        </div>
+        <div class="status">
+          <span class="chip">Paste TSV below and replace all rows</span>
+          <span class="chip">Canonical column order follows spec/15_account_snapshot_contract.yaml</span>
+        </div>
+        <div class="pane-body">
+          <div class="view-controls">
+            <input id="snapshotSortField" placeholder="sort field" list="snapshotSortFields" oninput="applyViewPreferences('account_snapshot')" />
+            <select id="snapshotSortDirection" onchange="applyViewPreferences('account_snapshot')">
+              <option value="asc">asc</option>
+              <option value="desc">desc</option>
+            </select>
+            <button onclick="saveViewPreset('account_snapshot')">Save view</button>
+            <select id="snapshotViewPreset" onchange="loadViewPreset('account_snapshot')"></select>
+            <button onclick="clearViewPreset('account_snapshot')">Delete view</button>
+          </div>
+          <datalist id="snapshotSortFields">
+            <option value="ordinal"></option>
+            <option value="ticker"></option>
+            <option value="name"></option>
+            <option value="account"></option>
+            <option value="account_type"></option>
+            <option value="parse_status"></option>
+            <option value="position_type"></option>
+            <option value="updated_at"></option>
+            <option value="market_value"></option>
+          </datalist>
+          <div class="filter-row">
+            <input id="snapshotFilter" placeholder="Filter ticker / name / account" oninput="applyFilters()" />
+          </div>
+          <div class="grid-wrap" id="snapshotWrap"></div>
+          <div class="note-box">
+            <textarea id="snapshotTsv" placeholder="Paste TSV rows here (headerless or with header)."></textarea>
+            <div class="toolbar">
+              <button class="good" onclick="importSnapshotTsv()">Import TSV (replace)</button>
+              <button onclick="fillSnapshotTemplate()">Insert blank template</button>
+            </div>
+          </div>
+        </div>
+      </section>
+    </div>
+  </main>
+
+  <script>
+    const state = {
+      settingsRows: [],
+      snapshotRows: [],
+      initialSettingsRows: [],
+      initialSnapshotRows: [],
+      snapshotColumns: [],
+      summary: {},
+      approvalRows: [],
+      approvalSettings: {},
+      approvalSnapshot: {},
+      locks: [],
+      recentChanges: [],
+      validation: { settings: [], account_snapshot: [] },
+      suggestions: [],
+      autofixActions: [],
+      filterSettings: "",
+      filterSnapshot: "",
+      filterCollection: "",
+      filterChangeLog: "",
+      selected: { domain: "", target_ref: "" },
+      viewPresets: { settings: [], account_snapshot: [] },
+      viewPrefs: {
+        settings: { sortField: "ordinal", sortDirection: "asc" },
+        account_snapshot: { sortField: "ordinal", sortDirection: "asc" },
+      },
+      collection: {},
+      collectionSelection: { kind: "", key: "" },
+    };
+
+    const VIEW_STORAGE_KEY = "snapshot_admin_view_presets_v1";
+    const PREF_STORAGE_KEY = "snapshot_admin_view_prefs_v1";
+
+    const settingsColumns = ["ordinal", "key", "value", "note", "updated_at"];
+
+    function esc(value) {
+      return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+    }
+
+    function cellValue(row, column) {
+      const value = row[column];
+      if (value === undefined || value === null) return "";
+      if (typeof value === "object") return JSON.stringify(value, null, 2);
+      return String(value);
+    }
+
+    function collectTable(tableId, columns) {
+      const table = document.getElementById(tableId);
+      const rows = [];
+      const bodyRows = table.querySelectorAll("tbody tr[data-row-index]");
+      bodyRows.forEach((tr, index) => {
+        const row = { ordinal: index + 1, _row_ref: tr.dataset.rowRef || "" };
+        columns.forEach((col, colIndex) => {
+          const cell = tr.querySelector(`td[data-col-index="${colIndex}"]`);
+          row[col] = cell ? cell.innerText.trim() : "";
+        });
+        rows.push(row);
+      });
+      return rows;
+    }
+
+    function currentSettingsRows() {
+      try {
+        return collectTable("settingsTable", ["key", "value", "note"]).map((row, index) => ({
+          ordinal: index + 1,
+          _row_ref: row._row_ref || "",
+          key: row.key,
+          value: parseCellValue(row.value),
+          note: row.note,
+        }));
+      } catch (err) {
+        return state.settingsRows || [];
+      }
+    }
+
+    function currentSnapshotRows() {
+      try {
+        return collectTable("snapshotTable", state.snapshotColumns).map((row, index) => {
+          const normalized = { ordinal: index + 1, _row_ref: row._row_ref || "" };
+          state.snapshotColumns.forEach((column) => {
+            normalized[column] = parseCellValue(row[column]);
+          });
+          return normalized;
+        });
+      } catch (err) {
+        return state.snapshotRows || [];
+      }
+    }
+
+    function cloneRows(rows) {
+      return JSON.parse(JSON.stringify(rows || []));
+    }
+
+    function loadJsonStorage(key, fallback) {
+      try {
+        const text = localStorage.getItem(key);
+        if (!text) return fallback;
+        const parsed = JSON.parse(text);
+        return parsed && typeof parsed === "object" ? parsed : fallback;
+      } catch (err) {
+        return fallback;
+      }
+    }
+
+    function saveJsonStorage(key, value) {
+      try {
+        localStorage.setItem(key, JSON.stringify(value));
+      } catch (err) {
+        return;
+      }
+    }
+
+    function rowKey(domain, row) {
+      if (domain === "settings") return String(row?._row_ref || row?.key || "").trim();
+      if (domain === "account_snapshot") return snapshotTargetRef(row);
+      return String(row?.target_ref || "").trim();
+    }
+
+    function snapshotTargetRef(row) {
+      const ref = String(row?._row_ref || "").trim();
+      if (ref) return ref;
+      const ordinal = String(row?._ordinal ?? row?.ordinal ?? "").trim();
+      if (ordinal) return `row:${ordinal}`;
+      const ticker = String(row?.ticker || "").trim();
+      if (ticker) return `ticker:${ticker}`;
+      return "row:unknown";
+    }
+
+    function settingsTargetRef(row) {
+      return String(row?._row_ref || row?.key || "").trim();
+    }
+
+    function rowDisplayLabel(domain, row) {
+      if (domain === "settings") {
+        return String(row?.key || "").trim() || "settings-row";
+      }
+      if (domain === "account_snapshot") {
+        const ticker = String(row?.ticker || "").trim();
+        const name = String(row?.name || "").trim();
+        const ordinal = String(row?._ordinal ?? row?.ordinal ?? "").trim();
+        return [ticker, name, ordinal ? `#${ordinal}` : ""].filter(Boolean).join(" ");
+      }
+      return rowKey(domain, row);
+    }
+
+    function collectionItemKey(kind, item, index) {
+      if (kind === "run") {
+        return String(item?.run_id || item?.started_at || index || "").trim();
+      }
+      if (kind === "snapshot") {
+        return [item?.run_id, item?.dataset_name, item?.ticker, item?.created_at, index].map((value) => String(value || "").trim()).join("|");
+      }
+      if (kind === "error") {
+        return [item?.run_id, item?.source_name, item?.ticker, item?.error_kind, item?.created_at, index].map((value) => String(value || "").trim()).join("|");
+      }
+      return String(item?.id || index || "").trim();
+    }
+
+    function collectionItemLabel(kind, item) {
+      if (kind === "run") {
+        const finished = item?.finished_at || "RUNNING";
+        return `${item?.started_at || ""} ${item?.status || ""} ${item?.collector_name || "collector"} ${item?.run_id || ""} -> ${finished}`.trim();
+      }
+      if (kind === "snapshot") {
+        return `${item?.created_at || ""} ${item?.dataset_name || ""}:${item?.ticker || ""} ${item?.source_status || ""}`.trim();
+      }
+      if (kind === "error") {
+        return `${item?.created_at || ""} ${item?.source_name || ""}:${item?.error_kind || ""} ${item?.ticker || ""} ${item?.error_message || ""}`.trim();
+      }
+      return JSON.stringify(item, null, 2);
+    }
+
+    function collectionItemDetail(kind, item) {
+      const base = item && typeof item === "object" ? item : {};
+      return JSON.stringify({ kind, ...base }, null, 2);
+    }
+
+    function selectCollectionItem(kind, key) {
+      state.collectionSelection = { kind, key };
+      renderCollectionState();
+    }
+
+    function currentCollectionSelectionKey(kind, item, index) {
+      return collectionItemKey(kind, item, index);
+    }
+
+    function selectedRowRef(domain) {
+      return state.selected.domain === domain ? String(state.selected.target_ref || "").trim() : "";
+    }
+
+    function selectRow(domain, row) {
+      state.selected = { domain, target_ref: rowKey(domain, row) };
+      renderSelectionInspector();
+      renderSettings();
+      renderSnapshot();
+    }
+
+    function currentSelectionRow() {
+      const domain = state.selected.domain;
+      const ref = String(state.selected.target_ref || "").trim();
+      if (!domain || !ref) return null;
+      const rows = domain === "settings" ? state.settingsRows : domain === "account_snapshot" ? state.snapshotRows : [];
+      return rows.find((row) => rowKey(domain, row) === ref) || null;
+    }
+
+    function currentSelectionTarget() {
+      const row = currentSelectionRow();
+      if (!row) return { domain: "", target_ref: "" };
+      return { domain: state.selected.domain, target_ref: rowKey(state.selected.domain, row) };
+    }
+
+    function selectedDomainOrDefault() {
+      if (state.selected.domain === "settings" || state.selected.domain === "account_snapshot") {
+        return state.selected.domain;
+      }
+      const active = document.activeElement;
+      if (active && active.closest) {
+        if (active.closest("#snapshotWrap") || active.closest("#snapshotTsv")) return "account_snapshot";
+        if (active.closest("#settingsWrap")) return "settings";
+      }
+      return "settings";
+    }
+
+    function normalizeViewPreset(domain, preset) {
+      const fallback = domain === "settings"
+        ? { sortField: "ordinal", sortDirection: "asc", filter: "" }
+        : { sortField: "ordinal", sortDirection: "asc", filter: "" };
+      if (!preset || typeof preset !== "object") return fallback;
+      return {
+        sortField: String(preset.sortField || fallback.sortField),
+        sortDirection: String(preset.sortDirection || fallback.sortDirection),
+        filter: String(preset.filter || ""),
+      };
+    }
+
+    function loadStoredViewPrefs() {
+      const prefs = loadJsonStorage(PREF_STORAGE_KEY, {});
+      state.viewPrefs.settings = normalizeViewPreset("settings", prefs.settings);
+      state.viewPrefs.account_snapshot = normalizeViewPreset("account_snapshot", prefs.account_snapshot);
+      state.filterSettings = state.viewPrefs.settings.filter || "";
+      state.filterSnapshot = state.viewPrefs.account_snapshot.filter || "";
+    }
+
+    function persistViewPrefs() {
+      saveJsonStorage(PREF_STORAGE_KEY, state.viewPrefs);
+    }
+
+    function loadStoredPresets() {
+      const presets = loadJsonStorage(VIEW_STORAGE_KEY, { settings: [], account_snapshot: [] });
+      state.viewPresets.settings = Array.isArray(presets.settings) ? presets.settings : [];
+      state.viewPresets.account_snapshot = Array.isArray(presets.account_snapshot) ? presets.account_snapshot : [];
+    }
+
+    function persistViewPresets() {
+      saveJsonStorage(VIEW_STORAGE_KEY, state.viewPresets);
+    }
+
+    function updateViewControls(domain) {
+      const prefs = state.viewPrefs[domain] || {};
+      const filterId = domain === "settings" ? "settingsFilter" : "snapshotFilter";
+      const sortFieldId = domain === "settings" ? "settingsSortField" : "snapshotSortField";
+      const sortDirId = domain === "settings" ? "settingsSortDirection" : "snapshotSortDirection";
+      const presetId = domain === "settings" ? "settingsViewPreset" : "snapshotViewPreset";
+      document.getElementById(filterId).value = prefs.filter || "";
+      document.getElementById(sortFieldId).value = prefs.sortField || "ordinal";
+      document.getElementById(sortDirId).value = prefs.sortDirection || "asc";
+      const select = document.getElementById(presetId);
+      const presets = state.viewPresets[domain] || [];
+      select.innerHTML = ['<option value="">Saved views</option>']
+        .concat(presets.map((item) => `<option value="${esc(item.name)}">${esc(item.name)}</option>`))
+        .join("");
+    }
+
+    function applyViewPreferences(domain) {
+      const filterId = domain === "settings" ? "settingsFilter" : "snapshotFilter";
+      const sortFieldId = domain === "settings" ? "settingsSortField" : "snapshotSortField";
+      const sortDirId = domain === "settings" ? "settingsSortDirection" : "snapshotSortDirection";
+      state.viewPrefs[domain] = {
+        sortField: document.getElementById(sortFieldId).value.trim() || "ordinal",
+        sortDirection: document.getElementById(sortDirId).value,
+        filter: document.getElementById(filterId).value,
+      };
+      persistViewPrefs();
+      renderSettings();
+      renderSnapshot();
+    }
+
+    function saveViewPreset(domain) {
+      const name = prompt("Save view preset name");
+      if (!name) return;
+      const filterId = domain === "settings" ? "settingsFilter" : "snapshotFilter";
+      const sortFieldId = domain === "settings" ? "settingsSortField" : "snapshotSortField";
+      const sortDirId = domain === "settings" ? "settingsSortDirection" : "snapshotSortDirection";
+      const preset = {
+        name,
+        filter: document.getElementById(filterId).value,
+        sortField: document.getElementById(sortFieldId).value.trim() || "ordinal",
+        sortDirection: document.getElementById(sortDirId).value,
+      };
+      const list = state.viewPresets[domain] || [];
+      const index = list.findIndex((item) => item.name === name);
+      if (index >= 0) list[index] = preset;
+      else list.push(preset);
+      state.viewPresets[domain] = list;
+      persistViewPresets();
+      updateViewControls(domain);
+    }
+
+    function loadViewPreset(domain) {
+      const presetId = domain === "settings" ? "settingsViewPreset" : "snapshotViewPreset";
+      const name = document.getElementById(presetId).value;
+      if (!name) return;
+      const preset = (state.viewPresets[domain] || []).find((item) => item.name === name);
+      if (!preset) return;
+      const filterId = domain === "settings" ? "settingsFilter" : "snapshotFilter";
+      const sortFieldId = domain === "settings" ? "settingsSortField" : "snapshotSortField";
+      const sortDirId = domain === "settings" ? "settingsSortDirection" : "snapshotSortDirection";
+      document.getElementById(filterId).value = preset.filter || "";
+      document.getElementById(sortFieldId).value = preset.sortField || "ordinal";
+      document.getElementById(sortDirId).value = preset.sortDirection || "asc";
+      applyViewPreferences(domain);
+    }
+
+    function clearViewPreset(domain) {
+      const presetId = domain === "settings" ? "settingsViewPreset" : "snapshotViewPreset";
+      const name = document.getElementById(presetId).value;
+      if (!name) return;
+      state.viewPresets[domain] = (state.viewPresets[domain] || []).filter((item) => item.name !== name);
+      persistViewPresets();
+      updateViewControls(domain);
+    }
+
+    function sortRows(rows, domain) {
+      const prefs = state.viewPrefs[domain] || {};
+      const field = prefs.sortField || "ordinal";
+      const direction = String(prefs.sortDirection || "asc").toLowerCase() === "desc" ? -1 : 1;
+      const sorted = (rows || []).slice();
+      sorted.sort((a, b) => {
+        const av = a?.[field];
+        const bv = b?.[field];
+        const aText = av === null || av === undefined ? "" : String(av);
+        const bText = bv === null || bv === undefined ? "" : String(bv);
+        const aNum = Number(aText);
+        const bNum = Number(bText);
+        if (!Number.isNaN(aNum) && !Number.isNaN(bNum) && aText !== "" && bText !== "") {
+          return (aNum - bNum) * direction;
+        }
+        return aText.localeCompare(bText, "ko") * direction;
+      });
+      return sorted;
+    }
+
+    function applyFiltersAndSort(domain, rows, columns) {
+      const filterText = domain === "settings" ? state.filterSettings : state.filterSnapshot;
+      const terms = String(filterText || "").toLowerCase().trim().replaceAll("\t", " ").split(" ").filter(Boolean);
+      const filtered = rows.filter((row) => matchesFilter(row, terms, columns));
+      return sortRows(filtered, domain);
+    }
+
+    function rowFieldDiffs(beforeRow, afterRow, columns) {
+      const fields = [];
+      const seen = new Set(columns || []);
+      for (const column of columns || []) {
+        const before = cellValue(beforeRow || {}, column);
+        const after = cellValue(afterRow || {}, column);
+        if (before !== after) {
+          fields.push({ field: column, before, after });
+        }
+      }
+      for (const key of Object.keys(beforeRow || {})) {
+        if (key.startsWith("_") || seen.has(key)) continue;
+        const before = cellValue(beforeRow || {}, key);
+        const after = cellValue(afterRow || {}, key);
+        if (before !== after) {
+          fields.push({ field: key, before, after });
+        }
+      }
+      for (const key of Object.keys(afterRow || {})) {
+        if (key.startsWith("_") || seen.has(key) || Object.prototype.hasOwnProperty.call(beforeRow || {}, key)) continue;
+        const before = "";
+        const after = cellValue(afterRow || {}, key);
+        if (before !== after) {
+          fields.push({ field: key, before, after });
+        }
+      }
+      return fields;
+    }
+
+    function rowDiffSummary(beforeRows, afterRows, domain, columns) {
+      const beforeMap = new Map((beforeRows || []).map((row) => [rowKey(domain, row), row]));
+      const afterMap = new Map((afterRows || []).map((row) => [rowKey(domain, row), row]));
+      const added = [];
+      const removed = [];
+      const changed = [];
+      for (const [key, afterRow] of afterMap.entries()) {
+        if (!beforeMap.has(key)) {
+          added.push({ key, row: afterRow });
+          continue;
+        }
+        const beforeRow = beforeMap.get(key);
+        const beforeJson = JSON.stringify(beforeRow);
+        const afterJson = JSON.stringify(afterRow);
+        if (beforeJson !== afterJson) {
+          changed.push({ key, before: beforeRow, after: afterRow, cells: rowFieldDiffs(beforeRow, afterRow, columns) });
+        }
+      }
+      for (const [key, beforeRow] of beforeMap.entries()) {
+        if (!afterMap.has(key)) {
+          removed.push({ key, row: beforeRow });
+        }
+      }
+      return { added, removed, changed };
+    }
+
+    function buildDiffHtml(title, summary) {
+      const sections = [
+        { label: "added", items: summary.added, tone: "good" },
+        { label: "removed", items: summary.removed, tone: "danger" },
+        { label: "changed", items: summary.changed, tone: "warn" },
+      ];
+      const blocks = sections.map((section) => {
+        const entries = section.items.slice(0, 5).map((item) => {
+          const before = item.before ? JSON.stringify(item.before, null, 2) : JSON.stringify(item.row, null, 2);
+          const after = item.after ? JSON.stringify(item.after, null, 2) : JSON.stringify(item.row, null, 2);
+          const cellText = item.cells && item.cells.length
+            ? `<code>${esc(item.cells.map((cell) => `${cell.field}: ${cell.before} -> ${cell.after}`).join("\n"))}</code>`
+            : "";
+          const detail = item.after
+            ? `<strong>${esc(item.key)}</strong>${cellText}<code>before:\n${esc(before)}\n\nafter:\n${esc(after)}</code>`
+            : `<strong>${esc(item.key)}</strong><code>${esc(after)}</code>`;
+          return `<div class="diff-item"><span class="chip">${section.label}</span>${detail}</div>`;
+        }).join("");
+        return `<div><div class="chip">${section.label}: ${section.items.length}</div>${entries || "<div class='muted'>none</div>"}</div>`;
+      }).join("");
+      return `<div class="diff-list"><div class="chip">${esc(title)}</div>${blocks}</div>`;
+    }
+
+    function buildTable(containerId, tableId, columns, rows, options) {
+      const container = document.getElementById(containerId);
+      const domain = options?.domain || "";
+      const table = document.createElement("table");
+      table.className = "sheet";
+      table.id = tableId;
+      const thead = document.createElement("thead");
+      const headRow = document.createElement("tr");
+      const numHead = document.createElement("th");
+      numHead.className = "rownum";
+      numHead.textContent = "#";
+      headRow.appendChild(numHead);
+      columns.forEach((column) => {
+        const th = document.createElement("th");
+        th.textContent = column;
+        headRow.appendChild(th);
+      });
+      if (options && Array.isArray(options.rowActions) && options.rowActions.length > 0) {
+        const th = document.createElement("th");
+        th.textContent = "actions";
+        headRow.appendChild(th);
+      }
+      thead.appendChild(headRow);
+      table.appendChild(thead);
+
+      const tbody = document.createElement("tbody");
+      rows.forEach((row, rowIndex) => {
+        const tr = document.createElement("tr");
+        tr.dataset.rowIndex = String(rowIndex);
+        tr.dataset.rowRef = String(row?._row_ref || rowKey(domain, row) || "");
+        const currentSelection = state.selected || {};
+        if (domain && currentSelection.domain === domain && currentSelection.target_ref === tr.dataset.rowRef) {
+          tr.classList.add("selected");
+        }
+        tr.addEventListener("click", (event) => {
+          if (event.target.closest("button")) return;
+          if (domain) {
+            selectRow(domain, row);
+          }
+        });
+        const rowNum = document.createElement("td");
+        rowNum.className = "rownum";
+        rowNum.textContent = String(rowIndex + 1);
+        tr.appendChild(rowNum);
+        columns.forEach((column, colIndex) => {
+          const td = document.createElement("td");
+          td.setAttribute("contenteditable", "true");
+          td.setAttribute("spellcheck", "false");
+          td.dataset.colIndex = String(colIndex);
+          td.textContent = cellValue(row, column);
+          td.addEventListener("paste", (event) => handlePaste(event, tableId, columns));
+          td.addEventListener("input", () => previewDiff());
+          td.addEventListener("focus", () => {
+            if (domain) selectRow(domain, row);
+          });
+          td.addEventListener("keydown", (event) => {
+            if (event.key === "Enter" && !event.shiftKey) {
+              event.preventDefault();
+              td.blur();
+            }
+          });
+          tr.appendChild(td);
+        });
+        if (options && Array.isArray(options.rowActions) && options.rowActions.length > 0) {
+          const actionTd = document.createElement("td");
+          const actions = document.createElement("div");
+          actions.className = "row-actions";
+          options.rowActions.forEach((action) => {
+            const btn = document.createElement("button");
+            btn.textContent = action.label;
+            if (action.className) {
+              btn.className = action.className;
+            }
+            btn.addEventListener("click", () => action.onClick(row, rowIndex));
+            actions.appendChild(btn);
+          });
+          actionTd.appendChild(actions);
+          tr.appendChild(actionTd);
+        }
+        tbody.appendChild(tr);
+      });
+      table.appendChild(tbody);
+      container.innerHTML = "";
+      container.appendChild(table);
+      if (options && options.emptyMessage && rows.length === 0) {
+        const empty = document.createElement("div");
+        empty.className = "muted";
+        empty.style.padding = "12px";
+        empty.textContent = options.emptyMessage;
+        container.appendChild(empty);
+      }
+    }
+
+    function matchesFilter(row, terms, columns) {
+      if (!terms.length) return true;
+      const haystack = columns.map((column) => String(row[column] ?? "")).join(" ").toLowerCase();
+      return terms.every((term) => haystack.includes(term));
+    }
+
+    function handlePaste(event, tableId, columns) {
+      const text = event.clipboardData.getData("text/plain");
+      if (!text.includes("\t") && !text.includes("\n")) {
+        return;
+      }
+      event.preventDefault();
+      const table = document.getElementById(tableId);
+      const startCell = event.target.closest("td");
+      const startRow = startCell.parentElement.rowIndex - 1;
+      const startCol = Number(startCell.dataset.colIndex);
+      const rows = table.querySelectorAll("tbody tr[data-row-index]");
+      const pastedRows = text.replace(/\r/g, "").split("\n").filter((line) => line.trim() !== "");
+      pastedRows.forEach((line, rowOffset) => {
+        const targetRow = rows[startRow + rowOffset];
+        if (!targetRow) return;
+        const values = line.split("\t");
+        values.forEach((value, colOffset) => {
+          const targetCell = targetRow.querySelector(`td[data-col-index="${startCol + colOffset}"]`);
+          if (targetCell) {
+            targetCell.innerText = value;
+          }
+        });
+      });
+    }
+
+    function addSettingRow() {
+      state.settingsRows.push({ ordinal: state.settingsRows.length + 1, _row_ref: `settings:new:${state.settingsRows.length + 1}`, key: "", value: "", note: "", updated_at: "" });
+      renderSettings();
+    }
+
+    function addSnapshotRow() {
+      const row = { ordinal: state.snapshotRows.length + 1, _row_ref: `account_snapshot:new:${state.snapshotRows.length + 1}` };
+      state.snapshotColumns.forEach((col) => {
+        row[col] = "";
+      });
+      row.parse_status = "NOT_PROVIDED";
+      row.user_confirmed = "N";
+      state.snapshotRows.push(row);
+      renderSnapshot();
+    }
+
+    function deleteSettingRow(row) {
+      const index = state.settingsRows.indexOf(row);
+      if (index >= 0) {
+        state.settingsRows.splice(index, 1);
+        state.settingsRows.forEach((item, idx) => { item.ordinal = idx + 1; });
+        renderSettings();
+      }
+    }
+
+    function deleteSnapshotRow(row) {
+      const index = state.snapshotRows.indexOf(row);
+      if (index >= 0) {
+        state.snapshotRows.splice(index, 1);
+        state.snapshotRows.forEach((item, idx) => { item.ordinal = idx + 1; });
+        renderSnapshot();
+      }
+    }
+
+    function _nextTempRowRef(domain, suffix) {
+      const rows = domain === "settings" ? state.settingsRows : state.snapshotRows;
+      return `${domain}:${suffix}:${rows.length + 1}:${Date.now().toString(36)}`;
+    }
+
+    function _reindexRows(rows) {
+      rows.forEach((item, idx) => {
+        item.ordinal = idx + 1;
+      });
+    }
+
+    function insertSettingRow(referenceRow, placement = "below", duplicate = false) {
+      const index = state.settingsRows.indexOf(referenceRow);
+      const insertAt = index < 0 ? state.settingsRows.length : (placement === "above" ? index : index + 1);
+      const template = duplicate ? referenceRow : {};
+      const row = {
+        ordinal: insertAt + 1,
+        _row_ref: _nextTempRowRef("settings", duplicate ? "copy" : "blank"),
+        key: duplicate ? "" : "",
+        value: duplicate ? template.value : "",
+        note: duplicate ? template.note : "",
+        updated_at: "",
+      };
+      state.settingsRows.splice(insertAt, 0, row);
+      _reindexRows(state.settingsRows);
+      selectRow("settings", row);
+      renderSettings();
+    }
+
+    function insertSnapshotRow(referenceRow, placement = "below", duplicate = false) {
+      const index = state.snapshotRows.indexOf(referenceRow);
+      const insertAt = index < 0 ? state.snapshotRows.length : (placement === "above" ? index : index + 1);
+      const row = duplicate
+        ? { ...cloneRows([referenceRow])[0] }
+        : {};
+      const nextRow = {
+        ordinal: insertAt + 1,
+        _row_ref: _nextTempRowRef("account_snapshot", duplicate ? "copy" : "blank"),
+      };
+      state.snapshotColumns.forEach((col) => {
+        if (duplicate) {
+          nextRow[col] = row[col] ?? "";
+        } else {
+          nextRow[col] = "";
+        }
+      });
+      nextRow.parse_status = duplicate ? (row.parse_status || "CAPTURE_READ_OK") : "NOT_PROVIDED";
+      nextRow.user_confirmed = duplicate ? (row.user_confirmed || "N") : "N";
+      state.snapshotRows.splice(insertAt, 0, nextRow);
+      _reindexRows(state.snapshotRows);
+      selectRow("account_snapshot", nextRow);
+      renderSnapshot();
+    }
+
+    function renderSettings() {
+      updateViewControls("settings");
+      const filteredRows = applyFiltersAndSort("settings", state.settingsRows, ["key", "value", "note"]);
+      buildTable("settingsWrap", "settingsTable", ["key", "value", "note"], filteredRows, {
+        domain: "settings",
+        emptyMessage: "No settings rows yet.",
+        rowActions: [
+          { label: "Insert above", onClick: (row) => insertSettingRow(row, "above") },
+          { label: "Insert below", onClick: (row) => insertSettingRow(row, "below") },
+          { label: "Duplicate", onClick: (row) => insertSettingRow(row, "below", true) },
+          { label: "Approve row", className: "good", onClick: (row) => approveTarget("settings", settingsTargetRef(row)) },
+          { label: "Lock row", onClick: (row) => lockTarget("settings", settingsTargetRef(row)) },
+          { label: "Unlock row", onClick: (row) => unlockTarget("settings", settingsTargetRef(row)) },
+          { label: "Delete", className: "danger", onClick: deleteSettingRow },
+        ],
+      });
+    }
+
+    function renderSnapshot() {
+      updateViewControls("account_snapshot");
+      const filteredRows = applyFiltersAndSort("account_snapshot", state.snapshotRows, ["ticker", "name", "account", "account_type", "parse_status", "position_type"]);
+      buildTable("snapshotWrap", "snapshotTable", state.snapshotColumns, filteredRows, {
+        domain: "account_snapshot",
+        emptyMessage: "No account snapshot rows yet.",
+        rowActions: [
+          { label: "Insert above", onClick: (row) => insertSnapshotRow(row, "above") },
+          { label: "Insert below", onClick: (row) => insertSnapshotRow(row, "below") },
+          { label: "Duplicate", onClick: (row) => insertSnapshotRow(row, "below", true) },
+          { label: "Approve row", className: "good", onClick: (row) => approveTarget("account_snapshot", snapshotTargetRef(row)) },
+          { label: "Lock row", onClick: (row) => lockTarget("account_snapshot", snapshotTargetRef(row)) },
+          { label: "Unlock row", onClick: (row) => unlockTarget("account_snapshot", snapshotTargetRef(row)) },
+          { label: "Delete", className: "danger", onClick: deleteSnapshotRow },
+        ],
+      });
+    }
+
+    function parseCellValue(value) {
+      const text = value.trim();
+      if (text === "") return "";
+      if (text === "null" || text === "None") return null;
+      if (text === "true") return true;
+      if (text === "false") return false;
+      const numericPattern = new RegExp("^-?(0|[1-9]\\d*)(\\.\\d+)?([eE][-+]?\\d+)?$");
+      if (numericPattern.test(text)) return Number(text);
+      try {
+        return JSON.parse(text);
+      } catch (err) {
+        return text;
+      }
+    }
+
+    async function reloadState() {
+      const response = await fetch("/api/state");
+      const payload = await response.json();
+      state.summary = payload.summary || {};
+      state.version = payload.version || {};
+      state.approvalRows = payload.approval_rows || [];
+      state.approvalSettings = payload.approval_settings || {};
+      state.approvalSnapshot = payload.approval_account_snapshot || {};
+      state.locks = payload.locks || [];
+      state.recentChanges = payload.recent_changes || [];
+      state.settingsRows = (payload.settings_rows || []).map((row) => ({ ...row, _row_ref: settingsTargetRef(row) }));
+      state.snapshotRows = (payload.account_snapshot_rows || []).map((row) => ({ ...row, _row_ref: snapshotTargetRef(row) }));
+      state.initialSettingsRows = cloneRows(state.settingsRows);
+      state.initialSnapshotRows = cloneRows(state.snapshotRows);
+      state.snapshotColumns = payload.account_snapshot_columns || [];
+      state.validation = payload.validation || { settings: [], account_snapshot: [] };
+      state.suggestions = (state.validation && state.validation.suggestions) || [];
+      state.autofixActions = payload.autofix_actions || [];
+      loadStoredViewPrefs();
+      loadStoredPresets();
+      renderSettings();
+      renderSnapshot();
+      renderMeta();
+      renderCollectionState();
+      renderSelectionInspector();
+      renderValidation();
+      document.getElementById("workspaceStatus").innerHTML = `
+        <strong>DB:</strong> ${esc(state.summary.db_path || "")}
+        <strong>settings:</strong> ${esc(state.summary.settings_rows ?? 0)}
+        <strong>account_snapshot:</strong> ${esc(state.summary.account_snapshot_rows ?? 0)}
+        <strong>updated:</strong> ${esc(state.summary.latest_update || "")}
+      `;
+      previewDiff();
+    }
+
+    async function saveSettings() {
+      if (String(state.filterSettings || "").trim()) {
+        throw new Error("clear settings filter before saving");
+      }
+      const rows = currentSettingsRows();
+      if (state.locks.some((lock) => lock.domain === "settings" && lock.target_ref === "*")) {
+        throw new Error("settings are locked");
+      }
+      const targets = rows.map((row) => String(row.key || "").trim()).filter(Boolean);
+      if (state.locks.some((lock) => lock.domain === "settings" && lock.target_ref !== "*" && targets.includes(String(lock.target_ref || "").trim()))) {
+        throw new Error("one or more settings rows are locked");
+      }
+      const response = await fetch("/api/settings/save", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ rows }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "settings save failed");
+      await reloadState();
+      alert(`settings saved: ${payload.settings_rows}`);
+    }
+
+    async function saveSnapshot() {
+      if (String(state.filterSnapshot || "").trim()) {
+        throw new Error("clear snapshot filter before saving");
+      }
+      const columns = state.snapshotColumns;
+      const rows = currentSnapshotRows();
+      if (state.locks.some((lock) => lock.domain === "account_snapshot" && lock.target_ref === "*")) {
+        throw new Error("account_snapshot is locked");
+      }
+      const targets = rows.map((row) => snapshotTargetRef(row)).filter(Boolean);
+      if (state.locks.some((lock) => lock.domain === "account_snapshot" && lock.target_ref !== "*" && targets.includes(String(lock.target_ref || "").trim()))) {
+        throw new Error("one or more account_snapshot rows are locked");
+      }
+      const response = await fetch("/api/account_snapshot/save", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ rows }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "snapshot save failed");
+      await reloadState();
+      alert(`account_snapshot saved: ${payload.account_snapshot_rows}`);
+    }
+
+    async function importSnapshotTsv() {
+      const tsv = document.getElementById("snapshotTsv").value;
+      const response = await fetch("/api/account_snapshot/import_tsv", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ tsv }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "TSV import failed");
+      await reloadState();
+      alert(`Imported ${payload.account_snapshot_rows} snapshot rows`);
+    }
+
+    async function approveDomain(domain) {
+      const response = await fetch("/api/approve", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ domain }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "approve failed");
+      await reloadState();
+    }
+
+    async function approveTarget(domain, targetRef) {
+      const response = await fetch("/api/approve", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ domain, target_ref: targetRef || "*" }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "approve failed");
+      await reloadState();
+      return payload;
+    }
+
+    async function lockDomain(domain) {
+      return lockTarget(domain, "*");
+    }
+
+    async function lockTarget(domain, targetRef) {
+      const response = await fetch("/api/lock", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ domain, target_ref: targetRef || "*" }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "lock failed");
+      await reloadState();
+    }
+
+    async function unlockDomain(domain) {
+      return unlockTarget(domain, "*");
+    }
+
+    async function unlockTarget(domain, targetRef) {
+      const response = await fetch("/api/unlock", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ domain, target_ref: targetRef || "*" }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "unlock failed");
+      await reloadState();
+    }
+
+    async function lockTargetFromInput() {
+      const domain = document.getElementById("lockDomainInput").value.trim();
+      const targetRef = document.getElementById("lockTargetInput").value.trim();
+      await lockTarget(domain, targetRef || "*");
+    }
+
+    async function unlockTargetFromInput() {
+      const domain = document.getElementById("lockDomainInput").value.trim();
+      const targetRef = document.getElementById("lockTargetInput").value.trim();
+      await unlockTarget(domain, targetRef || "*");
+    }
+
+    async function approvePendingChanges() {
+      const packet = buildApprovalPacket();
+      if (!packet.pending_targets.length) {
+        alert("No pending changes to approve.");
+        return;
+      }
+      for (const target of packet.pending_targets) {
+        const response = await fetch("/api/approve", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ domain: target.domain, target_ref: target.target_ref }),
+        });
+        const payload = await response.json();
+        if (!response.ok) throw new Error(payload.detail || `approve failed: ${target.domain}:${target.target_ref}`);
+      }
+      await reloadState();
+    }
+
+    function previewDiff() {
+      const settingsDiff = rowDiffSummary(state.initialSettingsRows, currentSettingsRows(), "settings", ["key", "value", "note"]);
+      const snapshotDiff = rowDiffSummary(state.initialSnapshotRows, currentSnapshotRows(), "account_snapshot", state.snapshotColumns);
+      const settingsHtml = buildDiffHtml("settings pending diff", settingsDiff);
+      const snapshotHtml = buildDiffHtml("account_snapshot pending diff", snapshotDiff);
+      document.getElementById("diffPreview").innerHTML = `${settingsHtml}<hr style="border:0;border-top:1px solid rgba(255,255,255,.08);margin:12px 0;">${snapshotHtml}`;
+    }
+
+    function buildApprovalPacket() {
+      const settingsDiff = rowDiffSummary(state.initialSettingsRows, currentSettingsRows(), "settings", ["key", "value", "note"]);
+      const snapshotDiff = rowDiffSummary(state.initialSnapshotRows, currentSnapshotRows(), "account_snapshot", state.snapshotColumns);
+      const pending_targets = [
+        ...settingsDiff.added.map((item) => ({ domain: "settings", target_ref: item.key, change_type: "added" })),
+        ...settingsDiff.removed.map((item) => ({ domain: "settings", target_ref: item.key, change_type: "removed" })),
+        ...settingsDiff.changed.map((item) => ({ domain: "settings", target_ref: item.key, change_type: "changed" })),
+        ...snapshotDiff.added.map((item) => ({ domain: "account_snapshot", target_ref: item.key, change_type: "added" })),
+        ...snapshotDiff.removed.map((item) => ({ domain: "account_snapshot", target_ref: item.key, change_type: "removed" })),
+        ...snapshotDiff.changed.map((item) => ({ domain: "account_snapshot", target_ref: item.key, change_type: "changed" })),
+      ];
+      return {
+        formula_id: "SNAPSHOT_ADMIN_APPROVAL_PACKET_V1",
+        generated_at: new Date().toISOString(),
+        summary: {
+          settings_changed: settingsDiff.added.length + settingsDiff.removed.length + settingsDiff.changed.length,
+          account_snapshot_changed: snapshotDiff.added.length + snapshotDiff.removed.length + snapshotDiff.changed.length,
+          pending_target_count: pending_targets.length,
+        },
+        pending_targets,
+        diff_preview: {
+          settings: settingsDiff,
+          account_snapshot: snapshotDiff,
+        },
+        approvals: state.approvalRows || [],
+        locks: state.locks || [],
+        workspace: state.summary || {},
+      };
+    }
+
+    async function exportApprovalPacket() {
+      const packet = buildApprovalPacket();
+      const response = await fetch("/api/approval_packet", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ packet }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "approval packet export failed");
+      alert(`approval packet exported: ${payload.packet_path}`);
+      await reloadState();
+    }
+
+    async function undoLastChange(domain) {
+      const response = await fetch("/api/undo", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ domain }),
+      });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "undo failed");
+      await reloadState();
+    }
+
+    async function runAutofix() {
+      const eligible = (state.autofixActions || []).filter((item) => item.action_id !== "required_total_asset_missing");
+      if (!eligible.length) {
+        alert("No safe autofix actions available.");
+        return;
+      }
+      for (const action of eligible) {
+        const response = await fetch("/api/autofix", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ action_id: action.action_id }),
+        });
+        const payload = await response.json();
+        if (!response.ok) throw new Error(payload.detail || `autofix failed: ${action.action_id}`);
+      }
+      await reloadState();
+    }
+
+    async function seedWorkspace() {
+      const response = await fetch("/api/bootstrap", { method: "POST" });
+      const payload = await response.json();
+      if (!response.ok) throw new Error(payload.detail || "seed failed");
+      await reloadState();
+      alert("Workspace seeded from GatherTradingData.json");
+    }
+
+    async function downloadExport() {
+      const response = await fetch("/api/export");
+      const payload = await response.text();
+      const blob = new Blob([payload], { type: "application/json" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "snapshot_admin_export.json";
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      URL.revokeObjectURL(url);
+    }
+
+    function fillSnapshotTemplate() {
+      document.getElementById("snapshotTsv").value = [
+        state.snapshotColumns.join("\t"),
+        state.snapshotColumns.map(() => "").join("\t"),
+      ].join("\n");
+    }
+
+    function renderMeta() {
+      const settingsApproval = state.approvalSettings || {};
+      const snapshotApproval = state.approvalSnapshot || {};
+      const version = state.version || {};
+      const git = version.git || {};
+      const source = version.source || {};
+      document.getElementById("versionSummary").textContent =
+        `app=${version.app || "N/A"} | git=${git.commit || "N/A"} | tree=${git.tree_state || "N/A"} | source=${source.fingerprint || "N/A"}`;
+      document.getElementById("approvalSettingsChip").textContent =
+        `settings: ${settingsApproval.status || "MISSING"} / ${settingsApproval.updated_at || ""}`;
+      document.getElementById("approvalSnapshotChip").textContent =
+        `account_snapshot: ${snapshotApproval.status || "MISSING"} / ${snapshotApproval.updated_at || ""}`;
+      const locks = state.locks || [];
+      document.getElementById("lockSummary").textContent =
+        locks.length === 0
+          ? "No active locks."
+          : locks.map((lock) => `${lock.domain}:${lock.target_ref} by ${lock.locked_by || "unknown"} (${lock.locked_at})`).join(" | ");
+      const approvalRows = state.approvalRows || [];
+      document.getElementById("approvalRowSummary").textContent =
+        approvalRows.length === 0
+          ? "No row-level approvals."
+          : approvalRows.slice(0, 8).map((row) => `${row.domain}:${row.target_ref}=${row.status}`).join(" | ");
+      const historyCounts = state.historyCounts || {};
+      const recent = (state.recentChanges || [])[0];
+      const changeLogFilter = String(document.getElementById("changeLogFilter")?.value || state.filterChangeLog || "").trim().toLowerCase();
+      state.filterChangeLog = changeLogFilter;
+      const visibleChanges = (state.recentChanges || []).filter((item) => {
+        if (!changeLogFilter) return true;
+        const haystack = [
+          item?.domain,
+          item?.action,
+          item?.target_ref,
+          item?.actor,
+          item?.note,
+          item?.created_at,
+        ].map((value) => String(value || "").toLowerCase()).join(" ");
+        return haystack.includes(changeLogFilter);
+      });
+      document.getElementById("historySummary").textContent =
+        `change_log=${historyCounts.changes ?? 0}, approvals=${historyCounts.approvals ?? 0}, locks=${historyCounts.locks ?? 0}` +
+        (changeLogFilter ? `, filtered=${visibleChanges.length}` : "") +
+        (recent ? ` | latest=${recent.domain}:${recent.action}:${recent.target_ref} @ ${recent.created_at}` : "");
+      document.getElementById("changeLog").textContent = visibleChanges.map((item) => {
+        const beforeCount = Array.isArray(item.before_json) ? item.before_json.length : 0;
+        const afterCount = Array.isArray(item.after_json) ? item.after_json.length : 0;
+        return `#${item.id} ${item.domain} ${item.action} ${item.target_ref} ${item.created_at}\n${beforeCount} -> ${afterCount}\n`;
+      }).join("\n");
+      const timelineEl = document.getElementById("changeTimeline");
+      if (timelineEl) {
+        timelineEl.innerHTML = visibleChanges.length
+          ? visibleChanges.map((item) => {
+              const before = Array.isArray(item.before_json) ? item.before_json : [];
+              const after = Array.isArray(item.after_json) ? item.after_json : [];
+              return `
+                <details class="history-item">
+                  <summary class="chip">${esc(item.domain)} · ${esc(item.action)} · ${esc(item.target_ref)} · ${esc(item.created_at)}</summary>
+                  <code>${esc(JSON.stringify({ before, after }, null, 2))}</code>
+                </details>
+              `;
+            }).join("")
+          : "<div class='muted'>No timeline entries.</div>";
+      }
+    }
+
+    function renderValidation() {
+      const settingsErrors = state.validation?.settings || [];
+      const snapshotErrors = state.validation?.account_snapshot || [];
+      const suggestions = state.validation?.suggestions || [];
+      const settingsText = settingsErrors.length ? settingsErrors.map((item) => `- ${item}`).join("\n") : "settings OK";
+      const snapshotText = snapshotErrors.length ? snapshotErrors.map((item) => `- ${item}`).join("\n") : "account_snapshot OK";
+      const suggestionText = suggestions.length ? suggestions.map((item) => `- ${item}`).join("\n") : "No suggestions";
+      document.getElementById("validationBox").textContent = `settings\n${settingsText}\n\naccount_snapshot\n${snapshotText}`;
+      const autofixText = (state.autofixActions || []).map((item) => `- ${item.label}`).join("\n") || "No safe autofix available";
+      document.getElementById("suggestionBox").textContent = `Suggestions\n${suggestionText}\n\nSafe autofix\n${autofixText}`;
+      const diffSummary = `recent changes: ${(state.recentChanges || []).length}\napproval settings: ${(state.approvalSettings || {}).status || "MISSING"}\napproval snapshot: ${(state.approvalSnapshot || {}).status || "MISSING"}`;
+      if (!document.getElementById("diffPreview").innerHTML.trim()) {
+        document.getElementById("diffPreview").textContent = diffSummary;
+      }
+    }
+
+    function renderCollectionState() {
+      const collection = state.collection || {};
+      const counts = collection.counts || {};
+      const latestRun = collection.latest_run || {};
+      const latestReport = collection.latest_report || {};
+      const recentRuns = collection.runs || [];
+      const recentSnapshots = collection.recent_snapshots || [];
+      const recentErrors = collection.recent_errors || [];
+      const chip = document.getElementById("collectionChip");
+      const summary = document.getElementById("collectionSummary");
+      const metrics = document.getElementById("collectionMetrics");
+      const runsEl = document.getElementById("collectionRuns");
+      const snapshotsEl = document.getElementById("collectionSnapshots");
+      const errorsEl = document.getElementById("collectionErrors");
+      const detailEl = document.getElementById("collectionDetail");
+      if (!chip || !summary || !metrics || !runsEl || !snapshotsEl || !errorsEl || !detailEl) return;
+      const filterText = String(document.getElementById("collectionFilter")?.value || state.filterCollection || "").trim().toLowerCase();
+      state.filterCollection = filterText;
+      chip.textContent = `collector: ${counts.collection_runs ?? 0} runs / ${counts.collection_snapshots ?? 0} snapshots / ${counts.collection_source_errors ?? 0} errors`;
+      summary.textContent = [
+        collection.db_path ? `db=${collection.db_path}` : "db=N/A",
+        collection.output_json_path ? `report=${collection.output_json_path}` : "report=N/A",
+        latestRun.run_id ? `latest_run=${latestRun.run_id}` : "",
+        latestReport.status ? `latest_status=${latestReport.status}` : "",
+        latestReport.generated_at ? `generated_at=${latestReport.generated_at}` : "",
+        filterText ? `filter=${filterText}` : "",
+      ].filter(Boolean).join(" | ");
+      const sourceCounts = latestReport.source_counts || {};
+      const metricItems = [
+        { label: "Runs", value: counts.collection_runs ?? 0 },
+        { label: "Snapshots", value: counts.collection_snapshots ?? 0 },
+        { label: "Errors", value: counts.collection_source_errors ?? 0 },
+      ];
+      if (latestReport.row_count !== undefined) {
+        metricItems.push({ label: "Rows in report", value: latestReport.row_count });
+      }
+      if (Object.keys(sourceCounts).length) {
+        metricItems.push({ label: "KIS", value: sourceCounts.kis_open_api ?? 0 });
+        metricItems.push({ label: "Naver", value: sourceCounts.naver_finance ?? 0 });
+        metricItems.push({ label: "Seed", value: sourceCounts.gathertradingdata_json ?? 0 });
+      }
+      metrics.innerHTML = metricItems.map((item) => `<div class="metric-card">${esc(item.label)}<strong>${esc(item.value)}</strong></div>`).join("");
+      const selection = state.collectionSelection || {};
+      const matchesFilter = (kind, item) => {
+        if (!filterText) return true;
+        const haystack = JSON.stringify({ kind, ...item }).toLowerCase();
+        return haystack.includes(filterText);
+      };
+      const renderItemList = (kind, items, emptyText) => {
+        const visible = items
+          .map((item, index) => ({ item, index }))
+          .filter(({ item }) => matchesFilter(kind, item));
+        if (!visible.length) return `<div class="muted">${esc(filterText ? `No ${kind} items match filter.` : emptyText)}</div>`;
+        return visible.map(({ item, index }) => {
+          const key = currentCollectionSelectionKey(kind, item, index);
+          const selected = selection.kind === kind && selection.key === key;
+          return `
+            <button class="collection-item ${selected ? "selected" : ""}" onclick="selectCollectionItem(${JSON.stringify(kind)}, ${JSON.stringify(key)})">
+              ${esc(collectionItemLabel(kind, item))}
+              <code>${esc(collectionItemDetail(kind, item))}</code>
+            </button>
+          `;
+        }).join("");
+      };
+      runsEl.innerHTML = renderItemList("run", recentRuns, "No collection runs yet.");
+      snapshotsEl.innerHTML = renderItemList("snapshot", recentSnapshots, "No collection snapshots yet.");
+      errorsEl.innerHTML = renderItemList("error", recentErrors, "No collection errors.");
+      const selectedItem = (() => {
+        const key = String(selection.key || "").trim();
+        if (!key) return null;
+        const run = recentRuns.find((item, index) => currentCollectionSelectionKey("run", item, index) === key);
+        if (run) return { kind: "run", item: run };
+        const snapshot = recentSnapshots.find((item, index) => currentCollectionSelectionKey("snapshot", item, index) === key);
+        if (snapshot) return { kind: "snapshot", item: snapshot };
+        const error = recentErrors.find((item, index) => currentCollectionSelectionKey("error", item, index) === key);
+        if (error) return { kind: "error", item: error };
+        return null;
+      })();
+      detailEl.textContent = selectedItem
+        ? collectionItemDetail(selectedItem.kind, selectedItem.item)
+        : JSON.stringify({
+            latest_run: latestRun,
+            latest_report: latestReport,
+          }, null, 2);
+    }
+
+    async function copyCollectionStatus() {
+      const collection = state.collection || {};
+      const counts = collection.counts || {};
+      const latestReport = collection.latest_report || {};
+      const text = [
+        `db=${collection.db_path || "N/A"}`,
+        `runs=${counts.collection_runs ?? 0}`,
+        `snapshots=${counts.collection_snapshots ?? 0}`,
+        `errors=${counts.collection_source_errors ?? 0}`,
+        `status=${latestReport.status || "N/A"}`,
+      ].join(" | ");
+      await navigator.clipboard.writeText(text);
+    }
+
+    function applyFilters() {
+      state.filterSettings = document.getElementById("settingsFilter").value;
+      state.filterSnapshot = document.getElementById("snapshotFilter").value;
+      state.viewPrefs.settings.filter = state.filterSettings;
+      state.viewPrefs.account_snapshot.filter = state.filterSnapshot;
+      persistViewPrefs();
+      renderSettings();
+      renderSnapshot();
+    }
+
+    function applyCollectionFilter() {
+      state.filterCollection = document.getElementById("collectionFilter").value;
+      renderCollectionState();
+    }
+
+    function clearCollectionFilter() {
+      const input = document.getElementById("collectionFilter");
+      if (input) input.value = "";
+      state.filterCollection = "";
+      renderCollectionState();
+    }
+
+    function clearChangeLogFilter() {
+      const input = document.getElementById("changeLogFilter");
+      if (input) input.value = "";
+      state.filterChangeLog = "";
+      renderMeta();
+    }
+
+    function renderSelectionInspector() {
+      const row = currentSelectionRow();
+      const summaryEl = document.getElementById("selectedRowSummary");
+      const detailEl = document.getElementById("selectedRowDetail");
+      const historyEl = document.getElementById("selectedRowHistory");
+      const batchDomainSelect = document.getElementById("batchDomainSelect");
+      if (!row) {
+        summaryEl.textContent = "No row selected.";
+        detailEl.textContent = "";
+        historyEl.textContent = "";
+        if (batchDomainSelect && !batchDomainSelect.value) {
+          batchDomainSelect.value = "settings";
+        }
+        return;
+      }
+      const domain = state.selected.domain;
+      const targetRef = rowKey(domain, row);
+      summaryEl.textContent = `${domain}:${targetRef} | ${rowDisplayLabel(domain, row)}`;
+      detailEl.textContent = JSON.stringify(row, null, 2);
+      const history = (state.recentChanges || []).filter((item) => {
+        if (!item || item.domain !== domain) return false;
+        const ref = String(item.target_ref || "").trim();
+        return ref === "*" || ref === targetRef || ref === String(row?.ticker || "").trim();
+      });
+      historyEl.textContent = history.length
+        ? history.slice(0, 8).map((item) => `#${item.id} ${item.action} ${item.target_ref} @ ${item.created_at}\n${JSON.stringify(item.before_json, null, 2)}\n=>\n${JSON.stringify(item.after_json, null, 2)}`).join("\n\n")
+        : "No recent history for selected row.";
+      if (batchDomainSelect) {
+        batchDomainSelect.value = domain;
+      }
+    }
+
+    function focusSelectedRow() {
+      const domain = state.selected.domain;
+      if (!domain) return;
+      const selector = domain === "settings" ? "#settingsTable tbody tr" : "#snapshotTable tbody tr";
+      const targetRef = String(state.selected.target_ref || "");
+      const row = document.querySelector(`${selector}[data-row-ref="${CSS.escape(targetRef)}"]`);
+      if (row) {
+        row.scrollIntoView({ block: "center", behavior: "smooth" });
+        row.classList.add("selected");
+      }
+    }
+
+    async function copySelectedTarget() {
+      const target = currentSelectionTarget();
+      if (!target.domain) {
+        alert("No row selected.");
+        return;
+      }
+      await navigator.clipboard.writeText(`${target.domain}:${target.target_ref}`);
+    }
+
+    async function approveSelectedRow() {
+      const target = currentSelectionTarget();
+      if (!target.domain) {
+        alert("No row selected.");
+        return;
+      }
+      await approveTarget(target.domain, target.target_ref);
+    }
+
+    async function lockSelectedRow() {
+      const target = currentSelectionTarget();
+      if (!target.domain) {
+        alert("No row selected.");
+        return;
+      }
+      await lockTarget(target.domain, target.target_ref);
+    }
+
+    async function unlockSelectedRow() {
+      const target = currentSelectionTarget();
+      if (!target.domain) {
+        alert("No row selected.");
+        return;
+      }
+      await unlockTarget(target.domain, target.target_ref);
+    }
+
+    function syncBatchDomain() {
+      const domain = document.getElementById("batchDomainSelect").value;
+      const selected = currentSelectionTarget();
+      if (!selected.domain) return;
+      if (selected.domain !== domain) {
+        state.selected = { domain, target_ref: "" };
+      }
+    }
+
+    function _tsvRows(tsvText) {
+      return String(tsvText || "").replace(/\r/g, "").split("\n").filter((line) => line.trim() !== "");
+    }
+
+    function applyBatchPaste() {
+      const domain = document.getElementById("batchDomainSelect").value;
+      const tsv = document.getElementById("batchPasteTsv").value;
+      const lines = _tsvRows(tsv);
+      if (!lines.length) {
+        alert("Paste TSV first.");
+        return;
+      }
+      const selected = currentSelectionRow();
+      const rows = domain === "settings" ? state.settingsRows : state.snapshotRows;
+      if (!selected || state.selected.domain !== domain) {
+        alert("Select a row in the same domain first.");
+        return;
+      }
+      const tableId = domain === "settings" ? "settingsTable" : "snapshotTable";
+      const table = document.getElementById(tableId);
+      const bodyRows = Array.from(table.querySelectorAll("tbody tr[data-row-index]"));
+      const startIndex = bodyRows.findIndex((tr) => tr.dataset.rowRef === rowKey(domain, selected));
+      if (startIndex < 0) {
+        alert("Selected row no longer exists.");
+        return;
+      }
+      const columns = domain === "settings" ? ["key", "value", "note"] : state.snapshotColumns;
+      const pastedRows = lines.map((line) => line.split("\t"));
+      pastedRows.forEach((values, rowOffset) => {
+        const targetRow = bodyRows[startIndex + rowOffset];
+        if (!targetRow) return;
+        values.forEach((value, colIndex) => {
+          const cell = targetRow.querySelector(`td[data-col-index="${colIndex}"]`);
+          if (cell) cell.innerText = value;
+        });
+      });
+      if (domain === "settings") renderSettings(); else renderSnapshot();
+      renderSelectionInspector();
+      previewDiff();
+    }
+
+    async function saveSelectedDomain() {
+      const domain = selectedDomainOrDefault();
+      if (domain === "account_snapshot") {
+        await saveSnapshot();
+      } else {
+        await saveSettings();
+      }
+    }
+
+    function installKeyboardShortcuts() {
+      document.addEventListener("keydown", (event) => {
+        if (event.key === "F5") return;
+        const target = event.target;
+        const isTyping = target && (
+          target.tagName === "INPUT" ||
+          target.tagName === "TEXTAREA" ||
+          target.isContentEditable
+        );
+        if (event.key === "Delete" && !event.ctrlKey && !event.metaKey && !event.altKey) {
+          if (isTyping) return;
+          const row = currentSelectionRow();
+          if (!row) return;
+          const domain = state.selected.domain;
+          const confirmMsg = `${domain}:${rowKey(domain, row)} delete?`;
+          if (!confirm(confirmMsg)) return;
+          if (domain === "settings") {
+            deleteSettingRow(row);
+          } else if (domain === "account_snapshot") {
+            deleteSnapshotRow(row);
+          }
+          event.preventDefault();
+          return;
+        }
+        if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "s") {
+          event.preventDefault();
+          saveSelectedDomain().catch((err) => alert(err.message));
+          return;
+        }
+        if ((event.ctrlKey || event.metaKey) && event.key === "Enter") {
+          event.preventDefault();
+          saveSelectedDomain().catch((err) => alert(err.message));
+          return;
+        }
+        if (isTyping) return;
+        if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+          const domain = selectedDomainOrDefault();
+          const rows = domain === "settings" ? state.settingsRows : state.snapshotRows;
+          if (!rows.length) return;
+          const current = currentSelectionRow();
+          let index = current ? rows.findIndex((row) => rowKey(domain, row) === rowKey(domain, current)) : -1;
+          index = event.key === "ArrowDown" ? Math.min(rows.length - 1, index + 1) : Math.max(0, index <= 0 ? 0 : index - 1);
+          const next = rows[index];
+          if (next) {
+            selectRow(domain, next);
+            focusSelectedRow();
+            event.preventDefault();
+          }
+        }
+      });
+    }
+
+    reloadState().catch((error) => {
+      document.getElementById("workspaceStatus").innerHTML = `<span class="error">${esc(error.message)}</span>`;
+    });
+    installKeyboardShortcuts();
+  </script>
+</body>
+</html>
+"""
+
+
+def render_collection_html() -> str:
+    return """<!doctype html>
+<html lang="ko">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>KIS Collection Dashboard</title>
+  <style>
+    :root {
+      color-scheme: light;
+      --bg: #0f172a;
+      --panel: #111827;
+      --line: #243047;
+      --text: #e5e7eb;
+      --muted: #9ca3af;
+      --accent: #38bdf8;
+      --accent-2: #22c55e;
+      --chip: #172036;
+    }
+    * { box-sizing: border-box; }
+    body { margin: 0; font-family: ui-sans-serif, system-ui, sans-serif; background: linear-gradient(180deg, #08101f 0%, #0b1220 100%); color: var(--text); }
+    header { padding: 24px; border-bottom: 1px solid rgba(255,255,255,.06); position: sticky; top: 0; background: rgba(5,10,20,.6); backdrop-filter: blur(10px); z-index: 10; }
+    h1 { margin: 0; font-size: 22px; }
+    .subline { margin-top: 6px; color: var(--muted); font-size: 13px; }
+    .wrap { max-width: 1280px; margin: 0 auto; padding: 20px 24px 40px; }
+    .panel { border: 1px solid rgba(255,255,255,.08); border-radius: 18px; overflow: hidden; background: linear-gradient(180deg, rgba(17,24,39,.94), rgba(10,16,28,.95)); box-shadow: 0 16px 48px rgba(0,0,0,.24); }
+    .panel-head { display:flex; flex-wrap:wrap; align-items:center; justify-content:space-between; gap:12px; padding: 16px 16px 10px; border-bottom: 1px solid rgba(255,255,255,.06); }
+    .actions { display:flex; flex-wrap:wrap; gap:8px; }
+    button, a.btn { border: 1px solid rgba(255,255,255,.12); background: var(--chip); color: var(--text); padding: 8px 12px; border-radius: 10px; cursor:pointer; font-size:13px; text-decoration:none; }
+    button.primary { background: linear-gradient(135deg, var(--accent), #0ea5e9); color:#fff; }
+    .pane { padding: 14px 16px 18px; }
+    .grid { display:grid; gap:12px; grid-template-columns: 1.1fr .9fr; }
+    .chip { display:inline-flex; gap:6px; align-items:center; padding:4px 8px; border-radius:999px; background: rgba(255,255,255,.06); color: var(--muted); font-size:12px; }
+    .muted { color: var(--muted); }
+    .metrics { display:grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap:8px; margin-top:10px; }
+    .metric { border: 1px solid rgba(255,255,255,.08); border-radius: 12px; padding: 10px; background: rgba(3,7,18,.42); font-size:12px; }
+    .metric strong { display:block; font-size:16px; margin-top:4px; }
+    .filter-row { display:flex; flex-wrap:wrap; gap:8px; margin-top: 10px; }
+    .filter-row input { background: rgba(3,7,18,.45); color: var(--text); border: 1px solid rgba(255,255,255,.10); border-radius: 10px; padding: 8px 10px; font-size: 12px; min-width: 220px; }
+    .list { display:grid; gap:8px; margin-top: 8px; }
+    .item { width:100%; text-align:left; border:1px solid rgba(255,255,255,.08); border-radius:12px; padding:10px; background: rgba(3,7,18,.42); color: var(--text); font-size:12px; cursor:pointer; }
+    .item.selected { border-color: rgba(96,165,250,.8); box-shadow: 0 0 0 1px rgba(96,165,250,.35) inset; }
+    .item code, pre { white-space: pre-wrap; }
+    pre { margin:0; max-height: 320px; overflow:auto; background: rgba(3,7,18,.45); border: 1px solid rgba(255,255,255,.08); border-radius: 12px; padding:10px; font-size:12px; }
+    @media (max-width: 980px) { .grid, .metrics { grid-template-columns: 1fr; } }
+  </style>
+</head>
+<body>
+  <header>
+    <h1>KIS Collection Dashboard</h1>
+    <div class="subline">Separate read-only view for KIS collection run, snapshots, errors, and raw JSON evidence.</div>
+  </header>
+  <main class="wrap">
+    <section class="panel">
+      <div class="panel-head">
+        <div>
+          <div class="chip" id="collectionChip">collection: loading...</div>
+          <div class="muted" id="collectionSummary" style="margin-top:10px;"></div>
+        </div>
+        <div class="actions">
+          <a class="btn" href="/">Back to workspace</a>
+          <a class="btn" href="/tables">Open table browser</a>
+          <button class="primary" onclick="reloadState()">Refresh</button>
+          <button onclick="downloadRawCollection()">Download raw JSON</button>
+          <button onclick="downloadCsvCollection()">Download CSV</button>
+        </div>
+      </div>
+      <div class="pane">
+        <div class="grid">
+          <div>
+            <div class="metrics" id="collectionMetrics"></div>
+            <div class="filter-row">
+              <input id="collectionFilter" placeholder="Filter runs / snapshots / errors" oninput="renderCollectionState()" />
+              <input id="collectionTickerFilter" placeholder="Ticker quick search" oninput="renderCollectionState()" />
+              <input id="collectionDateFilter" placeholder="Date quick search" oninput="renderCollectionState()" />
+              <button onclick="clearFilter()">Clear filter</button>
+            </div>
+            <div class="muted" style="margin-top:12px;">Recent collector runs</div>
+            <div id="collectionRuns" class="list"></div>
+            <div class="muted" style="margin-top:12px;">Recent collector snapshots</div>
+            <div id="collectionSnapshots" class="list"></div>
+            <div class="muted" style="margin-top:12px;">Recent collector errors</div>
+            <div id="collectionErrors" class="list"></div>
+          </div>
+          <div>
+            <div class="muted">Collection detail</div>
+            <pre id="collectionDetail"></pre>
+          </div>
+        </div>
+      </div>
+    </section>
+  </main>
+  <script>
+    const state = { collection: {}, selection: { kind: "", key: "" } };
+    function esc(value) { return String(value ?? "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;"); }
+    function keyFor(kind, item, index) {
+      if (kind === "run") return String(item?.run_id || item?.started_at || index || "").trim();
+      if (kind === "snapshot") return [item?.run_id, item?.dataset_name, item?.ticker, item?.created_at, index].join("|");
+      return [item?.run_id, item?.source_name, item?.ticker, item?.error_kind, item?.created_at, index].join("|");
+    }
+    function labelFor(kind, item) {
+      if (kind === "run") return `${item?.started_at || ""} ${item?.status || ""} ${item?.collector_name || "collector"} ${item?.run_id || ""} -> ${item?.finished_at || "RUNNING"}`.trim();
+      if (kind === "snapshot") return `${item?.created_at || ""} ${item?.dataset_name || ""}:${item?.ticker || ""} ${item?.source_status || ""}`.trim();
+      return `${item?.created_at || ""} ${item?.source_name || ""}:${item?.error_kind || ""} ${item?.ticker || ""} ${item?.error_message || ""}`.trim();
+    }
+    function detailFor(kind, item) { return JSON.stringify({ kind, ...item }, null, 2); }
+    function filtered(kind, items, filterText) {
+      const tickerText = String(document.getElementById("collectionTickerFilter")?.value || "").trim().toLowerCase();
+      const dateText = String(document.getElementById("collectionDateFilter")?.value || "").trim().toLowerCase();
+      return items.map((item, index) => ({ item, index })).filter(({ item }) => {
+        const haystack = JSON.stringify({ kind, ...item }).toLowerCase();
+        if (filterText && !haystack.includes(filterText)) return false;
+        if (tickerText && !haystack.includes(tickerText)) return false;
+        if (dateText && !haystack.includes(dateText)) return false;
+        return true;
+      });
+    }
+    async function reloadState() {
+      const response = await fetch("/api/state");
+      const payload = await response.json();
+      state.collection = payload.collection || {};
+      renderCollectionState();
+    }
+    function clearFilter() {
+      const input = document.getElementById("collectionFilter");
+      if (input) input.value = "";
+      const ticker = document.getElementById("collectionTickerFilter");
+      if (ticker) ticker.value = "";
+      const date = document.getElementById("collectionDateFilter");
+      if (date) date.value = "";
+      renderCollectionState();
+    }
+    function selectItem(kind, key) { state.selection = { kind, key }; renderCollectionState(); }
+    function renderCollectionState() {
+      const collection = state.collection || {};
+      const counts = collection.counts || {};
+      const latestRun = collection.latest_run || {};
+      const latestReport = collection.latest_report || {};
+      const runs = collection.runs || [];
+      const snapshots = collection.recent_snapshots || [];
+      const errors = collection.recent_errors || [];
+      const filterText = String(document.getElementById("collectionFilter")?.value || "").trim().toLowerCase();
+      document.getElementById("collectionChip").textContent = `collector: ${counts.collection_runs ?? 0} runs / ${counts.collection_snapshots ?? 0} snapshots / ${counts.collection_source_errors ?? 0} errors`;
+      document.getElementById("collectionSummary").textContent = [
+        collection.db_path ? `db=${collection.db_path}` : "db=N/A",
+        collection.output_json_path ? `report=${collection.output_json_path}` : "report=N/A",
+        latestRun.run_id ? `latest_run=${latestRun.run_id}` : "",
+        latestReport.generated_at ? `generated_at=${latestReport.generated_at}` : "",
+        filterText ? `filter=${filterText}` : "",
+        String(document.getElementById("collectionTickerFilter")?.value || "").trim() ? `ticker=${String(document.getElementById("collectionTickerFilter")?.value || "").trim()}` : "",
+        String(document.getElementById("collectionDateFilter")?.value || "").trim() ? `date=${String(document.getElementById("collectionDateFilter")?.value || "").trim()}` : "",
+      ].filter(Boolean).join(" | ");
+      const sourceCounts = latestReport.source_counts || {};
+      const metrics = [
+        { label: "Runs", value: counts.collection_runs ?? 0 },
+        { label: "Snapshots", value: counts.collection_snapshots ?? 0 },
+        { label: "Errors", value: counts.collection_source_errors ?? 0 },
+      ];
+      if (latestReport.row_count !== undefined) metrics.push({ label: "Rows", value: latestReport.row_count });
+      if (Object.keys(sourceCounts).length) {
+        metrics.push({ label: "KIS", value: sourceCounts.kis_open_api ?? 0 });
+        metrics.push({ label: "Naver", value: sourceCounts.naver_finance ?? 0 });
+        metrics.push({ label: "Seed", value: sourceCounts.gathertradingdata_json ?? 0 });
+      }
+      const combinedCount = [...runs, ...snapshots, ...errors].length;
+      metrics.push({ label: "Visible", value: filtered("run", runs, filterText).length + filtered("snapshot", snapshots, filterText).length + filtered("error", errors, filterText).length });
+      document.getElementById("collectionMetrics").innerHTML = metrics.map((item) => `<div class="metric">${esc(item.label)}<strong>${esc(item.value)}</strong></div>`).join("");
+      const renderList = (kind, items, emptyText) => {
+        const visible = filtered(kind, items, filterText);
+        if (!visible.length) return `<div class="muted">${esc(filterText ? `No ${kind} items match filter.` : emptyText)}</div>`;
+        return visible.map(({ item, index }) => {
+          const key = keyFor(kind, item, index);
+          const selected = state.selection.kind === kind && state.selection.key === key;
+          return `<button class="item ${selected ? "selected" : ""}" onclick="selectItem(${JSON.stringify(kind)}, ${JSON.stringify(key)})">${esc(labelFor(kind, item))}<code>${esc(detailFor(kind, item))}</code></button>`;
+        }).join("");
+      };
+      document.getElementById("collectionRuns").innerHTML = renderList("run", runs, "No collection runs yet.");
+      document.getElementById("collectionSnapshots").innerHTML = renderList("snapshot", snapshots, "No collection snapshots yet.");
+      document.getElementById("collectionErrors").innerHTML = renderList("error", errors, "No collection errors.");
+      const key = String(state.selection.key || "").trim();
+      const selected = runs.find((item, index) => keyFor("run", item, index) === key)
+        || snapshots.find((item, index) => keyFor("snapshot", item, index) === key)
+        || errors.find((item, index) => keyFor("error", item, index) === key);
+      document.getElementById("collectionDetail").textContent = selected ? JSON.stringify(selected, null, 2) : JSON.stringify({ latest_run: latestRun, latest_report: latestReport }, null, 2);
+    }
+    async function downloadRawCollection() {
+      const response = await fetch("/api/state");
+      const payload = await response.json();
+      const blob = new Blob([JSON.stringify(payload.collection || {}, null, 2)], { type: "application/json" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "kis_collection_state.json";
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      URL.revokeObjectURL(url);
+    }
+    async function downloadCsvCollection() {
+      const response = await fetch("/api/state");
+      const payload = await response.json();
+      const collection = payload.collection || {};
+      const rows = [
+        ...(collection.runs || []).map((item) => ({ kind: "run", ...item })),
+        ...(collection.recent_snapshots || []).map((item) => ({ kind: "snapshot", ...item })),
+        ...(collection.recent_errors || []).map((item) => ({ kind: "error", ...item })),
+      ];
+      const headers = ["kind", "run_id", "collector_name", "started_at", "finished_at", "status", "dataset_name", "ticker", "name", "source_name", "error_kind", "error_message", "created_at"];
+      const csv = [headers.join(",")].concat(rows.map((row) => headers.map((header) => {
+        const value = row[header];
+        const text = String(value ?? "");
+        return `"${text.replaceAll('"', '""')}"`;
+      }).join(","))).join("\n");
+      const blob = new Blob([csv], { type: "text/csv;charset=utf-8" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = "kis_collection_state.csv";
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      URL.revokeObjectURL(url);
+    }
+    reloadState().catch((error) => { document.getElementById("collectionSummary").textContent = error.message; });
+  </script>
+</body>
+</html>
+"""
+
+
+def render_tables_html() -> str:
+    return """<!doctype html>
+<html lang="ko">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Snapshot Admin — Table Browser</title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@tabler/core@1.0.0/dist/css/tabler.min.css">
+</head>
+<body>
+  <div class="page">
+    <header class="navbar navbar-expand-md navbar-dark d-print-none" data-bs-theme="dark">
+      <div class="container-xl">
+        <h1 class="navbar-brand">Snapshot Admin — Table Browser</h1>
+        <div class="navbar-nav flex-row">
+          <a class="btn btn-outline-light btn-sm me-2" href="/">Workspace editor</a>
+          <a class="btn btn-outline-light btn-sm" href="/collection">Collection dashboard</a>
+        </div>
+      </div>
+    </header>
+    <div class="page-wrapper">
+      <div class="page-body">
+        <div class="container-xl">
+          <div class="card">
+            <div class="card-header d-flex flex-wrap gap-2 align-items-center justify-content-between">
+              <div class="d-flex gap-2 align-items-center">
+                <label class="form-label mb-0 me-1" for="tableSelect">Table</label>
+                <select id="tableSelect" class="form-select" style="min-width:280px" onchange="onTableChange()"></select>
+                <span class="badge bg-secondary-lt" id="tableMeta"></span>
+              </div>
+              <div class="d-flex gap-2">
+                <button class="btn btn-sm" onclick="prevPage()">&laquo; Prev</button>
+                <span class="d-flex align-items-center px-2" id="pageInfo"></span>
+                <button class="btn btn-sm" onclick="nextPage()">Next &raquo;</button>
+                <button class="btn btn-sm btn-primary" onclick="reload()">Refresh</button>
+              </div>
+            </div>
+            <div class="table-responsive">
+              <table class="table table-vcenter card-table table-striped" id="gridTable">
+                <thead><tr id="gridHead"></tr></thead>
+                <tbody id="gridBody"></tbody>
+              </table>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </div>
+  <script>
+    const state = { tables: [], current: "", limit: 50, offset: 0, total: 0 };
+
+    function escapeHtml(value) {
+      if (value === null || value === undefined) return "";
+      const text = typeof value === "object" ? JSON.stringify(value) : String(value);
+      return text.replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[ch]));
+    }
+
+    async function loadTables() {
+      const res = await fetch("/api/tables");
+      const data = await res.json();
+      state.tables = data.tables || [];
+      const select = document.getElementById("tableSelect");
+      select.innerHTML = state.tables
+        .map((t) => `<option value="${t.table}" ${!t.exists ? "disabled" : ""}>${t.table} (${t.exists ? t.row_count : "no db"})</option>`)
+        .join("");
+      if (!state.current && state.tables.length) {
+        state.current = state.tables.find((t) => t.exists)?.table || state.tables[0].table;
+      }
+      select.value = state.current;
+      await loadRows();
+    }
+
+    function onTableChange() {
+      state.current = document.getElementById("tableSelect").value;
+      state.offset = 0;
+      loadRows();
+    }
+
+    async function loadRows() {
+      if (!state.current) return;
+      const params = new URLSearchParams({ table: state.current, limit: state.limit, offset: state.offset });
+      const res = await fetch(`/api/table_rows?${params.toString()}`);
+      const data = await res.json();
+      state.total = data.total || 0;
+      const head = document.getElementById("gridHead");
+      const body = document.getElementById("gridBody");
+      head.innerHTML = (data.columns || []).map((c) => `<th>${escapeHtml(c)}</th>`).join("");
+      body.innerHTML = (data.rows || [])
+        .map((row) => `<tr>${(data.columns || []).map((c) => `<td>${escapeHtml(row[c])}</td>`).join("")}</tr>`)
+        .join("") || `<tr><td colspan="99" class="text-secondary">no rows</td></tr>`;
+      document.getElementById("tableMeta").textContent = `${data.db || ""}`;
+      const from = state.total === 0 ? 0 : state.offset + 1;
+      const to = Math.min(state.offset + state.limit, state.total);
+      document.getElementById("pageInfo").textContent = `${from}-${to} / ${state.total}`;
+    }
+
+    function prevPage() {
+      state.offset = Math.max(0, state.offset - state.limit);
+      loadRows();
+    }
+
+    function nextPage() {
+      if (state.offset + state.limit < state.total) {
+        state.offset += state.limit;
+        loadRows();
+      }
+    }
+
+    function reload() {
+      loadRows();
+    }
+
+    loadTables().catch((error) => {
+      document.getElementById("gridBody").innerHTML = `<tr><td class="text-danger">${escapeHtml(error.message)}</td></tr>`;
+    });
+  </script>
+</body>
+</html>
+"""
+
+
+class SnapshotAdminHandler(BaseHTTPRequestHandler):
+    db_path: Path = DEFAULT_DB
+    seed_json_path: Path = DEFAULT_SEED_JSON
+
+    def log_message(self, format: str, *args: Any) -> None:  # noqa: A003
+        return
+
+    def _handle_exception(self, exc: Exception) -> None:
+        _json_response(self, HTTPStatus.INTERNAL_SERVER_ERROR, {"detail": str(exc)})
+
+    def do_GET(self) -> None:  # noqa: N802
+        parsed = urlparse(self.path)
+        if parsed.path == "/":
+            _text_response(self, HTTPStatus.OK, render_index_html(), "text/html; charset=utf-8")
+            return
+        if parsed.path == "/collection":
+            _text_response(self, HTTPStatus.OK, render_collection_html(), "text/html; charset=utf-8")
+            return
+        if parsed.path == "/tables":
+            _text_response(self, HTTPStatus.OK, render_tables_html(), "text/html; charset=utf-8")
+            return
+        if parsed.path == "/api/tables":
+            _json_response(self, HTTPStatus.OK, {"tables": list_browsable_tables(self.db_path)})
+            return
+        if parsed.path == "/api/table_rows":
+            query = parse_qs(parsed.query)
+            table = (query.get("table") or [""])[0]
+            try:
+                limit = int((query.get("limit") or ["50"])[0])
+                offset = int((query.get("offset") or ["0"])[0])
+            except ValueError:
+                _json_response(self, HTTPStatus.BAD_REQUEST, {"detail": "limit/offset must be integers"})
+                return
+            limit = min(max(limit, 1), 500)
+            offset = max(offset, 0)
+            try:
+                payload = fetch_table_rows(table, self.db_path, limit=limit, offset=offset)
+            except ValueError as exc:
+                _json_response(self, HTTPStatus.BAD_REQUEST, {"detail": str(exc)})
+                return
+            _json_response(self, HTTPStatus.OK, payload)
+            return
+        if parsed.path == "/api/state":
+            _json_response(self, HTTPStatus.OK, build_ui_state(self.db_path))
+            return
+        if parsed.path == "/api/history":
+            _json_response(
+                self,
+                HTTPStatus.OK,
+                {
+                    "settings": load_change_log_rows(self.db_path, limit=25),
+                    "approvals": load_approval_rows(self.db_path),
+                    "locks": load_locks(self.db_path),
+                },
+            )
+            return
+        if parsed.path == "/api/export":
+            _text_response(
+                self,
+                HTTPStatus.OK,
+                json.dumps(export_payload(self.db_path), ensure_ascii=False, indent=2),
+                "application/json; charset=utf-8",
+            )
+            return
+        if parsed.path == "/favicon.ico":
+            _text_response(self, HTTPStatus.NO_CONTENT, "")
+            return
+        _json_response(self, HTTPStatus.NOT_FOUND, {"detail": "not found"})
+
+    def do_POST(self) -> None:  # noqa: N802
+        parsed = urlparse(self.path)
+        try:
+            if parsed.path == "/api/bootstrap":
+                summary = import_seed_json(self.db_path, self.seed_json_path)
+                _json_response(self, HTTPStatus.OK, summary)
+                return
+            payload = _read_json_body(self)
+            if parsed.path == "/api/settings/save":
+                if is_locked(self.db_path, "settings"):
+                    raise ValueError("settings are locked")
+                rows = payload.get("rows")
+                if not isinstance(rows, list):
+                    raise ValueError("rows must be a list")
+                normalized_rows = []
+                for idx, row in enumerate(rows, start=1):
+                    if not isinstance(row, dict):
+                        continue
+                    key = str(row.get("key") or "").strip()
+                    if not key:
+                        continue
+                    normalized_rows.append(
+                        {
+                            "ordinal": idx,
+                            "key": key,
+                            "value": row.get("value", ""),
+                            "note": str(row.get("note") or ""),
+                        }
+                    )
+                conflicts = lock_conflicts_for_rows(self.db_path, "settings", normalized_rows)
+                if conflicts:
+                    refs = ", ".join(sorted({str(item.get("target_ref") or "") for item in conflicts if item.get("target_ref")}))
+                    raise ValueError(f"settings lock conflict: {refs}")
+                with open_connection(self.db_path) as conn:
+                    replace_settings(conn, normalized_rows)
+                _json_response(self, HTTPStatus.OK, summarize_workspace(self.db_path))
+                return
+            if parsed.path == "/api/account_snapshot/save":
+                if is_locked(self.db_path, "account_snapshot"):
+                    raise ValueError("account_snapshot is locked")
+                rows = payload.get("rows")
+                if not isinstance(rows, list):
+                    raise ValueError("rows must be a list")
+                normalized_rows: list[dict[str, Any]] = []
+                for idx, row in enumerate(rows, start=1):
+                    if not isinstance(row, dict):
+                        continue
+                    candidate = {key: value for key, value in row.items() if not key.startswith("_")}
+                    candidate["ordinal"] = idx
+                    normalized_rows.append(candidate)
+                conflicts = lock_conflicts_for_rows(self.db_path, "account_snapshot", normalized_rows)
+                if conflicts:
+                    refs = ", ".join(sorted({str(item.get("target_ref") or "") for item in conflicts if item.get("target_ref")}))
+                    raise ValueError(f"account_snapshot lock conflict: {refs}")
+                with open_connection(self.db_path) as conn:
+                    replace_account_snapshot(conn, normalized_rows)
+                _json_response(self, HTTPStatus.OK, summarize_workspace(self.db_path))
+                return
+            if parsed.path == "/api/account_snapshot/import_tsv":
+                if is_locked(self.db_path, "account_snapshot"):
+                    raise ValueError("account_snapshot is locked")
+                tsv_text = str(payload.get("tsv") or "")
+                rows = parse_account_snapshot_tsv(tsv_text)
+                with open_connection(self.db_path) as conn:
+                    replace_account_snapshot(conn, rows)
+                _json_response(self, HTTPStatus.OK, summarize_workspace(self.db_path))
+                return
+            if parsed.path == "/api/approval_packet":
+                packet = payload.get("packet")
+                if not isinstance(packet, dict):
+                    raise ValueError("packet must be an object")
+                artifacts = write_approval_packet_artifacts(packet)
+                response = {
+                    "gate": "PASS",
+                    "packet_path": artifacts["json_path"],
+                    "md_path": artifacts["md_path"],
+                    "formula_id": packet.get("formula_id", "SNAPSHOT_ADMIN_APPROVAL_PACKET_V1"),
+                }
+                _json_response(self, HTTPStatus.OK, response)
+                return
+            if parsed.path == "/api/approve":
+                domain = str(payload.get("domain") or "")
+                if domain not in {"settings", "account_snapshot"}:
+                    raise ValueError("domain must be settings or account_snapshot")
+                target_ref = str(payload.get("target_ref") or "*")
+                with open_connection(self.db_path) as conn:
+                    before = _approval_entry_from_conn(conn, domain, target_ref)
+                    set_approval(conn, domain, "APPROVED", target_ref=target_ref, approved_by="ui", note="manual approval")
+                    after = _approval_entry_from_conn(conn, domain, target_ref)
+                    record_change_log(
+                        conn,
+                        domain=domain,
+                        action="approve",
+                        target_ref=target_ref,
+                        before_json=before,
+                        after_json=after,
+                        actor="ui",
+                        note="manual approval",
+                    )
+                    conn.commit()
+                _json_response(self, HTTPStatus.OK, {"domain": domain, "target_ref": target_ref, "status": "APPROVED"})
+                return
+            if parsed.path == "/api/lock":
+                domain = str(payload.get("domain") or "")
+                target_ref = str(payload.get("target_ref") or "*")
+                if domain not in {"settings", "account_snapshot"}:
+                    raise ValueError("domain must be settings or account_snapshot")
+                with open_connection(self.db_path) as conn:
+                    before = _lock_entry_from_conn(conn, domain, target_ref)
+                    set_lock(conn, domain, target_ref, locked_by="ui", reason="manual lock")
+                    after = _lock_entry_from_conn(conn, domain, target_ref)
+                    record_change_log(
+                        conn,
+                        domain=domain,
+                        action="lock",
+                        target_ref=target_ref,
+                        before_json=before,
+                        after_json=after,
+                        actor="ui",
+                        note="manual lock",
+                    )
+                    conn.commit()
+                _json_response(self, HTTPStatus.OK, {"domain": domain, "target_ref": target_ref, "status": "LOCKED"})
+                return
+            if parsed.path == "/api/unlock":
+                domain = str(payload.get("domain") or "")
+                target_ref = str(payload.get("target_ref") or "*")
+                if domain not in {"settings", "account_snapshot"}:
+                    raise ValueError("domain must be settings or account_snapshot")
+                with open_connection(self.db_path) as conn:
+                    before = _lock_entry_from_conn(conn, domain, target_ref)
+                    clear_lock(conn, domain, target_ref)
+                    after = _lock_entry_from_conn(conn, domain, target_ref)
+                    record_change_log(
+                        conn,
+                        domain=domain,
+                        action="unlock",
+                        target_ref=target_ref,
+                        before_json=before,
+                        after_json=after,
+                        actor="ui",
+                        note="manual unlock",
+                    )
+                    conn.commit()
+                _json_response(self, HTTPStatus.OK, {"domain": domain, "target_ref": target_ref, "status": "UNLOCKED"})
+                return
+            if parsed.path == "/api/undo":
+                domain = str(payload.get("domain") or "")
+                if domain not in {"settings", "account_snapshot"}:
+                    raise ValueError("domain must be settings or account_snapshot")
+                if is_locked(self.db_path, domain):
+                    raise ValueError(f"{domain} is locked")
+                with open_connection(self.db_path) as conn:
+                    result = undo_last_change(conn, domain, actor="ui")
+                _json_response(self, HTTPStatus.OK, result if result else {"domain": domain, "status": "UNDONE"})
+                return
+            if parsed.path == "/api/autofix":
+                action_id = str(payload.get("action_id") or "")
+                if not action_id:
+                    raise ValueError("action_id required")
+                with open_connection(self.db_path) as conn:
+                    result = apply_safe_autofix_action(conn, action_id, actor="ui")
+                _json_response(self, HTTPStatus.OK, result)
+                return
+            _json_response(self, HTTPStatus.NOT_FOUND, {"detail": "not found"})
+        except Exception as exc:  # noqa: BLE001
+            self._handle_exception(exc)
+
+
+def serve(host: str, port: int, db_path: Path | str | None = None, seed_json_path: Path | str | None = None, bootstrap: bool = True) -> None:
+    db = normalize_db_path(db_path)
+    seed = Path(seed_json_path) if seed_json_path else DEFAULT_SEED_JSON
+    if bootstrap and seed.exists():
+        with open_connection(db) as conn:
+            from .snapshot_admin_store_v1 import ensure_schema
+
+            ensure_schema(conn)
+        if summarize_workspace(db)["settings_rows"] == 0 and summarize_workspace(db)["account_snapshot_rows"] == 0:
+            import_seed_json(db, seed)
+    SnapshotAdminHandler.db_path = db
+    SnapshotAdminHandler.seed_json_path = seed
+    server = ThreadingHTTPServer((host, port), SnapshotAdminHandler)
+    print(f"Snapshot Admin listening on http://{host}:{port}")
+    print(f"SQLite DB: {db}")
+    print(f"Seed JSON: {seed}")
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        server.server_close()
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run the snapshot admin web server.")
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8787)
+    parser.add_argument("--db", type=Path, default=DEFAULT_DB)
+    parser.add_argument("--seed", type=Path, default=DEFAULT_SEED_JSON)
+    parser.add_argument("--no-bootstrap", action="store_true")
+    args = parser.parse_args()
+    serve(args.host, args.port, args.db, args.seed, bootstrap=not args.no_bootstrap)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/src/quant_engine/snapshot_admin_store_v1.py b/src/quant_engine/snapshot_admin_store_v1.py
new file mode 100644
index 0000000..4b40b0f
--- /dev/null
+++ b/src/quant_engine/snapshot_admin_store_v1.py
@@ -0,0 +1,993 @@
+from __future__ import annotations
+
+import json
+import re
+import sqlite3
+from datetime import datetime
+from functools import lru_cache
+from pathlib import Path
+from typing import Any
+from zoneinfo import ZoneInfo
+
+import yaml
+
+
+ROOT = Path(__file__).resolve().parents[2]
+DEFAULT_DB = ROOT / "outputs" / "snapshot_admin" / "snapshot_admin.db"
+DEFAULT_SEED_JSON = ROOT / "GatherTradingData.json"
+KST = ZoneInfo("Asia/Seoul")
+
+SETTINGS_TABLE = "settings"
+SNAPSHOT_TABLE = "account_snapshot"
+CHANGE_LOG_TABLE = "workspace_change_log"
+APPROVAL_TABLE = "workspace_approval_v2"
+LOCK_TABLE = "workspace_lock"
+
+ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS = [
+    "captured_at",
+    "account",
+    "account_type",
+    "ticker",
+    "name",
+    "holding_quantity",
+    "available_quantity",
+    "average_cost",
+    "total_cost",
+    "current_price",
+    "market_value",
+    "profit_loss",
+    "return_pct",
+    "immediate_cash",
+    "settlement_cash_d2",
+    "available_cash",
+    "open_order_amount",
+    "monthly_contribution_limit",
+    "monthly_contribution_used",
+    "parse_status",
+    "user_confirmed",
+    "stop_price",
+    "highest_price_since_entry",
+    "entry_date",
+    "entry_stage",
+    "position_type",
+    "last_updated",
+]
+
+ALLOWED_PARSE_STATUS = {
+    "CAPTURE_READ_OK",
+    "CAPTURE_READ_FAILED",
+    "CAPTURE_PROVIDED_BUT_NOT_HOLDINGS",
+    "NOT_PROVIDED",
+}
+
+SETTINGS_SPEC_PATH = ROOT / "spec" / "18_settings_contract.yaml"
+ACCOUNT_SNAPSHOT_SPEC_PATH = ROOT / "spec" / "15_account_snapshot_contract.yaml"
+
+
+def now_kst_iso() -> str:
+    return datetime.now(tz=KST).isoformat(timespec="seconds")
+
+
+def parse_scalar(value: str) -> Any:
+    text = value.strip()
+    if text == "":
+        return ""
+    if text.lower() in {"null", "none"}:
+        return None
+    if text.lower() in {"true", "false"}:
+        return text.lower() == "true"
+    try:
+        return json.loads(text)
+    except Exception:
+        return text
+
+
+def _json_dump(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False)
+
+
+def _json_load(text: str) -> Any:
+    try:
+        return json.loads(text)
+    except Exception:
+        return text
+
+
+def normalize_db_path(db_path: Path | str | None = None) -> Path:
+    path = Path(db_path) if db_path else DEFAULT_DB
+    path.parent.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def open_connection(db_path: Path | str | None = None) -> sqlite3.Connection:
+    conn = sqlite3.connect(normalize_db_path(db_path))
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA foreign_keys = ON")
+    conn.execute("PRAGMA journal_mode = WAL")
+    return conn
+
+
+def ensure_schema(conn: sqlite3.Connection) -> None:
+    conn.execute(
+        f"""
+        CREATE TABLE IF NOT EXISTS {SETTINGS_TABLE} (
+            ordinal INTEGER NOT NULL,
+            key TEXT PRIMARY KEY,
+            value_json TEXT NOT NULL,
+            note TEXT NOT NULL DEFAULT '',
+            updated_at TEXT NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        f"""
+        CREATE TABLE IF NOT EXISTS {SNAPSHOT_TABLE} (
+            ordinal INTEGER NOT NULL,
+            row_json TEXT NOT NULL,
+            captured_at TEXT NOT NULL DEFAULT '',
+            account TEXT NOT NULL DEFAULT '',
+            account_type TEXT NOT NULL DEFAULT '',
+            ticker TEXT NOT NULL DEFAULT '',
+            name TEXT NOT NULL DEFAULT '',
+            parse_status TEXT NOT NULL DEFAULT '',
+            user_confirmed TEXT NOT NULL DEFAULT '',
+            updated_at TEXT NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        f"CREATE INDEX IF NOT EXISTS idx_{SNAPSHOT_TABLE}_captured_at ON {SNAPSHOT_TABLE}(captured_at)"
+    )
+    conn.execute(
+        f"CREATE INDEX IF NOT EXISTS idx_{SNAPSHOT_TABLE}_ticker ON {SNAPSHOT_TABLE}(ticker)"
+    )
+    conn.execute(
+        "CREATE TABLE IF NOT EXISTS workspace_meta (key TEXT PRIMARY KEY, value_json TEXT NOT NULL)"
+    )
+    conn.execute(
+        f"""
+        CREATE TABLE IF NOT EXISTS {CHANGE_LOG_TABLE} (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            domain TEXT NOT NULL,
+            action TEXT NOT NULL,
+            target_ref TEXT NOT NULL DEFAULT '',
+            actor TEXT NOT NULL DEFAULT 'system',
+            note TEXT NOT NULL DEFAULT '',
+            before_json TEXT NOT NULL DEFAULT 'null',
+            after_json TEXT NOT NULL DEFAULT 'null',
+            created_at TEXT NOT NULL
+        )
+        """
+    )
+    conn.execute(
+        f"""
+        CREATE TABLE IF NOT EXISTS {APPROVAL_TABLE} (
+            domain TEXT NOT NULL,
+            target_ref TEXT NOT NULL DEFAULT '*',
+            status TEXT NOT NULL,
+            approved_by TEXT NOT NULL DEFAULT '',
+            approved_at TEXT NOT NULL DEFAULT '',
+            note TEXT NOT NULL DEFAULT '',
+            updated_at TEXT NOT NULL,
+            PRIMARY KEY (domain, target_ref)
+        )
+        """
+    )
+    conn.execute(
+        f"""
+        CREATE TABLE IF NOT EXISTS {LOCK_TABLE} (
+            domain TEXT NOT NULL,
+            target_ref TEXT NOT NULL DEFAULT '',
+            locked_by TEXT NOT NULL DEFAULT '',
+            reason TEXT NOT NULL DEFAULT '',
+            locked_at TEXT NOT NULL,
+            PRIMARY KEY (domain, target_ref)
+        )
+        """
+    )
+    conn.commit()
+
+
+def _normalize_settings_rows(settings: Any) -> list[dict[str, Any]]:
+    if isinstance(settings, list):
+        rows: list[dict[str, Any]] = []
+        for idx, item in enumerate(settings, start=1):
+            if isinstance(item, dict) and "key" in item:
+                rows.append(
+                    {
+                        "ordinal": int(item.get("ordinal") or idx),
+                        "key": str(item.get("key") or ""),
+                        "value": item.get("value", ""),
+                        "note": str(item.get("note") or ""),
+                    }
+                )
+        return rows
+    if isinstance(settings, dict):
+        rows = []
+        for idx, (key, value) in enumerate(settings.items(), start=1):
+            rows.append({"ordinal": idx, "key": str(key), "value": value, "note": ""})
+        return rows
+    return []
+
+
+def _normalize_snapshot_rows(rows: Any) -> list[dict[str, Any]]:
+    if not isinstance(rows, list):
+        return []
+    normalized: list[dict[str, Any]] = []
+    for idx, item in enumerate(rows, start=1):
+        if isinstance(item, dict):
+            row = dict(item)
+            row.setdefault("ordinal", idx)
+            normalized.append(row)
+    return normalized
+
+
+def seed_payload_from_json(json_path: Path | str) -> dict[str, Any]:
+    payload = json.loads(Path(json_path).read_text(encoding="utf-8"))
+    data = payload.get("data") if isinstance(payload, dict) else None
+    if not isinstance(data, dict):
+        data = payload if isinstance(payload, dict) else {}
+    settings = _normalize_settings_rows(data.get("settings"))
+    account_snapshot = _normalize_snapshot_rows(data.get("account_snapshot"))
+    return {
+        "meta": payload.get("meta") if isinstance(payload, dict) else {},
+        "settings": settings,
+        "account_snapshot": account_snapshot,
+    }
+
+
+def replace_settings(conn: sqlite3.Connection, rows: list[dict[str, Any]]) -> None:
+    ensure_schema(conn)
+    errors = validate_settings_rows(rows)
+    if errors:
+        raise ValueError("; ".join(errors))
+    old_rows = load_settings_rows_from_conn(conn)
+    conn.execute(f"DELETE FROM {SETTINGS_TABLE}")
+    for idx, row in enumerate(rows, start=1):
+        key = str(row.get("key") or "").strip()
+        if not key:
+            continue
+        conn.execute(
+            f"""
+            INSERT INTO {SETTINGS_TABLE} (ordinal, key, value_json, note, updated_at)
+            VALUES (?, ?, ?, ?, ?)
+            """,
+            (
+                int(row.get("ordinal") or idx),
+                key,
+                _json_dump(row.get("value", "")),
+                str(row.get("note") or ""),
+                now_kst_iso(),
+            ),
+        )
+    record_change_log(
+        conn,
+        domain=SETTINGS_TABLE,
+        action="replace",
+        before_json=old_rows,
+        after_json=rows,
+        target_ref="*",
+        note="settings replace",
+    )
+    set_approval(conn, SETTINGS_TABLE, "PENDING", note="settings updated")
+    conn.commit()
+
+
+def replace_account_snapshot(conn: sqlite3.Connection, rows: list[dict[str, Any]]) -> None:
+    ensure_schema(conn)
+    errors = validate_account_snapshot_rows(rows)
+    if errors:
+        raise ValueError("; ".join(errors))
+    old_rows = load_account_snapshot_rows_from_conn(conn)
+    conn.execute(f"DELETE FROM {SNAPSHOT_TABLE}")
+    for idx, row in enumerate(rows, start=1):
+        normalized = dict(row)
+        ordinal = int(normalized.pop("ordinal", idx) or idx)
+        captured_at = str(normalized.get("captured_at") or "")
+        account = str(normalized.get("account") or "")
+        account_type = str(normalized.get("account_type") or "")
+        ticker = str(normalized.get("ticker") or "")
+        name = str(normalized.get("name") or "")
+        parse_status = str(normalized.get("parse_status") or "")
+        user_confirmed = str(normalized.get("user_confirmed") or "")
+        conn.execute(
+            f"""
+            INSERT INTO {SNAPSHOT_TABLE} (
+                ordinal, row_json, captured_at, account, account_type, ticker, name,
+                parse_status, user_confirmed, updated_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                ordinal,
+                _json_dump(normalized),
+                captured_at,
+                account,
+                account_type,
+                ticker,
+                name,
+                parse_status,
+                user_confirmed,
+                now_kst_iso(),
+            ),
+        )
+    record_change_log(
+        conn,
+        domain=SNAPSHOT_TABLE,
+        action="replace",
+        before_json=old_rows,
+        after_json=rows,
+        target_ref="*",
+        note="account_snapshot replace",
+    )
+    set_approval(conn, SNAPSHOT_TABLE, "PENDING", note="account_snapshot updated")
+    conn.commit()
+
+
+def import_seed_json(db_path: Path | str | None, json_path: Path | str) -> dict[str, Any]:
+    payload = seed_payload_from_json(json_path)
+    with open_connection(db_path) as conn:
+        replace_settings(conn, payload["settings"])
+        replace_account_snapshot(conn, payload["account_snapshot"])
+        conn.execute(
+            "INSERT OR REPLACE INTO workspace_meta(key, value_json) VALUES (?, ?)",
+            ("seed_json_path", _json_dump(str(Path(json_path).resolve()))),
+        )
+        conn.execute(
+            "INSERT OR REPLACE INTO workspace_meta(key, value_json) VALUES (?, ?)",
+            ("seeded_at", _json_dump(now_kst_iso())),
+        )
+        conn.commit()
+    return summarize_workspace(db_path)
+
+
+def load_settings_rows(db_path: Path | str | None = None) -> list[dict[str, Any]]:
+    with open_connection(db_path) as conn:
+        return load_settings_rows_from_conn(conn)
+
+
+def load_settings_rows_from_conn(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    ensure_schema(conn)
+    rows = conn.execute(
+        f"SELECT ordinal, key, value_json, note, updated_at FROM {SETTINGS_TABLE} ORDER BY ordinal ASC, key ASC"
+    ).fetchall()
+    return [
+        {
+            "ordinal": int(row["ordinal"]),
+            "key": row["key"],
+            "value": _json_load(row["value_json"]),
+            "note": row["note"],
+            "updated_at": row["updated_at"],
+        }
+        for row in rows
+    ]
+
+
+def load_account_snapshot_rows(db_path: Path | str | None = None) -> list[dict[str, Any]]:
+    with open_connection(db_path) as conn:
+        return load_account_snapshot_rows_from_conn(conn)
+
+
+def load_account_snapshot_rows_from_conn(conn: sqlite3.Connection) -> list[dict[str, Any]]:
+    ensure_schema(conn)
+    rows = conn.execute(
+        f"""
+        SELECT ordinal, row_json, captured_at, account, account_type, ticker, name,
+               parse_status, user_confirmed, updated_at
+        FROM {SNAPSHOT_TABLE}
+        ORDER BY ordinal ASC
+        """
+    ).fetchall()
+    loaded: list[dict[str, Any]] = []
+    for row in rows:
+        payload = _json_load(row["row_json"])
+        item = payload if isinstance(payload, dict) else {}
+        item.setdefault("captured_at", row["captured_at"])
+        item.setdefault("account", row["account"])
+        item.setdefault("account_type", row["account_type"])
+        item.setdefault("ticker", row["ticker"])
+        item.setdefault("name", row["name"])
+        item.setdefault("parse_status", row["parse_status"])
+        item.setdefault("user_confirmed", row["user_confirmed"])
+        item["_ordinal"] = int(row["ordinal"])
+        item["_updated_at"] = row["updated_at"]
+        loaded.append(item)
+    return loaded
+
+
+def export_payload(db_path: Path | str | None = None) -> dict[str, Any]:
+    settings_rows = load_settings_rows(db_path)
+    settings = {row["key"]: row["value"] for row in settings_rows}
+    account_snapshot = load_account_snapshot_rows(db_path)
+    return {
+        "meta": {
+            "generated_at": now_kst_iso(),
+            "source_db": str(normalize_db_path(db_path)),
+        },
+        "data": {
+            "settings": settings,
+            "account_snapshot": account_snapshot,
+        },
+    }
+
+
+def write_export_json(db_path: Path | str | None, output_path: Path | str) -> Path:
+    payload = export_payload(db_path)
+    output = Path(output_path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    return output
+
+
+def load_meta(db_path: Path | str | None = None) -> dict[str, Any]:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        rows = conn.execute("SELECT key, value_json FROM workspace_meta ORDER BY key ASC").fetchall()
+    return {row["key"]: _json_load(row["value_json"]) for row in rows}
+
+
+def record_change_log(
+    conn: sqlite3.Connection,
+    *,
+    domain: str,
+    action: str,
+    before_json: Any,
+    after_json: Any,
+    target_ref: str = "",
+    actor: str = "ui",
+    note: str = "",
+) -> None:
+    ensure_schema(conn)
+    conn.execute(
+        f"""
+        INSERT INTO {CHANGE_LOG_TABLE} (
+            domain, action, target_ref, actor, note, before_json, after_json, created_at
+        )
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            domain,
+            action,
+            target_ref,
+            actor,
+            note,
+            _json_dump(before_json),
+            _json_dump(after_json),
+            now_kst_iso(),
+        ),
+    )
+
+
+def set_approval(
+    conn: sqlite3.Connection,
+    domain: str,
+    status: str,
+    *,
+    target_ref: str = "*",
+    approved_by: str = "",
+    note: str = "",
+) -> None:
+    ensure_schema(conn)
+    conn.execute(
+        f"""
+        INSERT INTO {APPROVAL_TABLE} (domain, target_ref, status, approved_by, approved_at, note, updated_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(domain, target_ref) DO UPDATE SET
+            status=excluded.status,
+            approved_by=excluded.approved_by,
+            approved_at=excluded.approved_at,
+            note=excluded.note,
+            updated_at=excluded.updated_at
+        """,
+        (
+            domain,
+            target_ref or "*",
+            status,
+            approved_by,
+            now_kst_iso() if status == "APPROVED" else "",
+            note,
+            now_kst_iso(),
+        ),
+    )
+
+
+def load_approval_rows(db_path: Path | str | None = None) -> list[dict[str, Any]]:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        rows = conn.execute(
+            f"SELECT domain, target_ref, status, approved_by, approved_at, note, updated_at FROM {APPROVAL_TABLE} ORDER BY domain ASC, target_ref ASC"
+        ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def load_approval_entry(db_path: Path | str | None, domain: str, target_ref: str = "*") -> dict[str, Any] | None:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        row = conn.execute(
+            f"""
+            SELECT domain, target_ref, status, approved_by, approved_at, note, updated_at
+            FROM {APPROVAL_TABLE}
+            WHERE domain = ? AND target_ref = ?
+            LIMIT 1
+            """,
+            (domain, target_ref or "*"),
+        ).fetchone()
+    return dict(row) if row is not None else None
+
+
+def load_change_log_rows(db_path: Path | str | None = None, limit: int = 20) -> list[dict[str, Any]]:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        rows = conn.execute(
+            f"""
+            SELECT id, domain, action, target_ref, actor, note, before_json, after_json, created_at
+            FROM {CHANGE_LOG_TABLE}
+            ORDER BY id DESC
+            LIMIT ?
+            """,
+            (int(limit),),
+        ).fetchall()
+    items = []
+    for row in rows:
+        items.append(
+            {
+                "id": int(row["id"]),
+                "domain": row["domain"],
+                "action": row["action"],
+                "target_ref": row["target_ref"],
+                "actor": row["actor"],
+                "note": row["note"],
+                "before_json": _json_load(row["before_json"]),
+                "after_json": _json_load(row["after_json"]),
+                "created_at": row["created_at"],
+            }
+        )
+    return items
+
+
+def load_last_change_row(conn: sqlite3.Connection, domain: str) -> dict[str, Any] | None:
+    ensure_schema(conn)
+    row = conn.execute(
+        f"""
+        SELECT id, domain, action, target_ref, actor, note, before_json, after_json, created_at
+        FROM {CHANGE_LOG_TABLE}
+        WHERE domain = ?
+        ORDER BY id DESC
+        LIMIT 1
+        """,
+        (domain,),
+    ).fetchone()
+    if row is None:
+        return None
+    return {
+        "id": int(row["id"]),
+        "domain": row["domain"],
+        "action": row["action"],
+        "target_ref": row["target_ref"],
+        "actor": row["actor"],
+        "note": row["note"],
+        "before_json": _json_load(row["before_json"]),
+        "after_json": _json_load(row["after_json"]),
+        "created_at": row["created_at"],
+    }
+
+
+def set_lock(conn: sqlite3.Connection, domain: str, target_ref: str, *, locked_by: str, reason: str) -> None:
+    ensure_schema(conn)
+    conn.execute(
+        f"""
+        INSERT INTO {LOCK_TABLE} (domain, target_ref, locked_by, reason, locked_at)
+        VALUES (?, ?, ?, ?, ?)
+        ON CONFLICT(domain, target_ref) DO UPDATE SET
+            locked_by=excluded.locked_by,
+            reason=excluded.reason,
+            locked_at=excluded.locked_at
+        """,
+        (domain, target_ref, locked_by, reason, now_kst_iso()),
+    )
+
+
+def clear_lock(conn: sqlite3.Connection, domain: str, target_ref: str) -> None:
+    ensure_schema(conn)
+    conn.execute(
+        f"DELETE FROM {LOCK_TABLE} WHERE domain = ? AND target_ref = ?",
+        (domain, target_ref),
+    )
+
+
+def load_locks(db_path: Path | str | None = None) -> list[dict[str, Any]]:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        rows = conn.execute(
+            f"SELECT domain, target_ref, locked_by, reason, locked_at FROM {LOCK_TABLE} ORDER BY domain ASC, target_ref ASC"
+        ).fetchall()
+    return [dict(row) for row in rows]
+
+
+def load_lock_entry(db_path: Path | str | None, domain: str, target_ref: str = "*") -> dict[str, Any] | None:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        row = conn.execute(
+            f"""
+            SELECT domain, target_ref, locked_by, reason, locked_at
+            FROM {LOCK_TABLE}
+            WHERE domain = ? AND target_ref = ?
+            LIMIT 1
+            """,
+            (domain, target_ref or "*"),
+        ).fetchone()
+    return dict(row) if row is not None else None
+
+
+def is_locked(db_path: Path | str | None, domain: str, target_ref: str = "*") -> bool:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        row = conn.execute(
+            f"SELECT 1 FROM {LOCK_TABLE} WHERE domain = ? AND target_ref IN (?, '*') LIMIT 1",
+            (domain, target_ref),
+        ).fetchone()
+    return row is not None
+
+
+def lock_conflicts_for_rows(
+    db_path: Path | str | None,
+    domain: str,
+    rows: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        locks = conn.execute(
+            f"SELECT domain, target_ref, locked_by, reason, locked_at FROM {LOCK_TABLE} WHERE domain = ? ORDER BY target_ref ASC",
+            (domain,),
+        ).fetchall()
+    if not locks:
+        return []
+    row_refs: list[str] = []
+    for idx, row in enumerate(rows, start=1):
+        if domain == SETTINGS_TABLE:
+            ref = str(row.get("_row_ref") or "").strip() or str(row.get("key") or "").strip()
+        elif domain == SNAPSHOT_TABLE:
+            ref = str(row.get("_row_ref") or "").strip()
+            if not ref:
+                ordinal = str(row.get("_ordinal") or row.get("ordinal") or idx).strip()
+                ref = f"row:{ordinal}"
+        else:
+            ref = str(row.get("target_ref") or "").strip()
+        if ref:
+            row_refs.append(ref)
+        if domain == SETTINGS_TABLE:
+            key = str(row.get("key") or "").strip()
+            if key:
+                row_refs.append(key)
+        if domain == SNAPSHOT_TABLE:
+            ticker = str(row.get("ticker") or "").strip()
+            if ticker:
+                row_refs.append(ticker)
+    conflicts: list[dict[str, Any]] = []
+    for lock in locks:
+        target_ref = str(lock["target_ref"] or "").strip()
+        if target_ref == "*" or target_ref in row_refs:
+            conflicts.append(dict(lock))
+    return conflicts
+
+
+def undo_last_change(conn: sqlite3.Connection, domain: str, *, actor: str = "ui") -> dict[str, Any]:
+    ensure_schema(conn)
+    last = load_last_change_row(conn, domain)
+    if not last:
+        raise ValueError(f"no change log for domain={domain}")
+    before_json = last.get("before_json")
+    if domain == SETTINGS_TABLE:
+        rows = before_json if isinstance(before_json, list) else []
+        replace_settings(conn, rows)
+    elif domain == SNAPSHOT_TABLE:
+        rows = before_json if isinstance(before_json, list) else []
+        replace_account_snapshot(conn, rows)
+    else:
+        raise ValueError(f"unsupported domain={domain}")
+    record_change_log(
+        conn,
+        domain=domain,
+        action="undo",
+        before_json=last.get("after_json"),
+        after_json=before_json,
+        target_ref=last.get("target_ref", "*"),
+        actor=actor,
+        note=f"undo change #{last['id']}",
+    )
+    conn.commit()
+    return load_last_change_row(conn, domain) or {}
+
+
+def load_approval_for_domain(db_path: Path | str | None, domain: str) -> dict[str, Any]:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        row = conn.execute(
+            f"""
+            SELECT domain, target_ref, status, approved_by, approved_at, note, updated_at
+            FROM {APPROVAL_TABLE}
+            WHERE domain = ? AND target_ref = '*'
+            """,
+            (domain,),
+        ).fetchone()
+    return (
+        dict(row)
+        if row
+        else {"domain": domain, "target_ref": "*", "status": "MISSING", "approved_by": "", "approved_at": "", "note": "", "updated_at": ""}
+    )
+
+
+def summarize_workspace(db_path: Path | str | None = None) -> dict[str, Any]:
+    with open_connection(db_path) as conn:
+        ensure_schema(conn)
+        settings_count = conn.execute(f"SELECT COUNT(*) FROM {SETTINGS_TABLE}").fetchone()[0]
+        snapshot_count = conn.execute(f"SELECT COUNT(*) FROM {SNAPSHOT_TABLE}").fetchone()[0]
+        latest_update = conn.execute(
+            f"""
+            SELECT MAX(updated_at)
+            FROM (
+                SELECT updated_at FROM {SETTINGS_TABLE}
+                UNION ALL
+                SELECT updated_at FROM {SNAPSHOT_TABLE}
+            )
+            """
+            ).fetchone()[0]
+        table_rows = conn.execute(
+            "SELECT name FROM sqlite_master WHERE type='table' AND name IN (?, ?, ?, ?, ?)",
+            (SETTINGS_TABLE, SNAPSHOT_TABLE, CHANGE_LOG_TABLE, APPROVAL_TABLE, LOCK_TABLE),
+        ).fetchall()
+    tables = sorted(row[0] for row in table_rows)
+    workspace_db = str(normalize_db_path(db_path))
+    return {
+        "db_path": workspace_db,
+        "settings_rows": int(settings_count),
+        "account_snapshot_rows": int(snapshot_count),
+        "latest_update": latest_update or "",
+        "tables": tables,
+        "topology": {
+            "mode": "single_workspace_sqlite",
+            "workspace_db": workspace_db,
+            "collector_db": str(ROOT / "outputs" / "kis_data_collection" / "kis_data_collection.db"),
+            "settings_and_snapshot_share_db": True,
+            "collector_separate_db": True,
+        },
+        "meta": load_meta(db_path),
+    }
+
+
+def parse_account_snapshot_tsv(tsv_text: str) -> list[dict[str, Any]]:
+    lines = [line.rstrip("\r") for line in tsv_text.splitlines() if line.strip() != ""]
+    if not lines:
+        return []
+    rows: list[list[str]] = [line.split("\t") for line in lines]
+    first_row = rows[0]
+    if first_row == ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS:
+        data_rows = rows[1:]
+    elif set(first_row) >= {"captured_at", "account", "ticker"}:
+        header = first_row
+        data_rows = rows[1:]
+        converted: list[dict[str, Any]] = []
+        for idx, row in enumerate(data_rows, start=1):
+            item: dict[str, Any] = {"ordinal": idx}
+            for col_index, column in enumerate(header):
+                value = row[col_index] if col_index < len(row) else ""
+                item[column] = parse_scalar(value)
+            converted.append(item)
+        return converted
+    else:
+        data_rows = rows
+    converted = []
+    for idx, row in enumerate(data_rows, start=1):
+        item: dict[str, Any] = {"ordinal": idx}
+        for col_index, column in enumerate(ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS):
+            value = row[col_index] if col_index < len(row) else ""
+            item[column] = parse_scalar(value)
+        converted.append(item)
+    return converted
+
+
+def settings_rows_to_dict(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for row in rows:
+        key = str(row.get("key") or "").strip()
+        if key:
+            result[key] = row.get("value", "")
+    return result
+
+
+def _as_number(value: Any) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        return float(text)
+    except Exception:
+        return None
+
+
+@lru_cache(maxsize=1)
+def _load_settings_spec() -> dict[str, Any]:
+    return yaml.safe_load(SETTINGS_SPEC_PATH.read_text(encoding="utf-8")) or {}
+
+
+@lru_cache(maxsize=1)
+def _load_account_snapshot_spec() -> dict[str, Any]:
+    return yaml.safe_load(ACCOUNT_SNAPSHOT_SPEC_PATH.read_text(encoding="utf-8")) or {}
+
+
+def validate_settings_rows(rows: list[dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    spec = _load_settings_spec().get("required_keys") or {}
+    optional_spec = _load_settings_spec().get("optional_keys") or {}
+    seen: set[str] = set()
+    total_asset_found = False
+    for idx, row in enumerate(rows, start=1):
+        key = str(row.get("key") or "").strip()
+        if not key:
+            errors.append(f"settings row {idx}: missing key")
+            continue
+        if key in seen:
+            errors.append(f"settings row {idx}: duplicate key {key}")
+        seen.add(key)
+        value = row.get("value", "")
+        if key == "total_asset_krw":
+            total_asset_found = True
+            amount = _as_number(value)
+            if amount is None or amount <= 0:
+                errors.append("settings.total_asset_krw must be positive number")
+        if key in {"weekly_target_cash_pct", "fc_budget_pct_override"}:
+            pct = _as_number(value)
+            if pct is None or pct < 0:
+                errors.append(f"settings.{key} must be non-negative number")
+        if key in spec and spec[key].get("type") == "string":
+            if value is not None and not isinstance(value, str):
+                errors.append(f"settings.{key} must be string")
+        if key in optional_spec and optional_spec[key].get("format") == "YYYY-MM":
+            text = str(value).strip()
+            if text and not re.fullmatch(r"\d{4}-\d{2}(-.*)?", text):
+                errors.append(f"settings.{key} must use YYYY-MM")
+    if not total_asset_found:
+        errors.append("settings.total_asset_krw is required")
+    return errors
+
+
+def validate_account_snapshot_rows(rows: list[dict[str, Any]]) -> list[str]:
+    errors: list[str] = []
+    spec = _load_account_snapshot_spec().get("account_snapshot_contract") or {}
+    canonical = spec.get("canonical_fields") or {}
+    for idx, row in enumerate(rows, start=1):
+        captured_at = str(row.get("captured_at") or "").strip()
+        account = str(row.get("account") or "").strip()
+        ticker = str(row.get("ticker") or "").strip()
+        name = str(row.get("name") or "").strip()
+        account_type = str(row.get("account_type") or "").strip()
+        parse_status = str(row.get("parse_status") or "").strip()
+        holding_quantity = _as_number(row.get("holding_quantity"))
+        average_cost = _as_number(row.get("average_cost"))
+        stop_price = _as_number(row.get("stop_price"))
+        entry_stage = str(row.get("entry_stage") or "").strip()
+        position_type = str(row.get("position_type") or "").strip()
+        user_confirmed = str(row.get("user_confirmed") or "").strip().upper()
+        if not captured_at:
+            errors.append(f"account_snapshot row {idx}: captured_at required")
+        if not account:
+            errors.append(f"account_snapshot row {idx}: account required")
+        if not account_type:
+            errors.append(f"account_snapshot row {idx}: account_type required")
+        if account_type and canonical.get("account_type", {}).get("allowed") and account_type not in canonical["account_type"]["allowed"]:
+            errors.append(f"account_snapshot row {idx}: invalid account_type {account_type!r}")
+        if not ticker:
+            errors.append(f"account_snapshot row {idx}: ticker required")
+        if not name:
+            errors.append(f"account_snapshot row {idx}: name required")
+        if parse_status not in ALLOWED_PARSE_STATUS:
+            errors.append(f"account_snapshot row {idx}: invalid parse_status {parse_status!r}")
+        if holding_quantity is not None and holding_quantity < 0:
+            errors.append(f"account_snapshot row {idx}: holding_quantity must be >= 0")
+        if average_cost is not None and average_cost < 0:
+            errors.append(f"account_snapshot row {idx}: average_cost must be >= 0")
+        if user_confirmed and user_confirmed not in {"Y", "N"}:
+            errors.append(f"account_snapshot row {idx}: user_confirmed must be Y or N")
+        if parse_status == "CAPTURE_READ_OK" and user_confirmed != "Y":
+            errors.append(f"account_snapshot row {idx}: CAPTURE_READ_OK rows require user_confirmed=Y")
+        if entry_stage and canonical.get("entry_stage", {}).get("allowed") and entry_stage not in canonical["entry_stage"]["allowed"]:
+            errors.append(f"account_snapshot row {idx}: invalid entry_stage {entry_stage!r}")
+        if position_type and canonical.get("position_type", {}).get("allowed") and position_type not in canonical["position_type"]["allowed"]:
+            errors.append(f"account_snapshot row {idx}: invalid position_type {position_type!r}")
+    return errors
+
+
+def build_validation_suggestions(settings_rows: list[dict[str, Any]], snapshot_rows: list[dict[str, Any]]) -> list[str]:
+    suggestions: list[str] = []
+    settings_map = settings_rows_to_dict(settings_rows)
+    snapshot_count = len(snapshot_rows)
+    if "total_asset_krw" not in settings_map:
+        suggestions.append("settings: add total_asset_krw from current investable asset total")
+    if str(settings_map.get("weekly_target_cash_pct", "")).strip() == "":
+        suggestions.append("settings: weekly_target_cash_pct can stay blank unless weekly rebalance is active")
+    for row in snapshot_rows:
+        if str(row.get("parse_status") or "").strip() == "CAPTURE_READ_OK" and str(row.get("user_confirmed") or "").strip().upper() != "Y":
+            suggestions.append(
+                f"account_snapshot {row.get('ticker') or row.get('name') or 'row'}: set user_confirmed=Y for CAPTURE_READ_OK"
+            )
+        account_type = str(row.get("account_type") or "").strip()
+        if account_type and account_type not in {"일반계좌", "ISA", "연금저축"}:
+            suggestions.append(
+                f"account_snapshot {row.get('ticker') or row.get('name') or 'row'}: account_type should be one of 일반계좌/ISA/연금저축"
+            )
+        if str(row.get("entry_stage") or "").strip() and str(row.get("position_type") or "").strip() == "":
+            suggestions.append(
+                f"account_snapshot {row.get('ticker') or row.get('name') or 'row'}: consider setting position_type when entry_stage is present"
+            )
+    if not snapshot_rows:
+        suggestions.append("account_snapshot: import TSV from HTS capture before saving snapshot")
+    return suggestions[:20]
+
+
+def build_safe_autofix_actions(settings_rows: list[dict[str, Any]], snapshot_rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    actions: list[dict[str, Any]] = []
+    if any(str(row.get("parse_status") or "").strip() == "CAPTURE_READ_OK" and str(row.get("user_confirmed") or "").strip().upper() != "Y" for row in snapshot_rows):
+        actions.append(
+            {
+                "action_id": "confirm_captured_rows",
+                "domain": "account_snapshot",
+                "label": "Set user_confirmed=Y for CAPTURE_READ_OK rows",
+                "description": "Safe autofix using the contract default confirmation flag.",
+            }
+        )
+    if any(str(row.get("position_type") or "").strip() == "" and str(row.get("entry_stage") or "").strip() for row in snapshot_rows):
+        actions.append(
+            {
+                "action_id": "default_position_type_satellite",
+                "domain": "account_snapshot",
+                "label": "Default blank position_type to satellite",
+                "description": "Uses the contract default when position_type is missing.",
+            }
+        )
+    if not any(str(row.get("key") or "").strip() == "total_asset_krw" for row in settings_rows):
+        actions.append(
+            {
+                "action_id": "required_total_asset_missing",
+                "domain": "settings",
+                "label": "Settings total_asset_krw missing",
+                "description": "Manual input required. No safe autofix.",
+            }
+        )
+    return actions
+
+
+def apply_safe_autofix_action(
+    conn: sqlite3.Connection,
+    action_id: str,
+    *,
+    actor: str = "ui",
+) -> dict[str, Any]:
+    ensure_schema(conn)
+    snapshot_rows = load_account_snapshot_rows_from_conn(conn)
+    if action_id == "confirm_captured_rows":
+        updated = []
+        for row in snapshot_rows:
+            candidate = dict(row)
+            if str(candidate.get("parse_status") or "").strip() == "CAPTURE_READ_OK" and str(candidate.get("user_confirmed") or "").strip().upper() != "Y":
+                candidate["user_confirmed"] = "Y"
+            updated.append(candidate)
+        replace_account_snapshot(conn, updated)
+        return {"domain": SNAPSHOT_TABLE, "status": "AUTOFIXED", "action_id": action_id}
+    if action_id == "default_position_type_satellite":
+        updated = []
+        for row in snapshot_rows:
+            candidate = dict(row)
+            if str(candidate.get("entry_stage") or "").strip() and str(candidate.get("position_type") or "").strip() == "":
+                candidate["position_type"] = "satellite"
+            updated.append(candidate)
+        replace_account_snapshot(conn, updated)
+        return {"domain": SNAPSHOT_TABLE, "status": "AUTOFIXED", "action_id": action_id}
+    if action_id == "required_total_asset_missing":
+        return {"domain": SETTINGS_TABLE, "status": "MANUAL_REQUIRED", "action_id": action_id}
+    raise ValueError(f"unknown action_id={action_id}")
diff --git a/tests/unit/test_snapshot_admin_store_v1.py b/tests/unit/test_snapshot_admin_store_v1.py
new file mode 100644
index 0000000..52bc790
--- /dev/null
+++ b/tests/unit/test_snapshot_admin_store_v1.py
@@ -0,0 +1,249 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from src.quant_engine.snapshot_admin_server_v1 import build_ui_state
+from src.quant_engine.snapshot_admin_store_v1 import (
+    ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS,
+    export_payload,
+    import_seed_json,
+    load_approval_for_domain,
+    load_change_log_rows,
+    load_locks,
+    load_account_snapshot_rows,
+    load_settings_rows,
+    parse_account_snapshot_tsv,
+    open_connection,
+    lock_conflicts_for_rows,
+    validate_account_snapshot_rows,
+    validate_settings_rows,
+    build_validation_suggestions,
+    build_safe_autofix_actions,
+    apply_safe_autofix_action,
+    set_lock,
+    undo_last_change,
+    write_export_json,
+)
+
+
+def _seed_json(path: Path) -> None:
+    payload = {
+        "data": {
+            "settings": {
+                "total_asset_krw": 150000000,
+                "weekly_target_cash_pct": 14,
+                "orbit_start_yyyymm": "2026-01",
+            },
+            "account_snapshot": [
+                {
+                    "captured_at": "2026-06-21T09:00:00+09:00",
+                    "account": "real",
+                    "account_type": "일반계좌",
+                    "ticker": "005930",
+                    "name": "삼성전자",
+                    "holding_quantity": 10,
+                    "available_quantity": 10,
+                    "average_cost": 70000,
+                    "total_cost": 700000,
+                    "current_price": 71000,
+                    "market_value": 710000,
+                    "profit_loss": 10000,
+                    "return_pct": 1.43,
+                    "immediate_cash": 1000000,
+                    "settlement_cash_d2": 1000000,
+                    "available_cash": 1000000,
+                    "open_order_amount": 0,
+                    "monthly_contribution_limit": "",
+                    "monthly_contribution_used": "",
+                    "parse_status": "CAPTURE_READ_OK",
+                    "user_confirmed": "Y",
+                    "stop_price": 65000,
+                    "highest_price_since_entry": 72000,
+                    "entry_date": "2026-06-01",
+                    "entry_stage": "stage_1",
+                    "position_type": "core",
+                    "last_updated": "2026-06-21T09:05:00+09:00",
+                }
+            ],
+        }
+    }
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+
+
+def test_seed_import_and_export_round_trip(tmp_path):
+    db_path = tmp_path / "snapshot.db"
+    seed_path = tmp_path / "seed.json"
+    _seed_json(seed_path)
+
+    summary = import_seed_json(db_path, seed_path)
+    assert summary["settings_rows"] == 3
+    assert summary["account_snapshot_rows"] == 1
+
+    settings_rows = load_settings_rows(db_path)
+    assert settings_rows[0]["key"] == "total_asset_krw"
+    assert settings_rows[0]["value"] == 150000000
+
+    snapshot_rows = load_account_snapshot_rows(db_path)
+    assert snapshot_rows[0]["ticker"] == "005930"
+    assert snapshot_rows[0]["parse_status"] == "CAPTURE_READ_OK"
+
+    exported = export_payload(db_path)
+    assert exported["data"]["settings"]["weekly_target_cash_pct"] == 14
+    assert exported["data"]["account_snapshot"][0]["name"] == "삼성전자"
+
+    out = write_export_json(db_path, tmp_path / "export.json")
+    assert out.exists()
+
+
+def test_parse_account_snapshot_tsv_supports_headerless_and_header_rows():
+    headerless = "\n".join(
+        [
+            "\t".join(ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS),
+            "\t".join(
+                [
+                    "2026-06-21T09:00:00+09:00",
+                    "real",
+                    "일반계좌",
+                    "005930",
+                    "삼성전자",
+                    "10",
+                    "10",
+                    "70000",
+                    "700000",
+                    "71000",
+                    "710000",
+                    "10000",
+                    "1.43",
+                    "1000000",
+                    "1000000",
+                    "1000000",
+                    "0",
+                    "",
+                    "",
+                    "CAPTURE_READ_OK",
+                    "Y",
+                    "65000",
+                    "72000",
+                    "2026-06-01",
+                    "stage_1",
+                    "core",
+                    "2026-06-21T09:05:00+09:00",
+                ]
+            ),
+        ]
+    )
+    rows = parse_account_snapshot_tsv(headerless)
+    assert rows[0]["ticker"] == "005930"
+    assert rows[0]["holding_quantity"] == 10
+
+    with_header = "captured_at\taccount\tticker\n2026-06-21T09:00:00+09:00\treal\t005930"
+    rows2 = parse_account_snapshot_tsv(with_header)
+    assert rows2[0]["account"] == "real"
+    assert rows2[0]["ticker"] == "005930"
+
+
+def test_build_ui_state_reports_schema(tmp_path):
+    db_path = tmp_path / "snapshot.db"
+    seed_path = tmp_path / "seed.json"
+    _seed_json(seed_path)
+    import_seed_json(db_path, seed_path)
+
+    state = build_ui_state(db_path)
+    assert state["summary"]["settings_rows"] == 3
+    assert state["account_snapshot_columns"][: len(ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS)] == ACCOUNT_SNAPSHOT_CANONICAL_COLUMNS
+
+
+def test_change_log_approval_and_lock_workflow(tmp_path):
+    db_path = tmp_path / "snapshot.db"
+    seed_path = tmp_path / "seed.json"
+    _seed_json(seed_path)
+    import_seed_json(db_path, seed_path)
+
+    with open_connection(db_path) as conn:
+        set_lock(conn, "settings", "*", locked_by="tester", reason="review")
+        conn.commit()
+
+    locks = load_locks(db_path)
+    assert locks and locks[0]["domain"] == "settings"
+
+    approval = load_approval_for_domain(db_path, "settings")
+    assert approval["status"] == "PENDING"
+
+    changes = load_change_log_rows(db_path, limit=10)
+    assert changes
+
+
+def test_lock_conflicts_detect_row_targets(tmp_path):
+    db_path = tmp_path / "snapshot.db"
+    seed_path = tmp_path / "seed.json"
+    _seed_json(seed_path)
+    import_seed_json(db_path, seed_path)
+
+    with open_connection(db_path) as conn:
+        set_lock(conn, "settings", "total_asset_krw", locked_by="tester", reason="review")
+        set_lock(conn, "account_snapshot", "005930", locked_by="tester", reason="review")
+        conn.commit()
+
+    settings_conflicts = lock_conflicts_for_rows(
+        db_path,
+        "settings",
+        [{"key": "total_asset_krw", "value": 123, "note": ""}],
+    )
+    snapshot_conflicts = lock_conflicts_for_rows(
+        db_path,
+        "account_snapshot",
+        [{"ticker": "005930", "name": "삼성전자", "ordinal": 1}],
+    )
+
+    assert settings_conflicts and settings_conflicts[0]["target_ref"] == "total_asset_krw"
+    assert snapshot_conflicts and snapshot_conflicts[0]["target_ref"] == "005930"
+
+
+def test_undo_last_change_restores_previous_snapshot(tmp_path):
+    db_path = tmp_path / "snapshot.db"
+    seed_path = tmp_path / "seed.json"
+    _seed_json(seed_path)
+    import_seed_json(db_path, seed_path)
+
+    with open_connection(db_path) as conn:
+        from src.quant_engine.snapshot_admin_store_v1 import replace_settings
+
+        replace_settings(conn, [{"ordinal": 1, "key": "total_asset_krw", "value": 123, "note": "edited"}])
+
+    with open_connection(db_path) as conn:
+        undo_last_change(conn, "settings")
+
+    settings_rows = load_settings_rows(db_path)
+    assert settings_rows[0]["value"] == 150000000
+
+
+def test_validation_helpers_detect_invalid_rows():
+    assert "settings.total_asset_krw is required" in validate_settings_rows([{"key": "weekly_target_cash_pct", "value": 10}])
+    assert "account_snapshot row 1: ticker required" in validate_account_snapshot_rows(
+        [{"captured_at": "2026-06-21", "account": "real", "name": "삼성전자", "parse_status": "BAD"}]
+    )
+    suggestions = build_validation_suggestions(
+        [{"key": "weekly_target_cash_pct", "value": 10}],
+        [{"captured_at": "2026-06-21", "account": "real", "account_type": "일반계좌", "ticker": "005930", "name": "삼성전자", "parse_status": "CAPTURE_READ_OK", "user_confirmed": "N"}],
+    )
+    assert any("user_confirmed=Y" in item for item in suggestions)
+    actions = build_safe_autofix_actions(
+        [{"key": "total_asset_krw", "value": 150000000}],
+        [{"captured_at": "2026-06-21", "account": "real", "account_type": "일반계좌", "ticker": "005930", "name": "삼성전자", "parse_status": "CAPTURE_READ_OK", "user_confirmed": "N", "entry_stage": "stage_1", "position_type": ""}],
+    )
+    assert any(item["action_id"] == "confirm_captured_rows" for item in actions)
+
+
+def test_safe_autofix_updates_snapshot_defaults(tmp_path):
+    db_path = tmp_path / "snapshot.db"
+    seed_path = tmp_path / "seed.json"
+    _seed_json(seed_path)
+    import_seed_json(db_path, seed_path)
+
+    with open_connection(db_path) as conn:
+        result = apply_safe_autofix_action(conn, "confirm_captured_rows")
+        assert result["status"] == "AUTOFIXED"
+
+    snapshot_rows = load_account_snapshot_rows(db_path)
+    assert all(row.get("user_confirmed") == "Y" or str(row.get("parse_status")) != "CAPTURE_READ_OK" for row in snapshot_rows)
diff --git a/tests/unit/test_snapshot_admin_web_v1.py b/tests/unit/test_snapshot_admin_web_v1.py
new file mode 100644
index 0000000..8f7b034
--- /dev/null
+++ b/tests/unit/test_snapshot_admin_web_v1.py
@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+import tools.validate_snapshot_admin_web_v1 as validator
+from src.quant_engine.snapshot_admin_server_v1 import (
+    build_ui_state,
+    fetch_table_rows,
+    list_browsable_tables,
+    render_collection_html,
+    render_index_html,
+    render_tables_html,
+)
+from src.quant_engine.snapshot_admin_store_v1 import import_seed_json
+
+
+def test_render_index_html_contains_spreadsheet_surface():
+    html = render_index_html()
+    assert "Snapshot Admin" in html
+    assert "contenteditable" in html
+    assert "/api/settings/save" in html
+    assert "/api/account_snapshot/save" in html
+    assert "Lock target" in html
+    assert "Lock row" in html
+    assert "Approve pending" in html
+    assert "Refresh diff" in html
+    assert "Export approval packet" in html
+    assert "Selection Inspector" in html
+    assert "Recent row history" in html
+    assert "Save view" in html
+    assert "Apply TSV to selection" in html
+    assert "Ctrl+S" in html
+    assert "KIS Collection" in html
+    assert "Recent collector snapshots" in html
+    assert "Collection detail" in html
+    assert "Filter runs / snapshots / errors" in html
+    assert "Filter change log" in html
+    assert "Timeline" in html
+    assert "/collection" in html
+    assert "Open collection dashboard" in html
+
+
+def test_render_collection_html_contains_dashboard_surface():
+    html = render_collection_html()
+    assert "KIS Collection Dashboard" in html
+    assert "/api/state" in html
+    assert "Download raw JSON" in html
+    assert "Download CSV" in html
+    assert "Filter runs / snapshots / errors" in html
+    assert "Ticker quick search" in html
+    assert "Date quick search" in html
+
+
+def test_build_ui_state_exposes_expected_columns(tmp_path):
+    db_path = tmp_path / "snapshot_admin.db"
+    seed_path = ROOT / "GatherTradingData.json"
+    import_seed_json(db_path, seed_path)
+
+    state = build_ui_state(db_path)
+    assert state["summary"]["settings_rows"] > 0
+    assert state["summary"]["account_snapshot_rows"] > 0
+    assert state["summary"]["topology"]["mode"] == "single_workspace_sqlite"
+    assert state["summary"]["topology"]["settings_and_snapshot_share_db"] is True
+    assert state["summary"]["topology"]["collector_separate_db"] is True
+    assert state["account_snapshot_columns"][0] == "captured_at"
+    assert "settings" in state["validation"]
+    assert state["version"]["app"]
+    assert "fingerprint" in state["version"]["source"]
+    assert "collection" in state
+    assert "counts" in state["collection"]
+    assert "latest_report" in state["collection"]
+    assert state["summary"]["topology"]["mode"] == "single_workspace_sqlite"
+
+
+def test_snapshot_admin_workflow_and_script_exist():
+    workflow = ROOT / ".gitea" / "workflows" / "snapshot_admin.yml"
+    package = json.loads((ROOT / "package.json").read_text(encoding="utf-8"))
+    assert workflow.exists()
+    assert "--reload" in package["scripts"]["ops:snapshot-web"]
+    assert "ops:snapshot-validate" in package["scripts"]
+    assert "ops:snapshot-web-validate" in package["scripts"]
+
+
+def test_render_tables_html_contains_tabler_grid_surface():
+    html = render_tables_html()
+    assert "tabler" in html.lower()
+    assert "tableSelect" in html
+    assert "/api/tables" in html
+    assert "/api/table_rows" in html
+    assert "gridTable" in html
+
+
+def test_list_browsable_tables_covers_all_three_databases(tmp_path):
+    db_path = tmp_path / "snapshot_admin.db"
+    import_seed_json(db_path, ROOT / "GatherTradingData.json")
+
+    tables = list_browsable_tables(db_path)
+    names = {row["table"] for row in tables}
+    assert {"settings", "account_snapshot", "workspace_change_log"} <= names
+    assert {"collection_runs", "collection_snapshots", "collection_source_errors"} <= names
+    assert {"sell_strategy_results", "satellite_recommendations"} <= names
+
+    settings_row = next(row for row in tables if row["table"] == "settings")
+    assert settings_row["exists"] is True
+    assert settings_row["row_count"] > 0
+
+
+def test_fetch_table_rows_paginates_and_rejects_unknown_table(tmp_path):
+    db_path = tmp_path / "snapshot_admin.db"
+    import_seed_json(db_path, ROOT / "GatherTradingData.json")
+
+    page1 = fetch_table_rows("settings", db_path, limit=2, offset=0)
+    assert page1["columns"]
+    assert len(page1["rows"]) == 2
+    assert page1["total"] > 2
+
+    page2 = fetch_table_rows("settings", db_path, limit=2, offset=2)
+    assert page1["rows"] != page2["rows"]
+
+    import pytest
+
+    with pytest.raises(ValueError):
+        fetch_table_rows("settings; DROP TABLE settings;--", db_path)
+
+
+def test_snapshot_admin_web_validation_script_passes():
+    out = ROOT / "Temp" / "snapshot_admin_web_validation_v1.json"
+    if out.exists():
+        out.unlink()
+
+    rc = validator.main()
+    payload = json.loads(out.read_text(encoding="utf-8"))
+
+    assert rc == 0
+    assert payload["gate"] == "PASS"
+    assert payload["formula_id"] == "SNAPSHOT_ADMIN_WEB_VALIDATION_V1"
+    assert payload["settings_rows"] > 0
+    assert payload["account_snapshot_rows"] > 0
diff --git a/tools/run_snapshot_admin_server_v1.py b/tools/run_snapshot_admin_server_v1.py
new file mode 100644
index 0000000..7683ea4
--- /dev/null
+++ b/tools/run_snapshot_admin_server_v1.py
@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+SERVER_MODULE = "src.quant_engine.snapshot_admin_server_v1"
+WATCH_DIRS = (
+    ROOT / "src",
+    ROOT / "tools",
+    ROOT / "spec",
+    ROOT / "governance",
+    ROOT / "docs",
+    ROOT / ".gitea",
+)
+WATCH_FILES = (
+    ROOT / "package.json",
+    ROOT / "AGENTS.md",
+    ROOT / "GatherTradingData.json",
+)
+WATCH_EXTENSIONS = {".py", ".yaml", ".yml", ".json", ".md", ".gs"}
+IGNORED_DIR_NAMES = {"Temp", "outputs", ".git", "__pycache__", ".pytest_cache"}
+
+
+def _server_cmd(args: argparse.Namespace) -> list[str]:
+    cmd = [
+        sys.executable,
+        "-m",
+        SERVER_MODULE,
+        "--host",
+        args.host,
+        "--port",
+        str(args.port),
+        "--db",
+        args.db,
+        "--seed",
+        args.seed,
+    ]
+    if args.no_bootstrap:
+        cmd.append("--no-bootstrap")
+    return cmd
+
+
+def _iter_watch_files() -> list[Path]:
+    seen: set[Path] = set()
+    files: list[Path] = []
+    for path in WATCH_FILES:
+        if path.exists() and path.is_file():
+            resolved = path.resolve()
+            if resolved not in seen:
+                seen.add(resolved)
+                files.append(resolved)
+    for root in WATCH_DIRS:
+        if not root.exists():
+            continue
+        for path in root.rglob("*"):
+            if not path.is_file():
+                continue
+            if any(part in IGNORED_DIR_NAMES for part in path.parts):
+                continue
+            if path.suffix.lower() not in WATCH_EXTENSIONS:
+                continue
+            resolved = path.resolve()
+            if resolved not in seen:
+                seen.add(resolved)
+                files.append(resolved)
+    return files
+
+
+def _snapshot_mtimes() -> dict[Path, float]:
+    mtimes: dict[Path, float] = {}
+    for path in _iter_watch_files():
+        try:
+            mtimes[path] = path.stat().st_mtime
+        except FileNotFoundError:
+            continue
+    return mtimes
+
+
+def _changed_files(previous: dict[Path, float]) -> list[Path]:
+    current = _snapshot_mtimes()
+    changed: list[Path] = []
+    for path, mtime in current.items():
+        if previous.get(path) != mtime:
+            changed.append(path)
+    for path in previous:
+        if path not in current:
+            changed.append(path)
+    return changed
+
+
+def _run_once(args: argparse.Namespace) -> int:
+    proc = subprocess.Popen(_server_cmd(args), cwd=str(ROOT), env=os.environ.copy())
+    try:
+        return proc.wait()
+    except KeyboardInterrupt:
+        proc.terminate()
+        try:
+            return proc.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            proc.kill()
+            return proc.wait()
+
+
+def _run_reload(args: argparse.Namespace, interval: float) -> int:
+    last_mtimes = _snapshot_mtimes()
+    child: subprocess.Popen[str] | None = None
+    try:
+        while True:
+            if child is None or child.poll() is not None:
+                if child is not None:
+                    code = child.returncode or 0
+                    print(f"[snapshot-admin] server exited with code {code}; restarting...")
+                child = subprocess.Popen(_server_cmd(args), cwd=str(ROOT), env=os.environ.copy())
+                print("[snapshot-admin] hot reload watcher active")
+                print("[snapshot-admin] watching:", ", ".join(str(path) for path in WATCH_DIRS))
+            time.sleep(interval)
+            changed = _changed_files(last_mtimes)
+            if changed:
+                print("[snapshot-admin] changes detected:")
+                for path in changed[:20]:
+                    print(f"  - {path}")
+                last_mtimes = _snapshot_mtimes()
+                if child is not None and child.poll() is None:
+                    child.terminate()
+                    try:
+                        child.wait(timeout=10)
+                    except subprocess.TimeoutExpired:
+                        child.kill()
+                        child.wait()
+                child = None
+    except KeyboardInterrupt:
+        if child is not None and child.poll() is None:
+            child.terminate()
+            try:
+                child.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                child.kill()
+                child.wait()
+        return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Run the snapshot admin web server.")
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8787)
+    parser.add_argument("--db", default=str(ROOT / "outputs" / "snapshot_admin" / "snapshot_admin.db"))
+    parser.add_argument("--seed", default=str(ROOT / "GatherTradingData.json"))
+    parser.add_argument("--no-bootstrap", action="store_true")
+    parser.add_argument("--reload", action="store_true", help="Restart the server when watched files change.")
+    parser.add_argument("--reload-interval", type=float, default=1.0, help="Seconds between file-system polls.")
+    args = parser.parse_args()
+    if args.reload:
+        return _run_reload(args, max(0.25, args.reload_interval))
+    return _run_once(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/validate_snapshot_admin_web_v1.py b/tools/validate_snapshot_admin_web_v1.py
new file mode 100644
index 0000000..5220f4d
--- /dev/null
+++ b/tools/validate_snapshot_admin_web_v1.py
@@ -0,0 +1,222 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import json
+import socket
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+OUT = ROOT / "Temp" / "snapshot_admin_web_validation_v1.json"
+
+
+def _read_json(url: str) -> dict[str, Any]:
+    with urllib.request.urlopen(url, timeout=5) as response:
+        payload = response.read().decode("utf-8")
+    data = json.loads(payload)
+    return data if isinstance(data, dict) else {}
+
+
+def _read_text(url: str) -> str:
+    with urllib.request.urlopen(url, timeout=5) as response:
+        return response.read().decode("utf-8")
+
+
+def _post_json(url: str, payload: dict[str, Any]) -> dict[str, Any]:
+    data = json.dumps(payload, ensure_ascii=False).encode("utf-8")
+    request = urllib.request.Request(
+        url,
+        data=data,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+    with urllib.request.urlopen(request, timeout=5) as response:
+        return json.loads(response.read().decode("utf-8"))
+
+
+def _wait_for_server(url: str, timeout_s: float = 15.0) -> None:
+    deadline = time.time() + timeout_s
+    last_error: Exception | None = None
+    while time.time() < deadline:
+        try:
+            _read_text(url)
+            return
+        except Exception as exc:  # noqa: BLE001
+            last_error = exc
+            time.sleep(0.25)
+    raise RuntimeError(f"server did not start: {last_error}")
+
+
+def _pick_free_port() -> int:
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
+        sock.bind(("127.0.0.1", 0))
+        return int(sock.getsockname()[1])
+
+
+def main() -> int:
+    port = _pick_free_port()
+    db_path = ROOT / "Temp" / "snapshot_admin_web_validation.db"
+    seed_path = ROOT / "GatherTradingData.json"
+    server_cmd = [
+        sys.executable,
+        str(ROOT / "tools" / "run_snapshot_admin_server_v1.py"),
+        "--host",
+        "127.0.0.1",
+        "--port",
+        str(port),
+        "--db",
+        str(db_path),
+        "--seed",
+        str(seed_path),
+    ]
+
+    proc = subprocess.Popen(
+        server_cmd,
+        cwd=ROOT,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        encoding="utf-8",
+    )
+    base_url = f"http://127.0.0.1:{port}"
+    errors: list[str] = []
+    html = ""
+    state: dict[str, Any] = {}
+
+    try:
+        _wait_for_server(base_url)
+        html = _read_text(f"{base_url}/")
+        state = _read_json(f"{base_url}/api/state")
+        export_payload = _read_json(f"{base_url}/api/export")
+        approval_packet = {
+            "formula_id": "SNAPSHOT_ADMIN_APPROVAL_PACKET_V1",
+            "generated_at": state.get("generated_at") or "",
+            "summary": {
+                "settings_changed": 0,
+                "account_snapshot_changed": 0,
+                "pending_target_count": 0,
+            },
+            "pending_targets": [],
+            "diff_preview": {"settings": {"added": [], "removed": [], "changed": []}, "account_snapshot": {"added": [], "removed": [], "changed": []}},
+            "approvals": state.get("approval_rows", []),
+            "locks": state.get("locks", []),
+            "workspace": state.get("summary", {}),
+        }
+        packet_response = _post_json(f"{base_url}/api/approval_packet", {"packet": approval_packet})
+        if "Snapshot Admin" not in html:
+            errors.append("html_title_missing")
+        if "contenteditable" not in html:
+            errors.append("sheet_editor_missing")
+        if "settings" not in html or "Account Snapshot" not in html:
+            errors.append("section_missing")
+        if "/api/settings/save" not in html or "/api/account_snapshot/save" not in html:
+            errors.append("api_binding_missing")
+        if "Approve pending" not in html or "Refresh diff" not in html:
+            errors.append("diff_or_approval_ui_missing")
+        if "Export approval packet" not in html:
+            errors.append("approval_packet_ui_missing")
+        if "Selection Inspector" not in html or "Apply TSV to selection" not in html or "Save view" not in html:
+            errors.append("sheet_facade_ui_missing")
+        if "Recent row history" not in html or "Ctrl+S" not in html:
+            errors.append("sheet_shortcuts_ui_missing")
+        if "KIS Collection" not in html or "collector:" not in html:
+            errors.append("collection_dashboard_ui_missing")
+        if "Recent collector snapshots" not in html or "Collection detail" not in html or "Filter runs / snapshots / errors" not in html:
+            errors.append("collection_detail_ui_missing")
+        if "Filter change log" not in html:
+            errors.append("change_log_filter_ui_missing")
+        if "Timeline" not in html or "/collection" not in html or "Open collection dashboard" not in html:
+            errors.append("collection_page_link_missing")
+        if "Open collection dashboard" not in html:
+            errors.append("collection_dashboard_link_missing")
+        collection_html = _read_text(f"{base_url}/collection")
+        if "KIS Collection Dashboard" not in collection_html or "Download CSV" not in collection_html or "Ticker quick search" not in collection_html or "Date quick search" not in collection_html:
+            errors.append("collection_dashboard_page_missing")
+        if int(state.get("summary", {}).get("settings_rows") or 0) <= 0:
+            errors.append("settings_rows_missing")
+        if int(state.get("summary", {}).get("account_snapshot_rows") or 0) <= 0:
+            errors.append("account_snapshot_rows_missing")
+        topology = state.get("summary", {}).get("topology", {})
+        if not isinstance(topology, dict):
+            errors.append("topology_missing")
+        else:
+            if topology.get("mode") != "single_workspace_sqlite":
+                errors.append("topology_mode_invalid")
+            if not topology.get("settings_and_snapshot_share_db"):
+                errors.append("topology_workspace_split_invalid")
+            if not topology.get("collector_separate_db"):
+                errors.append("topology_collector_split_invalid")
+        if not isinstance(state.get("version"), dict) or not state.get("version", {}).get("app"):
+            errors.append("version_metadata_missing")
+        if not isinstance(state.get("collection"), dict):
+            errors.append("collection_state_missing")
+        collection = state.get("collection", {})
+        if not isinstance(collection.get("counts"), dict):
+            errors.append("collection_counts_missing")
+        if "latest_report" not in collection:
+            errors.append("collection_latest_report_missing")
+        if "data" not in export_payload:
+            errors.append("export_missing_data")
+        if packet_response.get("gate") != "PASS":
+            errors.append("approval_packet_export_failed")
+        packet_path = Path(packet_response.get("packet_path") or "")
+        md_path = Path(packet_response.get("md_path") or "")
+        if not packet_path.exists():
+            errors.append("approval_packet_json_missing")
+        if not md_path.exists():
+            errors.append("approval_packet_md_missing")
+
+        payload = {
+            "formula_id": "SNAPSHOT_ADMIN_WEB_VALIDATION_V1",
+            "gate": "PASS" if not errors else "FAIL",
+            "port": port,
+            "db_path": str(db_path),
+            "base_url": base_url,
+            "errors": errors,
+            "summary": state.get("summary", {}),
+            "version": state.get("version", {}),
+            "settings_rows": int(state.get("summary", {}).get("settings_rows") or 0),
+            "account_snapshot_rows": int(state.get("summary", {}).get("account_snapshot_rows") or 0),
+            "approval_packet_path": str(packet_path),
+        }
+        OUT.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return 0 if payload["gate"] == "PASS" else 1
+    except urllib.error.URLError as exc:
+        errors.append(str(exc))
+        payload = {
+            "formula_id": "SNAPSHOT_ADMIN_WEB_VALIDATION_V1",
+            "gate": "FAIL",
+            "port": port,
+            "db_path": str(db_path),
+            "base_url": base_url,
+            "errors": errors,
+            "summary": state.get("summary", {}),
+            "version": state.get("version", {}),
+        }
+        OUT.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        print(json.dumps(payload, ensure_ascii=False, indent=2))
+        return 1
+    finally:
+        if proc.poll() is None:
+            proc.terminate()
+            try:
+                proc.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                proc.kill()
+                proc.wait(timeout=5)
+        if proc.stdout is not None:
+            proc.stdout.close()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/validate_snapshot_admin_workflow_v1.py b/tools/validate_snapshot_admin_workflow_v1.py
new file mode 100644
index 0000000..cc7f989
--- /dev/null
+++ b/tools/validate_snapshot_admin_workflow_v1.py
@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))
+
+from src.quant_engine.snapshot_admin_store_v1 import (
+    DEFAULT_DB,
+    DEFAULT_SEED_JSON,
+    import_seed_json,
+    load_account_snapshot_rows,
+    load_settings_rows,
+    parse_account_snapshot_tsv,
+    validate_account_snapshot_rows,
+    validate_settings_rows,
+    write_export_json,
+)
+
+OUT = ROOT / "Temp" / "snapshot_admin_workflow_v1.json"
+
+
+def main() -> int:
+    db_path = DEFAULT_DB
+    seed_path = DEFAULT_SEED_JSON
+    summary = import_seed_json(db_path, seed_path)
+    settings_rows = load_settings_rows(db_path)
+    snapshot_rows = load_account_snapshot_rows(db_path)
+    settings_errors = validate_settings_rows(settings_rows)
+    snapshot_errors = validate_account_snapshot_rows(snapshot_rows)
+    exported = write_export_json(db_path, ROOT / "Temp" / "snapshot_admin_export_v1.json")
+    tsv_rows = parse_account_snapshot_tsv(
+        "\n".join(
+            [
+                "captured_at\taccount\taccount_type\tticker\tname\tholding_quantity\tavailable_quantity\taverage_cost\ttotal_cost\tcurrent_price\tmarket_value\tprofit_loss\treturn_pct\timmediate_cash\tsettlement_cash_d2\tavailable_cash\topen_order_amount\tmonthly_contribution_limit\tmonthly_contribution_used\tparse_status\tuser_confirmed\tstop_price\thighest_price_since_entry\tentry_date\tentry_stage\tposition_type\tlast_updated",
+                "2026-06-21T09:00:00+09:00\treal\t일반계좌\t005930\t삼성전자\t10\t10\t70000\t700000\t71000\t710000\t10000\t1.43\t1000000\t1000000\t1000000\t0\t\t\tCAPTURE_READ_OK\tY\t65000\t72000\t2026-06-01\tstage_1\tcore\t2026-06-21T09:05:00+09:00",
+            ]
+        )
+    )
+    payload = {
+        "status": "PASS",
+        "db_path": str(db_path),
+        "seed_path": str(seed_path),
+        "summary": summary,
+        "settings_rows": len(settings_rows),
+        "account_snapshot_rows": len(snapshot_rows),
+        "settings_errors": settings_errors,
+        "snapshot_errors": snapshot_errors,
+        "export_path": str(exported),
+        "tsv_parse_rows": len(tsv_rows),
+    }
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+    print(json.dumps(payload, ensure_ascii=False, indent=2))
+    if settings_errors or snapshot_errors:
+        print("FAIL")
+        return 1
+    print("PASS")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())