9 changed files with 522 additions and 114 deletions
--- a/.mcp.json
+++ b/.mcp.json
@@ -1,8 +1,8 @@
 {
  "mcpServers": {
    "iiot-rag": {
-      "command": "/home/windpacer/projects/ExperionCrawler/mcp-server/.venv/bin/python",
-      "args": ["/home/windpacer/projects/ExperionCrawler/mcp-server/server.py"],
+      "command": "/home/windpacer/projects/hc900_ax/mcp-server/.venv/bin/python",
+      "args": ["/home/windpacer/projects/hc900_ax/mcp-server/server.py"],
      "type": "stdio"
    }
  }
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1,6 +1,6 @@
 # CLAUDE.md

-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+> **📌 [`docs/베이직아키텍처-태그-디자인-전면재설계.md`](docs/베이직아키텍처-태그-디자인-전면재설계.md)** 를 먼저 읽을 것 — 모든 아키텍처 결정 사항이 정의되어 있음.

 ## Project Overview

@@ -11,6 +11,13 @@ Before: HC900 ──Modbus TCP──▶ Experion R530 ──OPC UA──▶ Expe
 After:  HC900 ──Modbus TCP──▶ C++ Gateway ──gRPC──▶ HC900Crawler ──▶ PostgreSQL
 ```

+**핵심 원칙:**
+- 단일 진실 공급원 = **`docs/Sinam_Tag_all.xlsx`** (태그명·주소·메타데이터 전부 포함)
+- **모든 태그명은 대문자** (OPC UA 강제 소문자 규칙 폐기)
+- **컨트롤러별 독립 맵** (`register-map-cN.json`)
+- Loop 블록은 **통째로 읽기** (개별 파라미터 금지)
+- `build_register_map.py` 하나로 **맵 생성 + 메타데이터 적재** 모두 처리
+
 Four active components:
 - **`industrial-comm/cpp/`** — C++ gateway: Modbus TCP poller + gRPC server (`hc900_gateway` binary)
 - **`src/Hc900Crawler/`** — C# .NET 8 ASP.NET Core web app: full monitoring platform (gRPC client + web UI + KB/P&ID/FF)
@@ -35,7 +42,7 @@ Produces `build/hc900_gateway` and `build/libcomm_core.so`.
 Run the gateway:
 ```bash
 ./build/hc900_gateway [host] [register-map-path] [poll_ms]
-# defaults: 192.168.0.240, docs/register-map.json, 1000
+# defaults: 192.168.0.240, docs/register-map-c3.json, 1000
 ```

 Log file: `/tmp/hc900_gateway.log`. gRPC listens on `0.0.0.0:50051`.
@@ -50,22 +57,23 @@ dotnet run

 Configuration via `appsettings.json`: `Hc900.GatewayAddress` (default `http://localhost:50051`), `Hc900.PollIntervalMs`, `ConnectionStrings.DefaultConnection` (PostgreSQL, `Search Path=hc900`). Serves web UI at `http://0.0.0.0:5000`.

-### Register Map Generation
+### Register Map Generation (단일 스크립트)

-Converts HC Designer CSV exports → `docs/register-map.json` used by the gateway at startup:
+`docs/Sinam_Tag_all.xlsx` 하나로 모든 처리:

 ```bash
 python3 scripts/build_register_map.py \
-    --loop-csv docs/SummaryFucntionBlockReport.csv \
-    --signal-csv docs/SignalTags.csv \
-    --variable-csv docs/Variables.csv \
-    -o docs/register-map.json
+    --xlsx docs/Sinam_Tag_all.xlsx \
+    -o docs/register-map-c3.json \
+    --controller C3 \
+    [--db-conn "Host=...;Database=hc900;..."]
 ```

-Load state labels (StatusPoint descriptors from xlsx) into DB:
-```bash
-python3 scripts/load_state_labels.py
-```
+출력:
+  - `register-map-cN.json` — 게이트웨이용 레지스터 맵
+  - `tag_metadata` upsert (state labels, units, desc, area)
+
+**더 이상 `load_state_labels.py`를 별도 실행할 필요 없음.**

 ### Test Utilities

@@ -74,99 +82,59 @@ python3 scripts/load_state_labels.py
 python3 test/modbus_sim.py

 # Read tags directly via Modbus TCP
-python3 test/read_tags.py FICQ3101.PV FICQ3101.SP FICQ3101.MODE
-python3 test/read_tags.py --port 5020 FICQ3101.PV   # against simulator
+python3 test/read_tags.py FICQ-6101.PV FICQ-6101.SP FICQ-6101.MODE
+python3 test/read_tags.py --port 5020 FICQ-6101.PV   # against simulator
 python3 test/read_tags.py --all --limit 50
-
-# pymodbus must be available; it's expected at /tmp/hc900_venv
-/tmp/hc900_venv/bin/python3 test/read_tags.py FICQ3101.PV
 ```

 ## Architecture

+**반드시 [`docs/베이직아키텍처-태그-디자인-전면재설계.md`](docs/베이직아키텍처-태그-디자인-전면재설계.md) 를 읽을 것.** 여기서는 요약만 기술.
+
 ### C++ Gateway (`industrial-comm/cpp/`)

 **`Hc900Gateway`** (`src/gateway.cpp`, `include/gateway.h`) is the core class:
- Loads `register-map.json` at startup into `registers_` (vector of `RegisterEntry`) and `tag_index_` (name→index map)
- Spawns a poll thread (`PollLoop`) that runs `ReadAllRegisters()` every `poll_interval_ms`
- `ReadAllRegisters()` groups consecutive registers into batches of ≤120 and issues one `read_raw()` call per batch (~48 batches total for a full HC900 config, ~117 ms round-trip)
- Cache (`cache_`, protected by `cache_mutex_`) stores `CachedValue` per tag; quality=192=good, quality=0=bad/stale
- `transport_mutex_` serializes all Modbus transport calls between the poll thread and gRPC `WriteTag` handlers
+- Loads `register-map-cN.json` at startup into `registers_` and `tag_index_`
+- Spawns poll thread (`PollLoop`) → `ReadAllRegisters()` every `poll_interval_ms`
+- Groups consecutive registers into batches of **≤120** (FC03), **Loop 블록은 통째로 192 regs**
+- Cache (`cache_`, protected by `cache_mutex_`); quality=192=good, quality=0=bad/stale
+- `transport_mutex_` serializes Modbus calls between poll thread and gRPC `WriteTag`

-**Key gRPC operations** (all implemented in `gateway.cpp`):
- `ReadTags` — reads from cache, sub-millisecond, no Modbus I/O
- `WriteTag` — calls Modbus FC16 directly, then updates cache
- `StreamTags` — pushes cache snapshot at requested interval
- `ListTags` — returns metadata from in-memory register list
- `HealthCheck` — reports connection state, poll count, last poll duration
+**Key gRPC operations:**
+- `ReadTags` — from cache, no Modbus I/O
+- `WriteTag` — FC16 directly, then update cache
+- `StreamTags` — push cache at interval
+- `ListTags` — metadata from register list
+- `HealthCheck` — connection state, poll count, duration

-**`Controller`** (`src/controller.cpp`, `include/controller.hpp`) wraps `ITransport` with typed read/write methods. **`ModbusTCP`** (`src/modbus_tcp.cpp`, `include/modbus_tcp.hpp`) implements the transport.
+**`Controller`** → wraps `ITransport` with typed read/write. **`ModbusTCP`** → FC03/FC16. **Codec** → FP_B format.

-**Codec** (`src/codec.cpp`, `include/codec.hpp`) handles byte/word order for float32, int32, int64, double. HC900 uses `VendorFormat::HC900_FLOAT` = `{BigEndian, HighFirst, Normal}` (FP B format per manual).
+### C# Crawler (`src/Hc900Crawler/`)

-**Proto:** The generated files (`gen/modbus_gateway.pb.{cc,h}` and `gen/modbus_gateway.grpc.pb.{cc,h}`) are pre-built and committed. The source proto is at `proto/modbus_gateway.proto`. The C# copy lives at `src/Hc900Crawler/Proto/modbus_gateway.proto` and is compiled by MSBuild via `Grpc.Tools`.
-
-### C# Crawler (`src/Hc900Crawler/`) — 3-Layer Architecture
-
-**Project layout** (ExperionCrawler 패턴 적용):
+**Project layout:**
 ```
 src/
  Core/               ← Domain entities, interfaces, application services
  Infrastructure/     ← DB (Hc900DbContext), HC900 services, Control, Kb, Mcp, Trend, Docs
-  Hc900Crawler/       ← ASP.NET Core web project (Controllers, wwwroot, Program.cs, csproj)
-mcp-server/           ← Python MCP server (copied from ExperionCrawler)
+  Hc900Crawler/       ← ASP.NET Core web project
 ```

 **BackgroundServices:**
- **`Hc900RealtimeService`** (`Infrastructure/Hc900/`) — gRPC 폴링 → `hc900.realtime_table` upsert (500 rows/batch). 상태 노출: `IsConnected`, `PollCount`, `LastPollAt`
- **`Hc900HistoryService`** — 60초 주기 `realtime_table` → `history_table` 스냅샷 (IsConnected 확인 후 실행)
- **`Hc900DigitalEventDetectorService`** — 1초 주기로 realtime_table 변화 감지 → `event_history_table` 기록
-
-**`Hc900GatewayClient`** (`Infrastructure/Hc900/`) — `IHc900GatewayService` 구현. gRPC 채널 lazy 생성. `GetHealthAsync()`, `ListTagsAsync()`, `WriteTagAsync()`.
-
-**`Hc900WriteService`** — FeedforwardSupervisor·FeedforwardController에서 SP 쓰기용.
-
-**Value formatting**: 상태 레이블 있으면 `{N | LABEL | }`, 없으면 float/uint16 string.
-
-**Web API endpoints** (port 5000):
- `GET /api/gateway/health` — gRPC HealthCheck
- `GET /api/gateway/tags` — ListTags
- `POST /api/gateway/write` — WriteTag
- `GET /api/gateway/status` — Hc900RealtimeService 상태
- `GET /api/realtime/points` — realtime_table
- `POST /api/history/query` — history_table 조회
- `POST /api/events/query` — event_history_table 조회
- `/api/pid/*`, `/api/kb/*`, `/api/ff/*`, `/api/t2s/*`, `/api/ollama/*` 등 ExperionCrawler 동일
+- `Hc900RealtimeService` — gRPC poll → `realtime_table` upsert (500 rows/batch)
+- `Hc900HistoryService` — 60s snapshot `realtime_table` → `history_table`
+- `Hc900DigitalEventDetectorService` — 1s digital change detect → `event_history_table`

 ### Database (PostgreSQL, schema `hc900`)

-`Hc900DbContext` (`Infrastructure/Database/Hc900DbContext.cs`) — `HasDefaultSchema("hc900")` + `Search Path=hc900` 연결문자열. `InitializeAsync()`에서 모든 테이블·뷰·TimeScaleDB 하이퍼테이블 자동 생성.
-
 | Table | Purpose |
 |---|---|
-| `hc900_map_master` | OPC UA `tagname` ↔ `hc900_tag` 매핑, Modbus addr, 데이터타입 |
 | `realtime_table` | 실시간 값 (tagname, livevalue, timestamp) — upsert on conflict |
 | `history_table` | 60초 이력 스냅샷 (TimeScaleDB hypertable) |
 | `event_history_table` | 디지털 태그 상태 변경 이벤트 (TRIP/ALARM/RUN 등) |
-| `tag_metadata` | 태그 메타 (description, area, sub_area, state0-7 레이블) |
-| `pid_equipment`, `pid_prefix_rules` | P&ID 추출 데이터 |
-| `kb_*` | Knowledge Base (Qdrant RAG) |
-| `ff_*` | Feedforward 제어 설정/감사 |
-
-### Register Map (`docs/register-map.json`)
-
-JSON file with a top-level `registers` array. Each entry: `tag`, `addr` (0-based Modbus holding register address), `count` (1=uint16, 2=float32), `type`, `access` ("R"/"RW"), `description`.
-
-Sources:
- **Loops** (PID): `SummaryFucntionBlockReport.csv` → expanded into per-parameter entries using `LOOP_PARAM_OFFSETS` in `build_register_map.py`. Loop #N base address = `0x40 + (N-1)*0x100` (loops 1–24), `0x7840 + (N-25)*0x100` (loops 25–32).
- **Signal Tags** (read-only): `SignalTags.csv`, addresses `0x2000–0x25E4`
- **Variables** (R/W): `Variables.csv`, addresses `0x18C0–0x1A10`
-
-Float format is `FP_B` (IEEE 754 big-endian, wire order bytes 4,3,2,1).
+| `tag_metadata` | 태그 메타 (desc, area, sub_area, state0-7, units) |
+| `hc900_map_master` | 활성 태그 관리 (향후 단순화 예정) |

 ### HC900 Hardware

 - Controller: HC900-C70, IP `192.168.0.240`, Modbus TCP port 502
- Maximum simultaneous connections: 10 (R530 uses 1, leaving 9 available)
- Unit ID: 0x00 (not used in Modbus TCP mode)
- Float format must be set to **FP B** on the controller
+- Unit ID: 1, Float format: **FP B**
--- a/src/Core/Application/DTOs/ExperionDtos.cs
+++ b/src/Core/Application/DTOs/ExperionDtos.cs
@@ -93,6 +93,61 @@ public class PointBuilderApplyDto
    public List<string> SelectedNodeIds { get; set; } = new();
 }

+// ── HC900 Point Builder DTOs ─────────────────────────────────────────────────
+
+public class Hc900PointBuilderGroupDto
+{
+    public List<string> TagPatterns { get; set; } = new();
+    public List<string> ParamTypes  { get; set; } = new();
+    public string?      DataType    { get; set; }
+    public int?         LoopNo      { get; set; }
+}
+
+public class Hc900PointBuilderBuildDto
+{
+    public Hc900PointBuilderGroupDto Loop     { get; set; } = new();
+    public Hc900PointBuilderGroupDto Signal   { get; set; } = new();
+    public Hc900PointBuilderGroupDto Digital  { get; set; } = new();
+    public Hc900PointBuilderGroupDto Variable { get; set; } = new();
+    public Hc900PointBuilderGroupDto Custom   { get; set; } = new();
+}
+
+public class Hc900PointBuilderPreviewItem
+{
+    [JsonPropertyName("tagName")]     public string  TagName      { get; set; } = "";
+    [JsonPropertyName("hc900Tag")]    public string  Hc900Tag     { get; set; } = "";
+    [JsonPropertyName("modbusAddr")]  public int     ModbusAddr   { get; set; }
+    [JsonPropertyName("paramType")]   public string  ParamType    { get; set; } = "";
+    [JsonPropertyName("dataType")]    public string  DataType     { get; set; } = "";
+    [JsonPropertyName("loopNo")]      public int?    LoopNo       { get; set; }
+    [JsonPropertyName("access")]      public string  Access       { get; set; } = "R";
+    [JsonPropertyName("controllerId")]public string  ControllerId { get; set; } = "HC1";
+    [JsonPropertyName("group")]       public string  Group        { get; set; } = "";
+    [JsonPropertyName("isActive")]    public bool    IsActive     { get; set; }
+}
+
+public class Hc900PointBuilderPreviewResult
+{
+    [JsonPropertyName("count")] public int                                Count { get; set; }
+    [JsonPropertyName("items")] public List<Hc900PointBuilderPreviewItem> Items { get; set; } = new();
+}
+
+public class Hc900PointBuilderApplyDto
+{
+    public List<string> SelectedTagNames { get; set; } = new();
+}
+
+public class Hc900PointBuilderAddDto
+{
+    public string  TagName      { get; set; } = "";
+    public string  Hc900Tag     { get; set; } = "";
+    public int     ModbusAddr   { get; set; }
+    public string  DataType     { get; set; } = "float32";
+    public string? ParamType    { get; set; }
+    public string  Access       { get; set; } = "R";
+    public string  ControllerId { get; set; } = "HC1";
+}
+
 // ── TimeScaleDB 하이퍼테이블 ────────────────────────────────────────────────────

 public class HypertableStatusDto
--- a/src/Core/Domain/Entities/Hc900Entities.cs
+++ b/src/Core/Domain/Entities/Hc900Entities.cs
@@ -77,7 +77,7 @@ public class TagMetadata
    [Column("value")]       public string?   Value        { get; set; }
    [Column("node_id")]     public string?   NodeId       { get; set; }
    [Column("loaded_at")]   public DateTime  LoadedAt     { get; set; } = DateTime.UtcNow;
-    [Column("controller_id")] public string  ControllerId { get; set; } = "HC1";
+    [Column("controller_id")] public string ControllerId { get; set; } = string.Empty;
 }

 // ── Knowledge Base (RAG) ─────────────────────────────────────────────────────
@@ -216,4 +216,12 @@ public class Hc900MapEntry

    [Column("controller_id")]
    public string ControllerId { get; set; } = "HC1";
+
+    /// <summary>실시간 폴링 대상 여부 (Hc900RealtimeService poll 대상 필터)</summary>
+    [Column("realtime_enabled")]
+    public bool RealtimeEnabled { get; set; } = true;
+
+    /// <summary>history_table 아카이브 대상 여부 (SnapshotToHistoryAsync 필터)</summary>
+    [Column("archive_enabled")]
+    public bool ArchiveEnabled { get; set; } = false;
 }
--- a/src/Hc900Crawler/Program.cs
+++ b/src/Hc900Crawler/Program.cs
@@ -106,6 +106,9 @@ builder.Services.AddScoped<Hc900Crawler.Infrastructure.Control.FeedRampAdvisorSe
 // 측류 추종(ON/OFF) 상태 저장소
 builder.Services.AddSingleton<Hc900Crawler.Core.Application.Feedforward.IFfTrackingStore,
    Hc900Crawler.Infrastructure.Control.FfTrackingStore>();
+// 모듈1 shadow 검증용 인메모리 버퍼
+builder.Services.AddSingleton<Hc900Crawler.Core.Application.Feedforward.IFfShadowStore,
+    Hc900Crawler.Infrastructure.Control.FfShadowStore>();
 // 작업 B: FEED 램프 실행기 + 작업 저장소
 builder.Services.AddSingleton<Hc900Crawler.Core.Application.Feedforward.IFeedRampJobStore,
    Hc900Crawler.Infrastructure.Control.FeedRampJobStore>();
--- a/src/Hc900Crawler/appsettings.json
+++ b/src/Hc900Crawler/appsettings.json
@@ -45,6 +45,13 @@
  "McpServer": {
    "WorkingDirectory": "../../mcp-server"
  },
+  "Sinam": {
+    "ScriptPath": "scripts/build_register_map_from_sinam.py",
+    "WorkingDirectory": "/home/windpacer/projects/hc900_ax",
+    "UploadDir": "docs/uploads",
+    "OutputDir": "docs",
+    "ProcessTimeoutSeconds": 120
+  },
  "DocBrowser": {
    "Root": "/home/windpacer/projects/hc900_ax",
    "MaxTextBytes": 2097152,
@@ -65,7 +72,7 @@
    }
  },
  "SteamAdvisor": {
-    "ModelPath": "/home/windpacer/projects/hc900_ax/scripts/analysis/C-6111_model.json",
+    "ModelPath": "/home/windpacer/projects/hc900_ax/scripts/analysis/C-6PG-Dump-20260605111_model.json",
    "PlotDataDir": "/home/windpacer/projects/hc900_ax/scripts/analysis",
    "ModelDir": "/home/windpacer/projects/hc900_ax/scripts/analysis",
    "DefaultColumn": "C-6111",
--- a/src/Hc900Crawler/wwwroot/index.html
+++ b/src/Hc900Crawler/wwwroot/index.html
@@ -47,7 +47,7 @@
      </li>
      <li class="nav-item" data-tab="pb">
        <span class="ni">01</span>
-        <span class="nl">태그 관리</span>
+        <span class="nl">포인트빌더</span>
      </li>
      <li class="nav-item" data-tab="hist">
        <span class="ni">02</span>
--- a/src/Infrastructure/Database/Hc900DbContext.cs
+++ b/src/Infrastructure/Database/Hc900DbContext.cs
@@ -265,6 +265,246 @@ public class Hc900DbContext : DbContext
            e.HasIndex(x => x.ExpiresAt);
        });
    }
+
+    // ── HC900 Point Builder ───────────────────────────────────────────────────
+
+    public async Task<int> Hc900BuildRealtimeTableAsync(
+        IEnumerable<(string GroupKey, Hc900PointBuilderGroupDto Group)> groups)
+    {
+        using var tx = await Database.BeginTransactionAsync();
+
+        try
+        {
+            await Database.ExecuteSqlRawAsync(
+                "UPDATE hc900_map_master SET is_active = false");
+
+            int total = 0;
+            foreach (var (groupKey, group) in groups)
+            {
+                var matched = await BuildGroupQuery(group).ToListAsync();
+                foreach (var entry in matched)
+                {
+                    entry.IsActive = true;
+                    total++;
+                }
+            }
+            await SaveChangesAsync();
+
+            await Hc900SyncRealtimeTableAsync();
+
+            await tx.CommitAsync();
+            return total;
+        }
+        catch
+        {
+            await tx.RollbackAsync();
+            throw;
+        }
+    }
+
+    public async Task<Hc900PointBuilderPreviewResult> Hc900PreviewRealtimeBuildAsync(
+        IEnumerable<(string GroupKey, Hc900PointBuilderGroupDto Group)> groups)
+    {
+        var items = new List<Hc900PointBuilderPreviewItem>();
+        foreach (var (groupKey, group) in groups)
+        {
+            var matched = await BuildGroupQuery(group)
+                .Select(e => new Hc900PointBuilderPreviewItem
+                {
+                    TagName      = e.TagName,
+                    Hc900Tag     = e.Hc900Tag,
+                    ModbusAddr   = e.ModbusAddr,
+                    ParamType    = e.ParamType ?? "",
+                    DataType     = e.DataType,
+                    LoopNo       = e.LoopNo,
+                    Access       = e.Access,
+                    ControllerId = e.ControllerId,
+                    Group        = groupKey,
+                    IsActive     = e.IsActive
+                })
+                .ToListAsync();
+            items.AddRange(matched);
+        }
+        return new Hc900PointBuilderPreviewResult { Count = items.Count, Items = items };
+    }
+
+    public async Task<int> Hc900ApplySelectedPointsAsync(IEnumerable<string> selectedTagNames)
+    {
+        var tagNames = selectedTagNames.Where(n => !string.IsNullOrEmpty(n)).ToList();
+        if (tagNames.Count == 0) return 0;
+
+        using var tx = await Database.BeginTransactionAsync();
+
+        try
+        {
+            await Database.ExecuteSqlRawAsync(
+                "UPDATE hc900_map_master SET is_active = false");
+
+            var count = await Hc900MapEntries
+                .Where(x => tagNames.Contains(x.TagName))
+                .ExecuteUpdateAsync(s => s.SetProperty(x => x.IsActive, true));
+
+            await Hc900SyncRealtimeTableAsync();
+
+            await tx.CommitAsync();
+            return count;
+        }
+        catch
+        {
+            await tx.RollbackAsync();
+            throw;
+        }
+    }
+
+    public async Task<int> Hc900AppendPointsAsync(IEnumerable<string> tagNames)
+    {
+        var tagNamesList = tagNames.Where(n => !string.IsNullOrEmpty(n)).ToList();
+        if (tagNamesList.Count == 0) return 0;
+
+        using var tx = await Database.BeginTransactionAsync();
+
+        try
+        {
+            var count = await Hc900MapEntries
+                .Where(x => tagNamesList.Contains(x.TagName) && !x.IsActive)
+                .ExecuteUpdateAsync(s => s.SetProperty(x => x.IsActive, true));
+
+            await Hc900SyncRealtimeTableAsync();
+
+            await tx.CommitAsync();
+            return count;
+        }
+        catch
+        {
+            await tx.RollbackAsync();
+            throw;
+        }
+    }
+
+    public async Task<RealtimePoint> Hc900AddRealtimePointAsync(
+        string tagName, string hc900Tag, int modbusAddr,
+        string dataType, string? paramType, string access, string controllerId)
+    {
+        var existing = await Hc900MapEntries
+            .FirstOrDefaultAsync(x => x.TagName == tagName && x.ControllerId == controllerId);
+
+        if (existing == null)
+        {
+            existing = new Hc900MapEntry
+            {
+                TagName      = tagName,
+                Hc900Tag     = hc900Tag ?? tagName,
+                ModbusAddr   = modbusAddr,
+                DataType     = dataType,
+                ParamType    = paramType,
+                Access       = access,
+                ControllerId = controllerId,
+                IsActive     = true
+            };
+            Hc900MapEntries.Add(existing);
+        }
+        else
+        {
+            existing.IsActive = true;
+        }
+        await SaveChangesAsync();
+
+        return await Hc900SyncSinglePointAsync(tagName, controllerId);
+    }
+
+    // ── Point Builder Helpers ─────────────────────────────────────────────────
+
+    private IQueryable<Hc900MapEntry> BuildGroupQuery(Hc900PointBuilderGroupDto group)
+    {
+        var q = Hc900MapEntries.AsQueryable();
+
+        if (group.TagPatterns?.Any() == true)
+        {
+            var patterns = group.TagPatterns.Where(p => !string.IsNullOrEmpty(p)).ToList();
+            if (patterns.Count > 0)
+            {
+                q = q.Where(x => patterns.Any(p => EF.Functions.ILike(x.TagName, $"%{p}%")));
+            }
+        }
+
+        if (group.ParamTypes?.Any() == true)
+        {
+            var validTypes = group.ParamTypes.Where(p => !string.IsNullOrEmpty(p)).ToList();
+            if (validTypes.Count > 0)
+                q = q.Where(x => validTypes.Contains(x.ParamType));
+        }
+
+        if (!string.IsNullOrEmpty(group.DataType))
+            q = q.Where(x => x.DataType == group.DataType);
+
+        if (group.LoopNo.HasValue)
+            q = q.Where(x => x.LoopNo == group.LoopNo.Value);
+
+        return q;
+    }
+
+    private async Task Hc900SyncRealtimeTableAsync()
+    {
+        var activeTags = await Hc900MapEntries
+            .Where(x => x.IsActive)
+            .Select(x => new { x.TagName, x.Hc900Tag, x.ControllerId })
+            .ToListAsync();
+
+        var activeTagNames = activeTags.Select(t => t.TagName).ToList();
+
+        var existingTagNames = await RealtimePoints
+            .Select(r => r.TagName)
+            .ToListAsync();
+
+        var toRemove = existingTagNames.Except(activeTagNames).ToList();
+        if (toRemove.Count > 0)
+        {
+            RealtimePoints.RemoveRange(
+                RealtimePoints.Where(r => toRemove.Contains(r.TagName)));
+        }
+
+        var toAddTagNames = activeTagNames.Except(existingTagNames).ToList();
+        if (toAddTagNames.Count > 0)
+        {
+            var toAdd = activeTags
+                .Where(t => toAddTagNames.Contains(t.TagName))
+                .Select(t => new RealtimePoint
+                {
+                    TagName      = t.TagName,
+                    NodeId       = t.Hc900Tag,
+                    LiveValue    = null,
+                    Timestamp    = DateTime.UtcNow,
+                    ControllerId = t.ControllerId
+                }).ToList();
+            RealtimePoints.AddRange(toAdd);
+        }
+
+        await SaveChangesAsync();
+    }
+
+    private async Task<RealtimePoint> Hc900SyncSinglePointAsync(string tagName, string controllerId)
+    {
+        var existing = await RealtimePoints
+            .FirstOrDefaultAsync(r => r.TagName == tagName && r.ControllerId == controllerId);
+        if (existing != null)
+        {
+            existing.Timestamp = DateTime.UtcNow;
+            await SaveChangesAsync();
+            return existing;
+        }
+
+        var point = new RealtimePoint
+        {
+            TagName      = tagName,
+            NodeId       = tagName,
+            LiveValue    = null,
+            Timestamp    = DateTime.UtcNow,
+            ControllerId = controllerId
+        };
+        RealtimePoints.Add(point);
+        await SaveChangesAsync();
+        return point;
+    }
 }

 // ── Service ──────────────────────────────────────────────────────────────────
@@ -274,12 +514,21 @@ public class Hc900DbService : IExperionDbService
    private readonly Hc900DbContext _ctx;
    private readonly ILogger<Hc900DbService> _logger;

-    private static HashSet<string> _digitalTagCache = new();
-    private static DateTime _digitalTagCacheTime = DateTime.MinValue;
-    private static Task? _cacheRefreshTask = null;
-    private static readonly object _digitalCacheLock = new();
    private const int DigitalTagCacheTtlSeconds = 300;

+    // archive_enabled = TRUE 인 (controller_id, tagname) 쌍 캐시.
+    // peer 통신으로 동일 tagname이 컨트롤러마다 다른 주소/플래그로 존재할 수 있어 컨트롤러 단위로 매칭한다.
+    private static HashSet<(string ControllerId, string TagName)> _archiveTagPairCache = new();
+    private static DateTime _archiveTagCacheTime = DateTime.MinValue;
+    private static Task? _archiveCacheRefreshTask = null;
+    private static readonly object _archiveCacheLock = new();
+
+    // 디지털 포인트 (controller_id, name) 쌍 캐시 — 위와 동일한 이유로 컨트롤러 단위 매칭.
+    private static HashSet<(string ControllerId, string Name)> _digitalTagPairCache = new();
+    private static DateTime _digitalTagPairCacheTime = DateTime.MinValue;
+    private static Task? _digitalPairCacheRefreshTask = null;
+    private static readonly object _digitalPairCacheLock = new();
+
    public Hc900DbService(Hc900DbContext ctx, ILogger<Hc900DbService> logger)
    {
        _ctx    = ctx;
@@ -453,7 +702,7 @@ public class Hc900DbService : IExperionDbService
            await _ctx.Database.ExecuteSqlRawAsync(
                "ALTER TABLE realtime_table ADD COLUMN IF NOT EXISTS controller_id TEXT NOT NULL DEFAULT 'HC1'");
            await _ctx.Database.ExecuteSqlRawAsync(
-                "ALTER TABLE history_table ADD COLUMN IF NOT EXISTS controller_id TEXT DEFAULT 'HC1'");
+                "ALTER TABLE history_table ADD COLUMN IF NOT EXISTS controller_id TEXT");
            await _ctx.Database.ExecuteSqlRawAsync(
                "ALTER TABLE event_history_table ADD COLUMN IF NOT EXISTS controller_id TEXT NOT NULL DEFAULT 'HC1'");
            await _ctx.Database.ExecuteSqlRawAsync(
@@ -461,6 +710,12 @@ public class Hc900DbService : IExperionDbService
            await _ctx.Database.ExecuteSqlRawAsync(
                "ALTER TABLE hc900_map_master ADD COLUMN IF NOT EXISTS controller_id TEXT NOT NULL DEFAULT 'HC1'");

+            // hc900_map_master: realtime_enabled / archive_enabled columns (register-map generation v2)
+            await _ctx.Database.ExecuteSqlRawAsync(
+                "ALTER TABLE hc900_map_master ADD COLUMN IF NOT EXISTS realtime_enabled BOOLEAN NOT NULL DEFAULT TRUE");
+            await _ctx.Database.ExecuteSqlRawAsync(
+                "ALTER TABLE hc900_map_master ADD COLUMN IF NOT EXISTS archive_enabled BOOLEAN NOT NULL DEFAULT FALSE");
+
            // hc900_map_master: tagname is unique PER controller, not globally — the same
            // SignalTag name can exist on several controllers (peer comms). Replace the old
            // UNIQUE(tagname) with UNIQUE(controller_id, tagname).
@@ -485,6 +740,32 @@ public class Hc900DbService : IExperionDbService
                END $$;
                """);

+            // tag_metadata: same base_tag/attribute can exist per controller (peer comms),
+            // so the unique key must include controller_id. The register-map loader upserts
+            // with ON CONFLICT(base_tag, attribute, controller_id); the old UNIQUE(base_tag,
+            // attribute) made every metadata upsert fail. Replace it.
+            await _ctx.Database.ExecuteSqlRawAsync("""
+                DO $$
+                BEGIN
+                    IF EXISTS (
+                        SELECT 1 FROM pg_constraint
+                        WHERE conrelid = 'tag_metadata'::regclass
+                          AND conname = 'tag_metadata_base_tag_attribute_key'
+                    ) THEN
+                        ALTER TABLE tag_metadata DROP CONSTRAINT tag_metadata_base_tag_attribute_key;
+                    END IF;
+                    IF NOT EXISTS (
+                        SELECT 1 FROM pg_constraint
+                        WHERE conrelid = 'tag_metadata'::regclass
+                          AND conname = 'tag_metadata_base_tag_attribute_controller_key'
+                    ) THEN
+                        ALTER TABLE tag_metadata
+                            ADD CONSTRAINT tag_metadata_base_tag_attribute_controller_key
+                            UNIQUE (base_tag, attribute, controller_id);
+                    END IF;
+                END $$;
+                """);
+
            // realtime_table: UNIQUE(controller_id, tagname) for ON CONFLICT upsert
            // Also drop the legacy tagname-only UNIQUE index/constraint that would
            // conflict with peer-mirrored tags (same tagname, different controller_id).
@@ -1566,16 +1847,24 @@ public class Hc900DbService : IExperionDbService
        if (!string.IsNullOrEmpty(controllerId))
            query = query.Where(p => p.ControllerId == controllerId);

+        var points = await query.ToListAsync();
+        if (points.Count == 0) return 0;
+
+        // archive_enabled = TRUE 인 (controller_id, tagname) 쌍만 아카이브.
+        // EF가 튜플 Contains를 SQL로 변환하지 못하므로 머티리얼라이즈 후 인메모리로 필터링한다
+        // (realtime_table은 수천 행 규모라 비용 무시 가능). 쌍이 비면(미설정/마이그레이션 전) 전체 아카이브 — 레거시 폴백.
+        var archivePairs = await GetArchiveEnabledTagPairsCachedAsync();
+        if (archivePairs.Count > 0)
+            points = points.Where(p => archivePairs.Contains((p.ControllerId, p.TagName))).ToList();
+
+        // 디지털 포인트 제외 — 동일하게 컨트롤러 단위 쌍 매칭.
        if (!includeDigital)
        {
-            var digitalTagNames = await GetDigitalTagNamesCachedAsync();
-            if (digitalTagNames.Count > 0)
-            {
-                query = query.Where(p => !digitalTagNames.Contains(p.TagName));
-            }
+            var digitalPairs = await GetDigitalTagPairsCachedAsync();
+            if (digitalPairs.Count > 0)
+                points = points.Where(p => !digitalPairs.Contains((p.ControllerId, p.TagName))).ToList();
        }

-        var points = await query.ToListAsync();
        if (points.Count == 0) return 0;

        var rows = points.Select(p => new HistoryRecord
@@ -1593,8 +1882,10 @@ public class Hc900DbService : IExperionDbService
        return saved;
    }

+    // 이력 조회 드롭다운용 — history_table에 실제 존재하는 태그만 반환한다.
+    // (realtime_table을 추종하면 history에 없는 폴링 태그까지 노출됨. idx_hist_tag로 DISTINCT는 수 ms.)
    public async Task<IEnumerable<string>> GetTagNamesAsync()
-        => await _ctx.RealtimePoints.Select(x => x.TagName).OrderBy(x => x).ToListAsync();
+        => await _ctx.HistoryRecords.Select(x => x.TagName).Distinct().OrderBy(x => x).ToListAsync();

    public async Task<HistoryQueryResult> QueryHistoryAsync(
        IEnumerable<string> tagNames, DateTime? from, DateTime? to, int limit)
@@ -1721,8 +2012,9 @@ public class Hc900DbService : IExperionDbService
        List<string> tags, DateTime? from, DateTime? to, string intervalStr, int limit)
    {
        var selectParts = new List<string>();
-        // time_bucket은 TimescaleDB 전용 함수 — PostgreSQL 내장 date_trunc로 대체
-        selectParts.Add($"date_trunc('second', recorded_at) AS time_bucket");
+        // date_trunc 단위를 intervalStr에서 추출 (예: "1 minute" → "minute")
+        var truncUnit = ParseIntervalToTruncUnit(intervalStr);
+        selectParts.Add($"date_trunc('{truncUnit}', recorded_at) AS time_bucket");

        // 태그명별로 동적으로 PIVOT 컬럼 생성 (MAX + CASE)
        foreach (var tag in tags)
@@ -1754,6 +2046,16 @@ public class Hc900DbService : IExperionDbService
        return sql;
    }

+    /// <summary>
+    /// intervalStr에서 date_trunc 단위 추출 (예: "1 minute" → "minute", "5 minutes" → "minute")
+    /// </summary>
+    private static string ParseIntervalToTruncUnit(string interval)
+    {
+        if (string.IsNullOrWhiteSpace(interval)) return "minute";
+        var m = System.Text.RegularExpressions.Regex.Match(interval.ToLower().Trim(), @"^\d+\s+(second|minute|hour|day|week)");
+        return m.Success ? m.Groups[1].Value : "minute";
+    }
+
    /// <summary>
    /// 사용자 입력 간격을 PostgreSQL INTERVAL 형식으로 변환
    /// 예: "1 minute" → "1 minute", "5 minutes" → "5 minutes", "1 hour" → "1 hour"
@@ -1981,15 +2283,21 @@ public class Hc900DbService : IExperionDbService

    public async Task<IEnumerable<string>> GetDigitalTagNamesAsync()
    {
+        // 디지털/상태 포인트 = tag_metadata에 state 라벨(state0~7)을 가진 base_tag.
+        // 값 N → state{N} 라벨(L-STOP/L-RUN/R-TRIP 등). 구 'i=7594' OPC UA 마커는
+        // 새 register-map 로더가 더 이상 생성하지 않으므로 state 라벨 보유를 기준으로 한다.
        var fromMetadata = await _ctx.TagMetadata
-            .Where(m => m.Value == "i=7594")
+            .Where(m => m.Attribute.StartsWith("state") && m.Value != null && m.Value != "")
            .Select(m => m.BaseTag)
            .Distinct()
            .ToListAsync();

        if (fromMetadata.Any())
-            return fromMetadata;
+            // 롤아웃 후 realtime 태그명은 {base}.PV 이므로 .PV 를 붙여 반환한다(메모리에서 —
+            // SQL 번역 불필요). 이러면 호출부는 단순 Contains(p.TagName) 만으로 매칭 가능.
+            return fromMetadata.Select(b => b + ".PV").ToList();

+        // 폴백: realtime livevalue가 '{N | label | }' (FormatValue가 만든 디지털 포맷)
        return await _ctx.RealtimePoints
            .Where(p => p.LiveValue != null && p.LiveValue.StartsWith("{"))
            .Select(p => p.TagName)
@@ -2005,6 +2313,8 @@ public class Hc900DbService : IExperionDbService
        if (tagSet.Count == 0)
            return Enumerable.Empty<RealtimePoint>();

+        // digitalTagNames 는 이미 .PV 명이므로 단순 Contains — substring/LastIndexOf 불필요
+        // (LastIndexOf 는 Npgsql 이 SQL 로 번역하지 못해 런타임 에러를 일으킴).
        return await _ctx.RealtimePoints
            .Where(p => tagSet.Contains(p.TagName))
            .ToListAsync();
@@ -2032,7 +2342,7 @@ public class Hc900DbService : IExperionDbService
    {
        var baseTag = tagName.Contains('.') ? tagName[..tagName.LastIndexOf('.')] : tagName;
        return await _ctx.TagMetadata
-            .Where(m => m.BaseTag.Equals(baseTag, StringComparison.OrdinalIgnoreCase) && m.Attribute == "sub_area")
+            .Where(m => m.BaseTag == baseTag && m.Attribute == "sub_area")
            .Select(m => m.Value)
            .FirstOrDefaultAsync();
    }
@@ -2374,34 +2684,91 @@ public class Hc900DbService : IExperionDbService
        });
    }

-    private async Task<HashSet<string>> GetDigitalTagNamesCachedAsync()
+    // ── archive_enabled (controller_id, tagname) 쌍 캐시 ─────────────────────────
+    private async Task<HashSet<(string, string)>> GetArchiveEnabledTagPairsCachedAsync()
    {
-        if ((DateTime.UtcNow - _digitalTagCacheTime).TotalSeconds < DigitalTagCacheTtlSeconds)
-            return _digitalTagCache;
+        if ((DateTime.UtcNow - _archiveTagCacheTime).TotalSeconds < DigitalTagCacheTtlSeconds)
+            return _archiveTagPairCache;

        Task refreshTask;
-        lock (_digitalCacheLock)
+        lock (_archiveCacheLock)
        {
-            if (_cacheRefreshTask == null)
-                _cacheRefreshTask = RefreshDigitalTagCacheAsync();
-            refreshTask = _cacheRefreshTask;
+            if (_archiveCacheRefreshTask == null)
+                _archiveCacheRefreshTask = RefreshArchiveTagCacheAsync();
+            refreshTask = _archiveCacheRefreshTask;
        }

        await refreshTask;

-        lock (_digitalCacheLock)
+        lock (_archiveCacheLock)
        {
-            _cacheRefreshTask = null;
+            _archiveCacheRefreshTask = null;
        }

-        return _digitalTagCache;
+        return _archiveTagPairCache;
    }

-    private async Task RefreshDigitalTagCacheAsync()
+    private async Task RefreshArchiveTagCacheAsync()
    {
-        var tags = await GetDigitalTagNamesAsync();
-        _digitalTagCache = new HashSet<string>(tags);
-        _digitalTagCacheTime = DateTime.UtcNow;
+        var rows = await _ctx.Hc900MapEntries
+            .Where(m => m.ArchiveEnabled && m.IsActive)
+            .Select(m => new { m.ControllerId, m.TagName })
+            .Distinct()
+            .ToListAsync();
+        _archiveTagPairCache = rows.Select(r => (r.ControllerId, r.TagName)).ToHashSet();
+        _archiveTagCacheTime = DateTime.UtcNow;
+    }
+
+    // ── 디지털 포인트 (controller_id, name) 쌍 캐시 ──────────────────────────────
+    private async Task<HashSet<(string, string)>> GetDigitalTagPairsCachedAsync()
+    {
+        if ((DateTime.UtcNow - _digitalTagPairCacheTime).TotalSeconds < DigitalTagCacheTtlSeconds)
+            return _digitalTagPairCache;
+
+        Task refreshTask;
+        lock (_digitalPairCacheLock)
+        {
+            if (_digitalPairCacheRefreshTask == null)
+                _digitalPairCacheRefreshTask = RefreshDigitalTagPairCacheAsync();
+            refreshTask = _digitalPairCacheRefreshTask;
+        }
+
+        await refreshTask;
+
+        lock (_digitalPairCacheLock)
+        {
+            _digitalPairCacheRefreshTask = null;
+        }
+
+        return _digitalTagPairCache;
+    }
+
+    private async Task RefreshDigitalTagPairCacheAsync()
+    {
+        _digitalTagPairCache = await GetDigitalTagPairsAsync();
+        _digitalTagPairCacheTime = DateTime.UtcNow;
+    }
+
+    /// <summary>디지털 태그를 (controller_id, name) 쌍으로 조회.
+    /// GetDigitalTagNamesAsync 와 동일한 소스(메타데이터 state 라벨 보유 base_tag,
+    /// 폴백: realtime live "{")에 controller_id 차원만 추가한 버전.</summary>
+    private async Task<HashSet<(string, string)>> GetDigitalTagPairsAsync()
+    {
+        var fromMetadata = await _ctx.TagMetadata
+            .Where(m => m.Attribute.StartsWith("state") && m.Value != null && m.Value != "")
+            .Select(m => new { m.ControllerId, m.BaseTag })
+            .Distinct()
+            .ToListAsync();
+
+        if (fromMetadata.Any())
+            return fromMetadata.Select(m => (m.ControllerId, m.BaseTag + ".PV")).ToHashSet();
+
+        var fromRealtime = await _ctx.RealtimePoints
+            .Where(p => p.LiveValue != null && p.LiveValue.StartsWith("{"))
+            .Select(p => new { p.ControllerId, p.TagName })
+            .Distinct()
+            .ToListAsync();
+        return fromRealtime.Select(p => (p.ControllerId, p.TagName)).ToHashSet();
    }

    /// <summary>
--- a/src/Infrastructure/Hc900/Hc900RealtimeService.cs
+++ b/src/Infrastructure/Hc900/Hc900RealtimeService.cs
@@ -140,7 +140,7 @@ public class Hc900RealtimeService : BackgroundService, IHc900RealtimeService
            await using var conn = new NpgsqlConnection(_connectionString);
            await conn.OpenAsync(ct);
            await using var cmd = new NpgsqlCommand(
-                "SELECT tagname, hc900_tag FROM hc900_map_master WHERE is_active = TRUE AND controller_id = $1", conn);
+                "SELECT tagname, hc900_tag FROM hc900_map_master WHERE is_active = TRUE AND realtime_enabled = TRUE AND controller_id = $1", conn);
            cmd.Parameters.Add(new NpgsqlParameter { Value = controllerId });
            await using var reader = await cmd.ExecuteReaderAsync(ct);
            while (await reader.ReadAsync(ct))