From 48a6b6be574a592526ec44a1dce1ccab2dd6479f Mon Sep 17 00:00:00 2001
From: windpacer <windpacer@windpacer.co.kr>
Date: Sun, 31 May 2026 17:31:47 +0900
Subject: [PATCH] =?UTF-8?q?docs:=20=EC=B8=A1=EB=A5=98=EC=B6=94=EC=B6=9C=20?=
 =?UTF-8?q?=ED=86=B5=ED=95=A9=EC=9C=A0=EB=9F=89=EC=84=A4=EC=A0=95=EA=B3=B5?=
 =?UTF-8?q?=EC=8B=9D=20=EC=84=A4=EA=B3=84=EB=AC=B8=EC=84=9C=20(Phase=20I/I?=
 =?UTF-8?q?I/III=20+=20=EB=B6=84=EC=84=9D=EC=97=94=EC=A7=84)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...��추출식-통합유량설정공식-구현코딩-PhaseI.md | 1067 +++++++++++++++
 ...량설정공식-구현코딩-PhaseII-분석엔진+전환류복귀.md |  439 +++++++
 ...�추출식-통합유량설정공식-구현코딩-PhaseII.md |  514 ++++++++
 ...추출식-통합유량설정공식-구현코딩-PhaseIII.md |  337 +++++
 docs/측류추출식-통합유량설정공식.md           | 1168 +++++++++++++++++
 5 files changed, 3525 insertions(+)
 create mode 100644 docs/측류추출식-통합유량설정공식-구현코딩-PhaseI.md
 create mode 100644 docs/측류추출식-통합유량설정공식-구현코딩-PhaseII-분석엔진+전환류복귀.md
 create mode 100644 docs/측류추출식-통합유량설정공식-구현코딩-PhaseII.md
 create mode 100644 docs/측류추출식-통합유량설정공식-구현코딩-PhaseIII.md
 create mode 100644 docs/측류추출식-통합유량설정공식.md

diff --git a/docs/측류추출식-통합유량설정공식-구현코딩-PhaseI.md b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseI.md
new file mode 100644
index 0000000..4ddd833
--- /dev/null
+++ b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseI.md
@@ -0,0 +1,1067 @@
+# 측류추출 통합유량 — §12 엔진 구현 코딩 (Phase I)
+
+> **본 문서의 성격**: `측류추출식-통합유량설정공식.md` §12(advisory 엔진)의 **구현 코딩 명세 + 검증 절차**.
+> **감독자(auditor)가 `diagnosis-checklist.md` 8단계로 진단한 뒤 실제 프로젝트에 반영**한다.
+> **진단 통과 전에는 DI 등록·빌드 편입 금지** (코드는 신규 파일로만 존재, 기존 동작 무영향).
+
+**전제(불변식)**: 본 Phase는 **advisory(보조지표) 전용** — 제어 레지스터(SP/OP)에 **쓰기 호출 0건**.
+AUTO/MANUAL **무관**하게 권장 SP를 계산해 저장·표시만 한다. RSP 쓰기는 Phase III.
+
+---
+
+## 0. Phase 분할 (무엇을 지금 코딩하나)
+
+| 범위 | Phase I (본 문서, 코드) | Phase II (플랜) | Phase III (플랜) |
+|:-----|:----|:----|:----|
+| 순수 연산블록 | EMA/MA·DeadTimeBuffer·FirstOrderLag·RateLimiter(비대칭)·Clamp·Derivative·PressureComp | CrossCorrLagEstimator·DiffTemp·FrontPositionIndicator | — |
+| 엔진 | `FeedforwardEngine.Tick`(role-aware, 과도게이트, confidence) | θ 자동튜닝·느린 바이어스 적응·analyzer corroborate | — |
+| 수급 | realtime_table PV 읽기 + AdvisoryStore | — | RSP 쓰기 + WriteGuard + 워치독·데드맨 |
+| 설정 | DB 테이블 + 로더 | Web UI 설정/대시보드(Tab 18) | 운전원 채택 스위치 |
+| 출력 | 권장 SP 저장 + 읽기 API | 화면 시각화 | 컨트롤러 SP 추종 |
+
+§13(온도기반 θ/sweet-spot)·§14(오차예산 등급·계절 바이어스)의 **보정 항목은 §6 플랜**에 매핑.
+
+---
+
+## 1. 파일 배치 & 네임스페이스 (신규만)
+
+```
+src/Core/Application/Feedforward/
+  FeedforwardModels.cs          # enum·ColumnConfig·StreamConfig·PvSnapshot·AdvisoryResult (record)
+  IFeedforwardStores.cs         # IFeedforwardConfigStore·IFeedforwardAdvisoryStore
+src/Infrastructure/Control/
+  ComputationBlocks.cs          # 순수 연산블록 (단위테스트 대상)
+  FeedforwardEngine.cs          # Tick (순수 함수, I/O 없음)
+  FeedforwardSupervisor.cs      # BackgroundService — PV 읽기→Tick→저장 (쓰기 없음)
+  FeedforwardAdvisoryStore.cs   # in-memory 최신 결과
+  FeedforwardConfigStore.cs     # DB 로더 (ff_column_config / ff_stream_config)
+src/Web/Controllers/
+  FeedforwardController.cs       # GET advisory/config (camelCase), admin config CRUD
+tests/ (또는 신규 테스트 프로젝트)
+  FeedforwardBlocksTests.cs / FeedforwardEngineTests.cs
+```
+
+네임스페이스: `ExperionCrawler.Core.Application.Feedforward`, `ExperionCrawler.Infrastructure.Control`,
+컨트롤러는 `ExperionCrawler.Web.Controllers`.
+
+### 1.1 프로젝트 구조 전제 (G1) ★
+
+- **단일 프로젝트**: 앱 코드는 전부 **`src/Web/ExperionCrawler.csproj`**(`Microsoft.NET.Sdk.Web`) 하나로 컴파일된다.
+  `src/Core`·`src/Infrastructure`·`src/Web`는 **폴더일 뿐 별도 csproj가 아니다.**
+- 따라서 위 신규 파일들은 **새 csproj·ProjectReference를 만들지 말고** 해당 폴더에 추가만 하면 같은 프로젝트로 빌드된다.
+- 빌드: `dotnet build src/Web/ExperionCrawler.csproj` (솔루션 파일 없음).
+- 단, **테스트 프로젝트만** 별도 csproj로 신설한다(§5.7).
+
+---
+
+## 2. 코드 — Core 모델 (`FeedforwardModels.cs`)
+
+```csharp
+namespace ExperionCrawler.Core.Application.Feedforward;
+
+/// <summary>스트림 역할. §9.3 D5: 레벨 폐루프가 있으면 D·B는 LevelDriven.</summary>
+public enum StreamRole { Commanded, LevelDriven, Monitor }
+
+/// <summary>보정 신뢰도 등급. §14.3 A 견고 / B 한계 / C 취약.</summary>
+public enum Confidence { A, B, C }
+
+/// <summary>스트림(유량 1개) 설정. 경험상수는 Web UI(Phase II)에서 공급, DB 저장.</summary>
+public sealed record StreamConfig
+{
+    public string     Key          { get; init; } = "";   // 논리명: "D","P","B","R"
+    public string     FlowTag      { get; init; } = "";   // realtime base tag: "ficq-6118"
+    public StreamRole Role         { get; init; } = StreamRole.Monitor;
+    public double     TargetCoeff  { get; init; }          // K_t (commanded/levelDriven), 또는 R_f(reflux)
+    public double     ThetaUpSec   { get; init; }          // 전달 데드타임(피드 상승), D7 비대칭
+    public double     ThetaDnSec   { get; init; }          // 전달 데드타임(피드 하강)
+    public double     TauSec       { get; init; }          // 1차 지체
+    public double     SpMin        { get; init; }
+    public double     SpMax        { get; init; } = double.MaxValue;
+    public double     RateUpPerMin { get; init; } = double.MaxValue;
+    public double     RateDnPerMin { get; init; } = double.MaxValue;
+    public bool       RefluxFromProduct { get; init; }     // R = R_f × P_sp
+    public Confidence Grade        { get; init; } = Confidence.A;
+}
+
+/// <summary>컬럼 1개 설정. 다중 컬럼 공유 — 새 컬럼 = row 추가만.</summary>
+public sealed record ColumnConfig
+{
+    public int     Id           { get; init; }
+    public string  Name         { get; init; } = "";
+    public bool    Enabled      { get; init; }
+    public bool    AdvisoryOnly { get; init; } = true;     // Phase I 강제 true
+    public string  FeedTag      { get; init; } = "";       // base tag (".pv"는 로더가 부착)
+    public string? PressureTag  { get; init; }
+    public IReadOnlyList<string> LevelTags { get; init; } = Array.Empty<string>();
+    public double  ScanSec               { get; init; } = 2.0;
+    public double  FeedFilterTauSec      { get; init; } = 300.0;  // §11.5 노이즈 필터
+    public double  FeedMoveThresholdPerMin { get; init; } = 0.0;  // 과도 판정(0=비활성)
+    public double  PressFilterTauSec      { get; init; } = 60.0;  // 압력 1차저역통과 시정수(초) — 원시압력 대비 필터값이 PressureBand 이상 벗어나면 과도판정
+    public double  PressureBand          { get; init; } = double.MaxValue;
+    public double  SettleSec             { get; init; } = 0.0;    // T_SETTLE
+    public double  StaleSec              { get; init; } = 120.0;  // PV 신선도 한계
+    public string? ProductKey            { get; init; } = "P";    // reflux 참조 대상
+    public IReadOnlyList<StreamConfig> Streams { get; init; } = Array.Empty<StreamConfig>();
+}
+
+/// <summary>읽은 PV 1개 (신선도·품질 포함).</summary>
+public sealed record TagSample(string Tag, double Value, bool Good, DateTime Timestamp);
+
+/// <summary>한 스캔의 입력 스냅샷.</summary>
+public sealed record PvSnapshot(
+    TagSample Feed,
+    TagSample? Pressure,
+    IReadOnlyList<TagSample> Levels,
+    IReadOnlyDictionary<string, TagSample> Streams);   // key = StreamConfig.Key
+
+/// <summary>스트림별 권장 결과.</summary>
+public sealed record StreamAdvisory(
+    string Key, string FlowTag, StreamRole Role,
+    double Pv, double? RecommendedSp, double? Gap,
+    int Trend,           // -1 하강 / 0 / +1 상승
+    bool Valid,          // 과도 중이면 false("정착 대기")
+    Confidence Grade,
+    string Note);
+
+/// <summary>컬럼 1회 Tick 결과 (저장·표시 전용).</summary>
+public sealed record AdvisoryResult(
+    int ColumnId, string ColumnName, DateTime ComputedAt,
+    bool Enabled, bool Transient, string TransientReason,
+    double FeedFiltered,
+    IReadOnlyList<StreamAdvisory> Streams,
+    double? VLoss, double? Yield, string MassBalanceState);
+```
+
+---
+
+## 3. 코드 — 순수 연산블록 (`ComputationBlocks.cs`)
+
+> 모두 **I/O 없음·결정론적** → 단위테스트 용이. 각 인스턴스는 **단일 스레드(엔진 루프)** 소유 → 락 불필요.
+
+```csharp
+namespace ExperionCrawler.Infrastructure.Control;
+
+public static class Num
+{
+    public static double Clamp(double x, double lo, double hi) => Math.Max(lo, Math.Min(hi, x));
+    public static bool   IsFinite(double x) => !double.IsNaN(x) && !double.IsInfinity(x);
+}
+
+/// <summary>1차 저역통과(EMA). DCS Lag/Filter 블록 등가.</summary>
+public sealed class FirstOrderLag
+{
+    private double _y;
+    private bool   _seeded;
+    public double Value => _y;
+    public bool   Seeded => _seeded;
+    public void   Seed(double v) { _y = v; _seeded = true; }
+    public double Step(double x, double tauSec, double tsSec)
+    {
+        if (!_seeded) { Seed(x); return _y; }
+        if (tauSec <= 0.0) { _y = x; return _y; }
+        var a = tsSec / (tauSec + tsSec);     // 0<a<1
+        _y += (x - _y) * a;
+        return _y;
+    }
+}
+
+/// <summary>진짜 윈도우 이동평균(MA). 노이즈 제거 대안(§11.5). DCS가 구현 어려운 블록.</summary>
+public sealed class MovingAverage
+{
+    private readonly Queue<double> _buf = new();
+    private readonly int _window;
+    private double _sum;
+    public MovingAverage(int windowSamples) => _window = Math.Max(1, windowSamples);
+    public double Push(double x)
+    {
+        _buf.Enqueue(x); _sum += x;
+        while (_buf.Count > _window) _sum -= _buf.Dequeue();
+        return _sum / _buf.Count;
+    }
+}
+
+/// <summary>가변 전달지연(데드타임) 링버퍼. 용량은 요청된 최대 n 으로 **증가만**(축소 금지),
+/// θ(=n)가 스캔마다 바뀌어도(비대칭 θup/θdn, D7) **읽기 오프셋만 가변** — 히스토리 보존.
+/// ※ 진단 정정(2026-05-30): n 변경 시 Resize-재시드하던 초안은 비대칭 θ에서 부호반전마다 지연선 소실 → 폐기.</summary>
+public sealed class DeadTimeBuffer
+{
+    private double[] _buf = Array.Empty<double>();   // 항상 가득 찬 링(시드 사전충전)
+    private int  _cap;                                // 용량(보존 샘플 수). 증가만.
+    private int  _head;                               // 다음 덮어쓸 위치(=가장 오래된)
+    private bool _seeded;
+
+    public double Through(double x, double thetaSec, double tsSec)
+    {
+        int n = (int)Math.Round(thetaSec / Math.Max(1e-6, tsSec));
+        if (n <= 0) return x;                         // θ<ts → 지연 없음
+        EnsureCapacity(n + 1, x);                     // n 샘플 지연 → n+1 슬롯
+        _buf[_head] = x;                              // 가장 오래된 자리에 현재값
+        int newest = _head;
+        _head = (_head + 1) % _cap;
+        int idx = ((newest - n) % _cap + _cap) % _cap;
+        return _buf[idx];                             // n 스캔 전 값
+    }
+
+    private void EnsureCapacity(int need, double seed)
+    {
+        if (_seeded && need <= _cap) return;          // 축소·재시드 없음
+        int newCap = Math.Max(need, Math.Max(_cap, 1));
+        var nb = new double[newCap];
+        if (!_seeded) Array.Fill(nb, seed);           // 최초: bumpless 사전충전
+        else
+        {
+            int extra = newCap - _cap;
+            double oldest = _buf[_head];
+            for (int i = 0; i < extra; i++) nb[i] = oldest;                       // 앞쪽 패딩
+            for (int k = 0; k < _cap; k++) nb[extra + k] = _buf[(_head + k) % _cap]; // 오래된→최신
+        }
+        _buf = nb; _cap = newCap; _head = 0; _seeded = true;
+    }
+}
+
+/// <summary>비대칭 변화율 제한(/min). §11.4 D7 (up≠dn).</summary>
+public sealed class RateLimiter
+{
+    private double _last;
+    private bool   _seeded;
+    public double Last => _last;
+    public void   Seed(double v) { _last = v; _seeded = true; }
+    public double Step(double target, double rateUpPerMin, double rateDnPerMin, double tsSec)
+    {
+        if (!_seeded) { Seed(target); return _last; }
+        var up = Math.Abs(rateUpPerMin) * tsSec / 60.0;
+        var dn = Math.Abs(rateDnPerMin) * tsSec / 60.0;
+        var d  = Num.Clamp(target - _last, -dn, up);
+        _last += d;
+        return _last;
+    }
+}
+
+/// <summary>per-second 미분(dF/dt, dM/dt).</summary>
+public sealed class Derivative
+{
+    private double _prev;
+    private bool   _seeded;
+    public double Update(double x, double tsSec)
+    {
+        if (!_seeded) { _prev = x; _seeded = true; return 0.0; }
+        var d = (x - _prev) / Math.Max(1e-6, tsSec);
+        _prev = x;
+        return d;
+    }
+}
+
+/// <summary>압력보정온도 PCT = T - dTdP·(P-Pref). §13.3 (Phase I는 모니터 보조).</summary>
+public static class TempCorrection
+{
+    public static double PressureCompensated(double tMeas, double p, double pRef, double dTdP)
+        => tMeas - dTdP * (p - pRef);
+}
+```
+
+---
+
+## 4. 코드 — 엔진 (`FeedforwardEngine.cs`)
+
+> **순수 함수**: I/O·시간·DB 접근 없음. 입력=cfg·snapshot·state, 출력=AdvisoryResult.
+> 상태(`ColumnState`)는 호출자(Supervisor)가 컬럼별 1개 보유 → 컬럼 간 격리.
+
+```csharp
+using ExperionCrawler.Core.Application.Feedforward;
+
+namespace ExperionCrawler.Infrastructure.Control;
+
+public sealed class StreamState
+{
+    public DeadTimeBuffer Dead { get; } = new();
+    public FirstOrderLag  Lag  { get; } = new();
+    public RateLimiter    Rate { get; } = new();
+    public double LastRec { get; set; } = double.NaN;
+}
+
+public sealed class ColumnState
+{
+    public FirstOrderLag FeedFilter  { get; } = new();
+    public FirstOrderLag PressFilter { get; } = new();
+    public Derivative    FeedDeriv   { get; } = new();
+    public double        SettleTimerSec { get; set; }
+    public bool          Initialized { get; set; }
+    public Dictionary<string, StreamState> Streams { get; } = new();
+
+    public StreamState Stream(string key)
+    {
+        if (!Streams.TryGetValue(key, out var s)) { s = new StreamState(); Streams[key] = s; }
+        return s;
+    }
+}
+
+public sealed class FeedforwardEngine
+{
+    public AdvisoryResult Tick(ColumnConfig cfg, PvSnapshot pv, ColumnState st, DateTime now)
+    {
+        var ts = cfg.ScanSec;
+
+        // ── 0) FEED 품질 게이트 → BAD면 직전 권장 홀드 ──────────────────────
+        if (!pv.Feed.Good || !Num.IsFinite(pv.Feed.Value))
+            return Hold(cfg, st, now, "FEED BAD");
+
+        // ── 1) FEED 노이즈 필터 ─────────────────────────────────────────────
+        var ff = st.FeedFilter.Step(pv.Feed.Value, cfg.FeedFilterTauSec, ts);
+
+        // 최초 정상값으로 bumpless 시드
+        if (!st.Initialized) { SeedAll(cfg, pv, st, ff); st.Initialized = true; }
+
+        // ── 2) 과도/압력 게이트 (§11.6 D6·D11) ──────────────────────────────
+        var  dF       = st.FeedDeriv.Update(ff, ts);                 // per sec
+        bool moving   = cfg.FeedMoveThresholdPerMin > 0
+                        && Math.Abs(dF) * 60.0 > cfg.FeedMoveThresholdPerMin;
+        bool pUnstable = false;
+        if (pv.Pressure is { Good: true } pp && Num.IsFinite(pp.Value))
+        {
+            var pf = st.PressFilter.Step(pp.Value, cfg.PressFilterTauSec, ts);
+            pUnstable = Math.Abs(pp.Value - pf) > cfg.PressureBand;
+        }
+        if (moving || pUnstable) st.SettleTimerSec = cfg.SettleSec;
+        else                     st.SettleTimerSec = Math.Max(0.0, st.SettleTimerSec - ts);
+        bool   transient = moving || pUnstable || st.SettleTimerSec > 0.0;
+        string treason   = moving ? "FEED 이동"
+                         : pUnstable ? "압력 불안정"
+                         : st.SettleTimerSec > 0.0 ? $"정착 대기 {st.SettleTimerSec:F0}s" : "";
+
+        // ── 3) 스트림별 권장값 (2-pass: reflux는 P 권장 참조) ───────────────
+        var outs       = new List<StreamAdvisory>(cfg.Streams.Count);
+        double? prodRec = null;
+
+        foreach (var s in cfg.Streams)
+        {
+            if (s.RefluxFromProduct) continue;                       // pass2에서
+            var (rec, note) = ComputeStream(s, ff, dF, ts, st.Stream(s.Key));
+            if (s.Key == cfg.ProductKey) prodRec = rec;
+            outs.Add(BuildAdvisory(s, pv, rec, note, transient, st.Stream(s.Key)));
+        }
+        foreach (var s in cfg.Streams)
+        {
+            if (!s.RefluxFromProduct) continue;
+            var stt = st.Stream(s.Key);
+            double? rec = null;
+            if (prodRec is double p)
+            {
+                var raw = Num.Clamp(s.TargetCoeff * p, s.SpMin, s.SpMax);
+                rec = stt.Rate.Step(raw, s.RateUpPerMin, s.RateDnPerMin, ts);
+            }
+            outs.Add(BuildAdvisory(s, pv, rec, "외부환류 R=R_f×P (P 지연 상속)", transient, stt));
+        }
+
+        // ── 4) 물질수지 모니터 (정상상태에서만, §10.6·§11.6) ────────────────
+        double? vloss = null, yield = null;
+        string  mbState;
+        if (transient)
+            mbState = $"정착 대기 ({st.SettleTimerSec:F0}s)";
+        else if (TryStreamPv(pv, "D", out var d) && TryStreamPv(pv, "P", out var pp2)
+              && TryStreamPv(pv, "B", out var b) && ff > 1e-6)
+        {
+            vloss   = ff - (d + pp2 + b);
+            yield   = 100.0 * pp2 / ff;
+            mbState = Math.Abs(vloss.Value) > 0.03 * ff ? "물질수지 불일치(계측 점검)"
+                    : vloss.Value < 0                   ? "음의 손실(스팬 오류 의심)"
+                    : "정상";
+        }
+        else mbState = "입력 부족";
+
+        return new AdvisoryResult(cfg.Id, cfg.Name, now, cfg.Enabled,
+            transient, treason, ff, outs, vloss, yield, mbState);
+    }
+
+    // ── helpers ─────────────────────────────────────────────────────────────
+
+    private static (double? rec, string note) ComputeStream(
+        StreamConfig s, double ff, double dF, double ts, StreamState stt)
+    {
+        switch (s.Role)
+        {
+            case StreamRole.Commanded:
+                double theta = dF >= 0 ? s.ThetaUpSec : s.ThetaDnSec;   // D7 비대칭
+                double fd    = stt.Dead.Through(ff, theta, ts);
+                fd           = stt.Lag.Step(fd, s.TauSec, ts);
+                double raw   = Num.Clamp(s.TargetCoeff * fd, s.SpMin, s.SpMax);
+                double rec   = stt.Rate.Step(raw, s.RateUpPerMin, s.RateDnPerMin, ts);
+                return (rec, "");
+            case StreamRole.LevelDriven:
+                return (s.TargetCoeff * ff, "레벨 제어 구동 — 기대치(deadtime 미적용)");  // §9.3 D5
+            default: // Monitor
+                return (null, "모니터(SP 없음)");
+        }
+    }
+
+    private static StreamAdvisory BuildAdvisory(
+        StreamConfig s, PvSnapshot pv, double? rec, string note, bool transient, StreamState stt)
+    {
+        double curPv = pv.Streams.TryGetValue(s.Key, out var smp) && smp.Good ? smp.Value : double.NaN;
+        int    trend = rec is double r && Num.IsFinite(stt.LastRec)
+                       ? Math.Sign(r - stt.LastRec) : 0;
+        if (rec is double rr) stt.LastRec = rr;
+        double? gap = (rec is double g && Num.IsFinite(curPv)) ? g - curPv : null;
+        return new StreamAdvisory(s.Key, s.FlowTag, s.Role, curPv, rec, gap, trend,
+            valid: !transient && s.Role != StreamRole.Monitor, s.Grade, note);
+    }
+
+    private static bool TryStreamPv(PvSnapshot pv, string key, out double v)
+    {
+        v = double.NaN;
+        if (pv.Streams.TryGetValue(key, out var s) && s.Good && Num.IsFinite(s.Value)) { v = s.Value; return true; }
+        return false;
+    }
+
+    private static void SeedAll(ColumnConfig cfg, PvSnapshot pv, ColumnState st, double ff)
+    {
+        st.FeedDeriv.Update(ff, cfg.ScanSec);
+        foreach (var s in cfg.Streams)
+        {
+            var stt = st.Stream(s.Key);
+            double seed = pv.Streams.TryGetValue(s.Key, out var smp) && smp.Good ? smp.Value : ff * s.TargetCoeff;
+            stt.Lag.Seed(seed);
+            stt.Rate.Seed(seed);
+            stt.LastRec = seed;
+        }
+    }
+
+    private AdvisoryResult Hold(ColumnConfig cfg, ColumnState st, DateTime now, string reason)
+    {
+        var outs = cfg.Streams.Select(s =>
+        {
+            var stt = st.Stream(s.Key);
+            double? rec = Num.IsFinite(stt.LastRec) ? stt.LastRec : (double?)null;
+            return new StreamAdvisory(s.Key, s.FlowTag, s.Role, double.NaN, rec, null, 0,
+                valid: false, s.Grade, $"홀드: {reason}");
+        }).ToList();
+        return new AdvisoryResult(cfg.Id, cfg.Name, now, cfg.Enabled, true, reason,
+            st.FeedFilter.Value, outs, null, null, $"홀드: {reason}");
+    }
+}
+```
+
+---
+
+## 5. 코드 — 수급/저장/Supervisor
+
+### 5.1 Stores (`IFeedforwardStores.cs`)
+
+```csharp
+namespace ExperionCrawler.Core.Application.Feedforward;
+
+public interface IFeedforwardConfigStore
+{
+    Task<IReadOnlyList<ColumnConfig>> LoadAllAsync(CancellationToken ct = default);
+}
+
+public interface IFeedforwardAdvisoryStore
+{
+    void Set(AdvisoryResult result);
+    AdvisoryResult? Get(int columnId);
+    IReadOnlyCollection<AdvisoryResult> GetAll();
+}
+```
+
+### 5.2 In-memory advisory store (`FeedforwardAdvisoryStore.cs`)
+
+```csharp
+using System.Collections.Concurrent;
+using ExperionCrawler.Core.Application.Feedforward;
+
+namespace ExperionCrawler.Infrastructure.Control;
+
+public sealed class FeedforwardAdvisoryStore : IFeedforwardAdvisoryStore
+{
+    private readonly ConcurrentDictionary<int, AdvisoryResult> _latest = new();
+    public void Set(AdvisoryResult r) => _latest[r.ColumnId] = r;   // 단일 writer(Supervisor)
+    public AdvisoryResult? Get(int id) => _latest.TryGetValue(id, out var r) ? r : null;
+    public IReadOnlyCollection<AdvisoryResult> GetAll() => _latest.Values.ToArray();
+}
+```
+
+### 5.3 Supervisor (`FeedforwardSupervisor.cs`) — 쓰기 없음
+
+```csharp
+using ExperionCrawler.Core.Application.Feedforward;
+using ExperionCrawler.Core.Application.Interfaces;
+using ExperionCrawler.Core.Domain.Entities;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using System.Globalization;
+
+namespace ExperionCrawler.Infrastructure.Control;
+
+public sealed class FeedforwardSupervisor : BackgroundService
+{
+    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly FeedforwardEngine     _engine;
+    private readonly IFeedforwardAdvisoryStore _store;
+    private readonly ILogger<FeedforwardSupervisor> _logger;
+    private readonly Dictionary<int, ColumnState> _states = new();   // 컬럼별 상태(단일 루프 소유)
+
+    public FeedforwardSupervisor(
+        IServiceScopeFactory scopeFactory, FeedforwardEngine engine,
+        IFeedforwardAdvisoryStore store, ILogger<FeedforwardSupervisor> logger)
+    { _scopeFactory = scopeFactory; _engine = engine; _store = store; _logger = logger; }
+
+    protected override async Task ExecuteAsync(CancellationToken ct)
+    {
+        // 부팅 비블로킹: 잠깐 양보 후 진입 (ExperionRealtimeService 패턴)
+        await Task.Yield();
+        while (!ct.IsCancellationRequested)
+        {
+            double minScan = 2.0;
+            try
+            {
+                using var scope = _scopeFactory.CreateScope();
+                var cfgStore = scope.ServiceProvider.GetRequiredService<IFeedforwardConfigStore>();
+                var db       = scope.ServiceProvider.GetRequiredService<IExperionDbService>();
+
+                var columns = await cfgStore.LoadAllAsync(ct);
+                var enabled = columns.Where(c => c.Enabled).ToList();
+                if (enabled.Count > 0) minScan = enabled.Min(c => c.ScanSec);
+
+                foreach (var cfg in enabled)
+                {
+                    try
+                    {
+                        var snap = await BuildSnapshotAsync(db, cfg);
+                        var st   = GetState(cfg.Id);
+                        var res  = _engine.Tick(cfg, snap, st, DateTime.UtcNow);
+                        _store.Set(res);                          // ★ 저장만 — 쓰기 없음
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.LogWarning(ex, "FF tick 실패: column {Id}", cfg.Id);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, "FF supervisor 루프 오류");
+            }
+            await Task.Delay(TimeSpan.FromSeconds(Math.Clamp(minScan, 1.0, 10.0)), ct);
+        }
+    }
+
+    private ColumnState GetState(int id)
+    {
+        if (!_states.TryGetValue(id, out var s)) { s = new ColumnState(); _states[id] = s; }
+        return s;
+    }
+
+    private async Task<PvSnapshot> BuildSnapshotAsync(IExperionDbService db, ColumnConfig cfg)
+    {
+        // 필요한 .pv 태그 목록 구성
+        // ★ GetRealtimeRecordsByTagNamesAsync는 tags.Contains(x.TagName) 정확·대소문자구분 매칭.
+        //   realtime_table은 소문자 저장 → 반드시 소문자로 질의.
+        string PvTag(string baseTag)
+        {
+            var t = baseTag.ToLowerInvariant();
+            return t.EndsWith(".pv") ? t : t + ".pv";
+        }
+        var feedTag = PvTag(cfg.FeedTag);
+        var tags = new List<string> { feedTag };
+        if (cfg.PressureTag is not null) tags.Add(PvTag(cfg.PressureTag));
+        tags.AddRange(cfg.LevelTags.Select(PvTag));
+        tags.AddRange(cfg.Streams.Select(s => PvTag(s.FlowTag)));
+
+        var rows = (await db.GetRealtimeRecordsByTagNamesAsync(tags))   // 기존 인터페이스 재사용
+                   .ToDictionary(r => r.TagName.ToLowerInvariant(), r => r);
+
+        TagSample Sample(string baseTag)
+        {
+            var tag = PvTag(baseTag);
+            if (rows.TryGetValue(tag.ToLowerInvariant(), out var r)
+                && double.TryParse(r.LiveValue, NumberStyles.Float, CultureInfo.InvariantCulture, out var v))
+            {
+                bool fresh = (DateTime.UtcNow - r.Timestamp.ToUniversalTime()).TotalSeconds <= cfg.StaleSec;
+                return new TagSample(tag, v, Good: fresh, r.Timestamp);
+            }
+            return new TagSample(tag, double.NaN, Good: false, DateTime.MinValue);
+        }
+
+        var feed = Sample(cfg.FeedTag);
+        var press = cfg.PressureTag is null ? null : Sample(cfg.PressureTag);
+        var levels = cfg.LevelTags.Select(Sample).ToList();
+        var streams = cfg.Streams.ToDictionary(s => s.Key, s => Sample(s.FlowTag));
+        return new PvSnapshot(feed, press, levels, streams);
+    }
+}
+```
+
+> ✅ **확인됨**: `RealtimePoint`(`src/Core/Domain/Entities/ExperionEntities.cs:72`)는
+> `TagName`·`LiveValue`(string?, `[Column("livevalue")]`)·`Timestamp`·`NodeId`를 가진다. 본 코드의 사용과 일치.
+
+### 5.4 Config DDL + 로더 (`FeedforwardConfigStore.cs`)
+
+**DDL 삽입 위치(G4)**: `src/Infrastructure/Database/ExperionDbContext.cs` 의 **`ExperionDbService.InitializeAsync`**
+(클래스 `ExperionDbService`, 약 line 285~). 기존 `await _ctx.Database.ExecuteSqlRawAsync("""...""")` 블록들이
+나열된 끝부분(예: 마지막 뷰 생성 뒤, `return true;` 직전)에 아래 두 테이블 생성을 **멱등 추가**한다.
+
+```sql
+-- ExperionDbService.InitializeAsync 내, 기존 ExecuteSqlRawAsync 블록들 끝에 추가 (멱등)
+CREATE TABLE IF NOT EXISTS ff_column_config (
+    id          SERIAL PRIMARY KEY,
+    name        TEXT NOT NULL,
+    enabled     BOOLEAN NOT NULL DEFAULT FALSE,
+    feed_tag    TEXT NOT NULL,
+    pressure_tag TEXT,
+    level_tags  TEXT,                     -- 콤마 구분
+    scan_sec    DOUBLE PRECISION NOT NULL DEFAULT 2,
+    feed_filter_tau_sec DOUBLE PRECISION NOT NULL DEFAULT 300,
+    feed_move_thr_per_min DOUBLE PRECISION NOT NULL DEFAULT 0,
+    press_filter_tau_sec DOUBLE PRECISION NOT NULL DEFAULT 60,
+    pressure_band DOUBLE PRECISION NOT NULL DEFAULT 1e9,
+    settle_sec  DOUBLE PRECISION NOT NULL DEFAULT 0,
+    stale_sec   DOUBLE PRECISION NOT NULL DEFAULT 120,
+    product_key TEXT NOT NULL DEFAULT 'P',
+    advisory_only BOOLEAN NOT NULL DEFAULT TRUE   -- Phase I 강제
+);
+CREATE TABLE IF NOT EXISTS ff_stream_config (
+    id          SERIAL PRIMARY KEY,
+    column_id   INTEGER NOT NULL REFERENCES ff_column_config(id) ON DELETE CASCADE,
+    key         TEXT NOT NULL,
+    flow_tag    TEXT NOT NULL,
+    role        TEXT NOT NULL,            -- Commanded|LevelDriven|Monitor
+    target_coeff DOUBLE PRECISION NOT NULL DEFAULT 0,
+    theta_up_sec DOUBLE PRECISION NOT NULL DEFAULT 0,
+    theta_dn_sec DOUBLE PRECISION NOT NULL DEFAULT 0,
+    tau_sec     DOUBLE PRECISION NOT NULL DEFAULT 0,
+    sp_min      DOUBLE PRECISION NOT NULL DEFAULT 0,
+    sp_max      DOUBLE PRECISION NOT NULL DEFAULT 1e9,
+    rate_up_per_min DOUBLE PRECISION NOT NULL DEFAULT 1e9,
+    rate_dn_per_min DOUBLE PRECISION NOT NULL DEFAULT 1e9,
+    reflux_from_product BOOLEAN NOT NULL DEFAULT FALSE,
+    grade       TEXT NOT NULL DEFAULT 'A'
+);
+```
+
+> 두 `CREATE TABLE` 문은 각각 별도의 `await _ctx.Database.ExecuteSqlRawAsync("""...""")` 호출로 넣는다
+> (EF의 다중문장 제약 회피 — 기존 코드도 한 호출에 한 문장).
+
+**로더 전체 코드** — EF `ExperionDbContext`의 ADO 커넥션 사용(신규 엔티티 매핑 불필요, 사용자 입력 없음→인젝션 없음):
+
+```csharp
+using System.Data;
+using ExperionCrawler.Core.Application.Feedforward;
+using ExperionCrawler.Infrastructure.Database;   // ExperionDbContext
+using Microsoft.EntityFrameworkCore;             // GetDbConnection()
+using Microsoft.Extensions.Logging;
+
+namespace ExperionCrawler.Infrastructure.Control;
+
+public sealed class FeedforwardConfigStore : IFeedforwardConfigStore
+{
+    private readonly ExperionDbContext _ctx;
+    private readonly ILogger<FeedforwardConfigStore> _logger;
+
+    public FeedforwardConfigStore(ExperionDbContext ctx, ILogger<FeedforwardConfigStore> logger)
+    { _ctx = ctx; _logger = logger; }
+
+    public async Task<IReadOnlyList<ColumnConfig>> LoadAllAsync(CancellationToken ct = default)
+    {
+        var conn = _ctx.Database.GetDbConnection();
+        if (conn.State != ConnectionState.Open) await conn.OpenAsync(ct);
+
+        // 1) 컬럼
+        var cols = new Dictionary<int, (ColumnConfig cfg, List<StreamConfig> streams)>();
+        await using (var cmd = conn.CreateCommand())
+        {
+            cmd.CommandText = """
+                SELECT id, name, enabled, feed_tag, pressure_tag, level_tags, scan_sec,
+                       feed_filter_tau_sec, feed_move_thr_per_min,
+                       press_filter_tau_sec, pressure_band, settle_sec,
+                       stale_sec, product_key
+                FROM ff_column_config
+                """;
+            await using var rd = await cmd.ExecuteReaderAsync(ct);
+            while (await rd.ReadAsync(ct))
+            {
+                var levelTags = rd.IsDBNull(5)
+                    ? Array.Empty<string>()
+                    : rd.GetString(5)
+                        .Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+                        .Select(t => t.ToLowerInvariant()).ToArray();
+
+                var cfg = new ColumnConfig
+                {
+                    Id                      = rd.GetInt32(0),
+                    Name                    = rd.GetString(1),
+                    Enabled                 = rd.GetBoolean(2),
+                    AdvisoryOnly            = true,                                  // ★ 불변식 강제(DB 무관)
+                    FeedTag                 = rd.GetString(3).ToLowerInvariant(),
+                    PressureTag             = rd.IsDBNull(4) ? null : rd.GetString(4).ToLowerInvariant(),
+                    LevelTags               = levelTags,
+                    ScanSec                 = rd.GetDouble(6),
+                    FeedFilterTauSec        = rd.GetDouble(7),
+                    FeedMoveThresholdPerMin = rd.GetDouble(8),
+                    PressFilterTauSec       = rd.GetDouble(9),
+                    PressureBand            = rd.GetDouble(10),
+                    SettleSec               = rd.GetDouble(11),
+                    StaleSec                = rd.GetDouble(12),
+                    ProductKey              = rd.GetString(13),
+                    Streams                 = Array.Empty<StreamConfig>()
+                };
+                cols[cfg.Id] = (cfg, new List<StreamConfig>());
+            }
+        }
+
+        // 2) 스트림
+        await using (var cmd = conn.CreateCommand())
+        {
+            cmd.CommandText = """
+                SELECT column_id, key, flow_tag, role, target_coeff, theta_up_sec, theta_dn_sec,
+                       tau_sec, sp_min, sp_max, rate_up_per_min, rate_dn_per_min,
+                       reflux_from_product, grade
+                FROM ff_stream_config
+                ORDER BY id
+                """;
+            await using var rd = await cmd.ExecuteReaderAsync(ct);
+            while (await rd.ReadAsync(ct))
+            {
+                int colId = rd.GetInt32(0);
+                if (!cols.TryGetValue(colId, out var entry)) continue;
+                entry.streams.Add(new StreamConfig
+                {
+                    Key               = rd.GetString(1),
+                    FlowTag           = rd.GetString(2).ToLowerInvariant(),
+                    Role              = Enum.TryParse<StreamRole>(rd.GetString(3), true, out var role) ? role : StreamRole.Monitor,
+                    TargetCoeff       = rd.GetDouble(4),
+                    ThetaUpSec        = rd.GetDouble(5),
+                    ThetaDnSec        = rd.GetDouble(6),
+                    TauSec            = rd.GetDouble(7),
+                    SpMin             = rd.GetDouble(8),
+                    SpMax             = rd.GetDouble(9),
+                    RateUpPerMin      = rd.GetDouble(10),
+                    RateDnPerMin      = rd.GetDouble(11),
+                    RefluxFromProduct = rd.GetBoolean(12),
+                    Grade             = Enum.TryParse<Confidence>(rd.GetString(13), true, out var g) ? g : Confidence.A
+                });
+            }
+        }
+
+        return cols.Values.Select(e => e.cfg with { Streams = e.streams }).ToList();
+    }
+}
+```
+
+> `GetDouble`/`GetBoolean` 컬럼은 DDL이 `DOUBLE PRECISION`/`BOOLEAN`이라 타입 일치. NULL은 위 DDL `NOT NULL DEFAULT`로 방지.
+> 커넥션은 EF가 소유하므로 **닫지 않는다**(열기만 보장).
+
+### 5.5 Controller (`FeedforwardController.cs`) — 읽기 (camelCase 필수)
+
+```csharp
+using ExperionCrawler.Core.Application.Feedforward;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ExperionCrawler.Web.Controllers;
+
+[ApiController]
+[Route("api/ff")]
+public sealed class FeedforwardController : ControllerBase
+{
+    private readonly IFeedforwardAdvisoryStore _store;
+    public FeedforwardController(IFeedforwardAdvisoryStore store) => _store = store;
+
+    [HttpGet("advisory")]
+    public IActionResult GetAll() => Ok(new
+    {
+        columns = _store.GetAll().Select(MapColumn)
+    });
+
+    [HttpGet("advisory/{columnId:int}")]
+    public IActionResult Get(int columnId)
+    {
+        var r = _store.Get(columnId);
+        return r is null ? NotFound() : Ok(MapColumn(r));
+    }
+
+    // CODING_CONVENTIONS §1: 모든 키 camelCase 명시 (shorthand/typed 반환 금지)
+    private static object MapColumn(AdvisoryResult r) => new
+    {
+        columnId         = r.ColumnId,
+        columnName       = r.ColumnName,
+        computedAt       = r.ComputedAt,
+        enabled          = r.Enabled,
+        transient        = r.Transient,
+        transientReason  = r.TransientReason,
+        feedFiltered     = r.FeedFiltered,
+        vLoss            = r.VLoss,
+        yield            = r.Yield,
+        massBalanceState = r.MassBalanceState,
+        streams          = r.Streams.Select(s => new
+        {
+            key           = s.Key,
+            flowTag       = s.FlowTag,
+            role          = s.Role.ToString(),
+            pv            = double.IsNaN(s.Pv) ? (double?)null : s.Pv,
+            recommendedSp = s.RecommendedSp,
+            gap           = s.Gap,
+            trend         = s.Trend,
+            valid         = s.Valid,
+            grade         = s.Grade.ToString(),
+            note          = s.Note
+        })
+    };
+}
+```
+
+### 5.6 DI 등록 (진단 통과 후에만 `Program.cs`에 추가)
+
+```csharp
+builder.Services.AddSingleton<FeedforwardEngine>();
+builder.Services.AddSingleton<IFeedforwardAdvisoryStore, FeedforwardAdvisoryStore>();
+builder.Services.AddScoped<IFeedforwardConfigStore, FeedforwardConfigStore>();
+builder.Services.AddHostedService<FeedforwardSupervisor>();
+```
+
+### 5.7 테스트 프로젝트 스캐폴드 (G3) — C# 테스트 인프라가 없으므로 신설
+
+저장소에 C# 테스트 프로젝트가 **없다**(Python pytest만 존재). 순수 블록·엔진 검증용 xUnit 프로젝트를 신설한다.
+
+```bash
+# 1) 테스트 프로젝트 생성 + 앱 프로젝트 참조 (솔루션 파일 없음 → 직접 참조)
+dotnet new xunit -o tests/ExperionCrawler.Tests
+dotnet add tests/ExperionCrawler.Tests/ExperionCrawler.Tests.csproj \
+           reference src/Web/ExperionCrawler.csproj
+# 2) 실행
+dotnet test tests/ExperionCrawler.Tests/ExperionCrawler.Tests.csproj
+```
+
+> Web SDK 프로젝트도 테스트에서 참조 가능. 테스트 대상 클래스(`FeedforwardEngine`·연산블록)는 모두 `public`.
+> DB·OPC 의존이 없는 **순수 로직만** 테스트(Supervisor·ConfigStore는 통합검증 §8.2에서 수동).
+
+**예시 테스트(`FeedforwardBlocksTests.cs`) — 가장 까다로운 3개:**
+
+```csharp
+using ExperionCrawler.Infrastructure.Control;
+using Xunit;
+
+public class FeedforwardBlocksTests
+{
+    [Fact]
+    public void DeadTime_delays_by_n_samples()
+    {
+        var d = new DeadTimeBuffer();
+        // θ=10s, ts=2s → n=5 스캔 지연. 버퍼는 첫 입력(10)으로 시드.
+        Assert.Equal(10.0, d.Through(10, 10, 2), 3);              // call1 시드 → 10
+        for (int i = 0; i < 4; i++)                              // call2~5: 입력 20, 출력은 옛값 10
+            Assert.Equal(10.0, d.Through(20, 10, 2), 3);
+        Assert.Equal(10.0, d.Through(20, 10, 2), 3);             // call6: 아직 10 (지연 5)
+        Assert.Equal(20.0, d.Through(20, 10, 2), 3);             // call7: 비로소 20 등장
+    }
+
+    [Fact]   // 진단 정정 회귀: 비대칭 θ 토글에도 지연선 보존
+    public void DeadTime_asymmetric_theta_preserves_history()
+    {
+        var d = new DeadTimeBuffer(); double ts = 2;
+        for (int i = 0; i < 12; i++) d.Through(0, 20, ts);       // θ=20→n=10, 0 충전
+        Assert.Equal(0.0, d.Through(100, 10, ts), 3);            // θ=10→n=5, 아직 0(누출 없음)
+        Assert.Equal(0.0, d.Through(100, 20, ts), 3);            // θ 복귀해도 0
+    }
+
+    [Fact]
+    public void RateLimiter_clamps_asymmetric_up_down()
+    {
+        var r = new RateLimiter();
+        r.Seed(0);
+        // up=60/min, ts=1s → 스캔당 +1 한도
+        Assert.Equal(1, r.Step(100, 60, 600, 1), 3);
+        // dn=600/min → 스캔당 -10 한도
+        r.Seed(100);
+        Assert.Equal(90, r.Step(0, 60, 600, 1), 3);
+    }
+
+    [Fact]
+    public void FirstOrderLag_reaches_63pct_after_tau()
+    {
+        var l = new FirstOrderLag();
+        l.Seed(0);
+        double y = 0; double ts = 1, tau = 10;
+        for (int i = 0; i < 10; i++) y = l.Step(1.0, tau, ts);   // τ=10s, 10스캔
+        Assert.InRange(y, 0.60, 0.66);                            // ≈63%
+    }
+}
+```
+
+### 5.8 실행용 예시 설정 (G5) — C-6111 seed
+
+end-to-end 가동 검증을 위한 **placeholder seed**. θ/τ는 §11.4 전형값, 한계는 대략치 —
+**실측·운전원 값으로 교체 전까지 임시**(Phase II Web UI 공급). 태그는 §확인된 실재 태그.
+
+```sql
+-- C-6111 (P6-1) advisory 1컬럼. 진단·DI 등록 후 1회 실행.
+INSERT INTO ff_column_config
+  (name, enabled, feed_tag, pressure_tag, level_tags, scan_sec,
+   feed_filter_tau_sec, feed_move_thr_per_min, pressure_band, settle_sec, stale_sec, product_key)
+VALUES
+  ('C-6111', TRUE, 'ficq-6101', 'pica-6111', 'li-6111,lica-6113', 2,
+   300, 5, 3, 1800, 120, 'P')
+RETURNING id;
+-- 위 id를 :cid 로 사용 (예시는 1로 가정)
+
+-- 스트림: P=commanded, R=reflux(P 경유), D·B=level_driven(LICA-6113 인벤토리 구동), 모니터 없음
+INSERT INTO ff_stream_config
+  (column_id, key, flow_tag, role, target_coeff, theta_up_sec, theta_dn_sec, tau_sec,
+   sp_min, sp_max, rate_up_per_min, rate_dn_per_min, reflux_from_product, grade) VALUES
+  (1, 'P', 'ficq-6118', 'Commanded',   0.95,  60,  60,  900,  0, 950, 30, 60, FALSE, 'A'),
+  (1, 'R', 'ficq-6113', 'Commanded',   0.80,   0,   0,    0,  0,1100, 30, 30, TRUE,  'A'),
+  (1, 'D', 'ficq-6114', 'LevelDriven', 0.02,   0,   0,    0,  0,  60,  0,  0, FALSE, 'B'),
+  (1, 'B', 'ficq-6116', 'LevelDriven', 0.03,   0,   0,    0,  0,  80,  0,  0, FALSE, 'B');
+```
+
+> **placeholder 경고**: 위 θ(P=60s)·τ(P=900s=15min)·rate·sp_max는 **임시 추정**. §11.4 bump test/Phase II로 교체.
+> D·B는 `LevelDriven`이라 deadtime/rate 미적용(기대치 K·F만 표시). reflux R은 P 권장값 경유(§4 엔진).
+
+---
+
+## 6. 나머지 항목 보정 플랜 (§13·§14 → Phase II/III)
+
+| ID | 항목 | 근거(§) | Phase | 구현 방향 |
+|:--:|:-----|:------:|:-----:|:----------|
+| P-1 | **θ 자동튜닝** (passive 교차상관) | §13.4 | II | `CrossCorrLagEstimator`: ΔF·ΔS(=TICA.OP) 다입력 부분상관 → θ_i + 신뢰도. StreamConfig.θ를 *제안*만(운전원 승인 시 반영). 폐루프 오염 회피(스팀 2nd 입력) |
+| P-2 | **PCT/차온 모니터** | §13.3·§14.1 | II | `TempCorrection`(已구현) + `DiffTemp`. PCT는 dT/dP·Pref **계절 재캘리브레이션**. 컬럼 설정에 tempTags·dTdP·pRef 추가 |
+| P-3 | **Sweet-spot/프론트 위치 지표** | §13.5 | II | `FrontPositionIndicator`: 민감트레이 PCT/ΔT → 드리프트 시 환류/boilup 트림 *권장*(advisory). analyzer 있으면 우선 |
+| P-4 | **느린 바이어스 적응** (K·k_V) | §14.4 | II | 물질수지 **장기 이동평균**으로 K_obs·k_V 추세 산출 → 운전원에게 "계절 보정 제안". 자동 변경 아님 |
+| P-5 | **confidence 자동 강등** | §14.3 | II | 입력 신선도·압력안정·analyzer 부재 등으로 A→B→C 동적 강등, UI 색상 |
+| P-6 | **Web UI** 설정/대시보드(Tab 18) | §12.7 | II | 컬럼별 경험상수 폼(admin) + 권장 SP 카드(현재/권장/Δ/추세/valid). Tab16/17 패턴. `press_filter_tau_sec` 포함 — 압력 1차저역통과 시정수(초), 운전자가 압력노이즈 특성에 맞춰 조정 |
+| P-7 | **RSP 감독제어 쓰기** | §12.8 Stage3 | III | `WriteGuard`(min/max·rate·Δcap) + 워치독·데드맨 + 운전원 채택 스위치. `ExperionOpcWriteClient` 가드 0건 → 선행 구현 필수 |
+
+> Phase I 코드는 P-1~P-7의 **확장점(설정 필드·블록 인터페이스)** 을 남겨두되, **본 Phase에선 미구현**.
+
+---
+
+## 7. 검증 절차 (diagnosis-checklist.md 8단계 기준) — 감독자 진단용
+
+> 감독자는 아래를 **순서대로** 수행하고, 발견 항목을 STEP 8 보고서 양식으로 기록한다.
+> 본 코드는 **신규 파일**이므로 STEP 3의 "전체 파일 읽기"는 §2~§5 코드블록 전체를 대상으로 한다.
+
+### STEP 1 — 맥락
+- 레이어: Core(모델/인터페이스), Infrastructure/Control(블록·엔진·Supervisor), Web(읽기 컨트롤러).
+- 관련 문서: `측류추출식-통합유량설정공식.md` §9~§14, `측류추출-시간지연-적용방식.md`, 본 문서 §0 Scope.
+- **의도적 설계 확인**: ① 쓰기 없음(advisory) ② D·B는 LevelDriven ③ 엔진 상태는 단일 루프 소유(락 없음) ④ AdvisoryOnly 강제.
+
+### STEP 2 — 구조
+- 신규 파일 목록(§1) 확인, 기존 파일 변경은 **DI 등록 + 부트 DDL 2테이블**뿐(나머지 무변경).
+- 의존: `IExperionDbService.GetRealtimeRecordsByTagNamesAsync`, `RealtimePoint`, `ExperionDbContext`.
+
+### STEP 3 — 코드 읽기 (전체, 건너뛰기 금지)
+순서: 모델(§2) → 블록(§3) → 엔진(§4) → stores/supervisor(§5) → 컨트롤러(§5.5).
+
+### STEP 4 — 호출 계층 지도
+```
+BackgroundService.ExecuteAsync (루프)
+  → scope: IFeedforwardConfigStore.LoadAllAsync   (DB read)
+  → scope: IExperionDbService.GetRealtimeRecordsByTagNamesAsync (DB read)
+  → FeedforwardEngine.Tick   (순수, I/O 없음)         ← try-catch는 컬럼 단위 + 루프 전체
+  → IFeedforwardAdvisoryStore.Set  (in-memory)
+HTTP GET /api/ff/advisory → AdvisoryStore.Get(All)  (read only)
+─ 쓰기 경로 없음 (ExperionOpcWriteClient 미참조) ─
+```
+
+### STEP 5 — 패턴 매칭 (자가 사전점검 결과 동봉)
+
+| 체크 | 본 코드 상태 | 처리 |
+|:-----|:-------------|:-----|
+| 미정의 참조 | `RealtimePoint.LiveValue`/`TagName`/`Timestamp` ✅ 실제 엔티티(`ExperionEntities.cs:72`)와 일치 확인 | OK |
+| async 내 blocking | DB는 `await`, 엔진은 순수 | OK |
+| Race condition | 엔진 상태는 Supervisor 단일 루프 소유, AdvisoryStore는 단일 writer + ConcurrentDictionary | OK |
+| `Task.Delay` 고정값 | 루프 주기는 cfg.ScanSec 기반(clamp 1~10s) | OK(폴링 본질) |
+| DB 커넥션 누수 | `using var scope` per iteration | OK |
+| 예외 삼킴 | 컬럼 단위 `LogWarning`, 루프 `LogError` | OK |
+| 0 나눗셈 | `ff>1e-6` 가드, `Max(1e-6,..)` | OK |
+| NaN 전파 | `Num.IsFinite` 게이트, BAD→Hold | OK |
+| 설정 하드코딩 | 상수는 cfg/DB | OK (단, Resize seed·~~press filter τ=60 하드코딩~~ → 해소: `PressFilterTauSec` ColumnConfig 속성으로 승격, DDL·로더·엔진·Web UI(Tab 18) 연동) |
+| SQL Injection | ConfigStore는 **사용자 입력 없이 전체 행 SELECT**(WHERE/파라미터 없음) | OK (인젝션 표면 없음) |
+| **쓰기 불변식** | 코드 전체에 SP/OP write 호출 **없음** | ★ 감독자 grep 확인 |
+
+### STEP 6 — 교차검증 (의심 항목별 Q1~Q4)
+- `RealtimePoint` 속성명: ✅ 확인 완료(`ExperionEntities.cs:72`, `LiveValue`/`TagName`/`Timestamp` 일치) → 보고서 제외.
+- press filter τ=60 하드코딩: Q4(장애 시나리오?) → 없음 → **LOW**.
+- ConfigStore 인젝션: 사용자 입력 없는 전체 SELECT → 표면 없음 → 보고서 제외.
+- `DeadTimeBuffer` 지연 정확도: 단위테스트(§5.7)로 n-샘플 지연 검증 → write-후-read는 n−1 버그(이미 정정).
+
+### STEP 7 — 심각도 (감독자 판정)
+- HIGH: 빌드/런타임 즉시 실패(예: 엔티티 속성명 불일치, EF 매핑 누락).
+- MED: 로더 인젝션, config 핫리로드 시 상태 누수(컬럼 삭제 후 `_states` 잔존 → 경미).
+- LOW: 하드코딩 상수, 미사용 using.
+
+### STEP 8 — 보고서 양식 (감독자가 채움)
+```
+### [n]. [제목] (HIGH/MED/LOW)
+문제: …
+근거: 파일:줄 — 코드 인용
+영향: …
+수정: …
+```
+
+---
+
+## 8. 단위·통합 검증 계획 (감독자 진단 통과 후)
+
+### 8.1 단위테스트 (순수 블록·엔진)
+| 대상 | 케이스 |
+|:-----|:-------|
+| `DeadTimeBuffer` | θ=10s/ts=2s → 5스캔 지연 정확, θ<ts 즉시통과, 길이변경 시 재시드 bump 없음 |
+| `FirstOrderLag` | 스텝 입력 τ후 63% 도달, τ=0 즉시통과, 미시드 첫값 시드 |
+| `MovingAverage` | 윈도 평균·윈도 초과 시 가장 오래된 값 제거 |
+| `RateLimiter` | up≠dn 비대칭 클램프, 시드 bumpless |
+| `FeedforwardEngine` | ① FEED 스텝 시 commanded는 θ 지연 후 변화 ② level_driven은 즉시 K·F ③ 과도 중 valid=false·물질수지 SETTLING ④ FEED BAD→Hold(직전 권장 유지) ⑤ reflux=R_f×P_rec |
+
+### 8.2 빌드/런타임 (감독자 승인 후)
+- `dotnet build src/Web/ExperionCrawler.csproj` 경고 0/에러 0.
+- DI 등록 후 기동 → `GET /api/ff/advisory` 200, 컬럼 결과 camelCase 확인.
+- **쓰기 불변식 검증**: `grep -rn "WriteTagAsync\|SetModeAsync" src/Infrastructure/Control src/Web/Controllers/FeedforwardController.cs` → **0건**.
+- 다컬럼 격리: 한 컬럼 FEED를 BAD로 만들어도 타 컬럼 advisory 정상.
+- 재기동 bumpless: 첫 정상 PV로 권장값 점프 없이 시드.
+
+### 8.3 제출 전 자가검증 (체크리스트 §STEP8)
+- [ ] 각 지적이 "파일 몇 줄"로 지목되는가
+- [ ] HIGH는 재현 시나리오 1문장
+- [ ] Q1~Q4 통과 항목만 포함
+- [ ] "더 좋은 제안"과 "틀림"을 혼동하지 않음
+- [ ] **쓰기 0건 불변식 재확인**
+
+---
+
+## 9. 턴키 상태 & 잔여 항목
+
+**턴키 갭 G1~G5 — 전부 해소(다른 LLM이 코드베이스 추가 탐색 없이 구현 가능):**
+
+| 갭 | 해소 |
+|:--:|:-----|
+| G1 프로젝트 구조 | §1.1 — 단일 `ExperionCrawler.csproj`, 새 csproj 금지·파일만 추가 |
+| G2 ConfigStore 본문 | §5.4 — ADO 로더 전체 코드(EF 커넥션, 사용자입력 없음) |
+| G3 테스트 인프라 | §5.7 — xUnit 신설 명령 + 예시 테스트(블록 3종) |
+| G4 DDL 위치 | §5.4 — `ExperionDbService.InitializeAsync` 내 멱등 추가, 위치 명시 |
+| G5 실행 seed | §5.8 — C-6111 placeholder INSERT(실재 태그, role 매핑 포함) |
+
+**구현 순서(다른 LLM용)**: ① 신규 파일 8개 추가(§2~§5, 같은 csproj) → ② `ExperionDbService.InitializeAsync`에
+DDL 2블록(§5.4) → ③ `Program.cs` DI 4줄(§5.6) → ④ `dotnet build src/Web/ExperionCrawler.csproj` →
+⑤ 테스트 프로젝트(§5.7) `dotnet test` → ⑥ seed INSERT(§5.8) → ⑦ `GET /api/ff/advisory` 확인 + 쓰기 0건 grep(§8.2).
+
+**여전히 사람/감독자 판단이 필요한 것(코드 갭 아님):**
+1. **경험상수 실측치** — seed의 θ/τ/K/limits는 placeholder. bump test·운전원 값으로 교체(Phase II Web UI).
+2. 컬럼 삭제 시 `_states`/`AdvisoryStore` 정리(현재 누적) — 경미, 장기 운영 시 cleanup 추가.
+3. Phase II 진입 기준(운전원 advisory 신뢰 확보 정의).
+
+---
+
+## 10. 구현 진단 결과 (2026-05-30)
+
+`diagnosis-checklist.md` 8단계 + 실측 검증 완료.
+
+**실측**: `dotnet build` 경고0/에러0 · 단위테스트 **4/4** · **쓰기 호출 0건**(grep) · DDL 2테이블 분리 정상 · DI 4줄 · ConfigStore SELECT↔reader 인덱스 일치.
+
+**발견·조치:**
+
+| # | 등급 | 항목 | 조치 |
+|:-:|:----:|:-----|:-----|
+| 1 | **MED** | 비대칭 θ(θup≠θdn) 시 `DeadTimeBuffer`가 n 변경마다 Resize-재시드 → 부호반전마다 지연선 소실(D7 기능 불능) | **수정 완료** — 고정용량(증가전용) 링 + 가변 읽기오프셋. 회귀테스트 `DeadTime_asymmetric_theta_preserves_history` 추가(4/4) |
+| 2 | LOW | 물질수지 키 `"D"/"P"/"B"` 하드코딩 — 다른 명명 컬럼은 모니터 무효 | 잔존(모니터 전용·무해). Phase II에서 ColumnConfig에 키 매핑화 검토 |
+| 3 | LOW | config 중복 Key → `ToDictionary` 예외 | 컬럼 단위 try-catch로 격리됨. Phase II에서 설정 검증 추가 |
+| 4 | NIT | `MovingAverage` 미사용(엔진은 EMA), Monitor 스트림 seed | 무해 — 대안 블록 |
+
+**결론**: MED 1건 수정 완료, 빌드·테스트·쓰기불변식 통과 → **머지 가능**. 잔여는 LOW/판단 항목.
diff --git a/docs/측류추출식-통합유량설정공식-구현코딩-PhaseII-분석엔진+전환류복귀.md b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseII-분석엔진+전환류복귀.md
new file mode 100644
index 0000000..2f85d86
--- /dev/null
+++ b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseII-분석엔진+전환류복귀.md
@@ -0,0 +1,439 @@
+# 측류추출 통합유량 — Phase II 분석엔진 + 전환류 복귀 모드 구현 작업지시서
+
+> **성격**: PhaseI(advisory 엔진)·PhaseII-UI(Tab 18)·PhaseIII(auto-write) 문서의 **§6 잔여 보정항목(P-1~P-5)** 과
+> **신규 안전기능(전환류 평형복귀 모드)** 의 턴키 구현 작업지시서. 다른 LLM이 코드베이스 추가 탐색 없이 구현하도록
+> **검증된 현재 코드 기준선** 위에서 작성한다.
+>
+> **불변식(PhaseI 계승)**: P-1~P-5 및 전환류 모드의 **권장(advisory) 계산까지는 제어 레지스터 쓰기 0건**.
+> 실제 SP 쓰기(전환류 자동 실행 포함)는 **전부 PhaseIII(WriteGuard)** 경유. 본 문서는 "권장값/모드 산출 + 표시"까지가 범위.
+>
+> **작업 순서(영향도·의존성 반영)**: §A 문서감리 선반영 → **WO-1(P-5)** → **WO-2(P-2)** → **WO-3(P-1)** →
+> **WO-4(P-4)** → **WO-5(P-3)** → **WO-6(전환류 복귀)** → §C 통합검증. P-7은 기존 PhaseIII 문서(§D 정정 메모 참조).
+
+---
+
+## §A. 선행 — 기존 문서·코드 감리 결과 (먼저 반영할 것) ★
+
+본 작업 착수 전 아래 문서 드리프트를 인지하고 **§B 현재 코드 기준선을 정본**으로 삼는다. (기존 PhaseI/II/III 문서를 글자대로 따르면 깨지는 지점들.)
+
+| # | 등급 | 위치 | 문제 | 조치 |
+|:-:|:----:|:-----|:-----|:-----|
+| A1 | **HIGH** | PhaseI §5.4 DDL·§5.8 seed·§2 모델, PhaseII §2.2 | `ff_stream_config.level_tag`(TEXT) 컬럼이 **실제 스키마·`StreamConfig.LevelTag`·`StreamAdvisory.LevelTag`·ConfigStore SELECT(인덱스 14)·SaveColumn INSERT·Controller `levelTag`** 에 전부 존재하나 **그 문서들엔 누락** | 본 문서는 **현재 코드 기준선(§B)** 을 정본으로 삼는다. 기존 DDL 문서를 그대로 따르지 말 것 |
+| A2 | **WO-6 선결** | `src/Web/Program.cs:124~128` | (중복 버그 아님 — 현재 `AddHostedService<FeedforwardSupervisor>()` **단일 등록**으로 정상.) 단, WO-6 복구 컨트롤러가 `FeedforwardSupervisor`에 주입 접근(ColumnState ARM)하려면 **singleton 노출 필요** | `AddHostedService<FeedforwardSupervisor>()`(128) → **`AddSingleton<FeedforwardSupervisor>()` + `AddHostedService(sp=>sp.GetRequiredService<FeedforwardSupervisor>())`** 2줄로 교체(단일 인스턴스를 hosted+injectable로). **WO-6 착수 시에만** 변경, 그전엔 현 상태 유지 |
+| A3 | **MED** | PhaseII §2.3 본문 vs §8 | §2.3 본문은 `IKbAuthService`/`IsAdminAsync`로 config CRUD를 막는 코드를 보여주나, §8과 **실제 컨트롤러는 인증 제거**(config CRUD 공개) | 본 문서는 **인증 없는 현재 컨트롤러(§B)** 기준. auth 재도입은 PhaseIII(쓰기 시)에서만 |
+| A4 | LOW | PhaseI §2 | `StreamAdvisory` 레코드에 `LevelTag` 없음, enum에 `[JsonStringEnumConverter]` 표기 없음 — 실제는 둘 다 있음 | §B 기준선 사용 |
+| A5 | LOW | PhaseI §6 P-2 | "TempCorrection(已구현)" — `TempCorrection.PressureCompensated`는 존재하나 **엔진에서 호출되지 않는 죽은 코드** | WO-2에서 배선 |
+| A6 | LOW | PhaseIII §6 | 변경대상 `src/Infrastructure/OpcUa/OpcUaClientService.cs`는 **그 이름의 파일이 없음**. 단, **`src/Infrastructure/OpcUa/ExperionOpcWriteClient.cs`(namespace `...Infrastructure.Control`)가 이미 존재**(쓰기 클라이언트 — 가드 없음). NodeId `ns=3;s="{tag}.sp"` 규칙 미검증 | §D 참조 — PhaseIII는 **기존 `ExperionOpcWriteClient` 재사용/확장**(신규 파일 X). NodeId는 서버 브라우즈로 확정 |
+
+> **advisory 쓰기 불변식의 정확한 범위**: 코드베이스 전체엔 범용 `ExperionOpcWriteClient`(다른 기능용)가 **존재**한다.
+> 불변식은 **"FF advisory 경로가 그 쓰기 클라이언트를 호출하지 않는다"** 는 의미.
+> 검증 grep은 **FF 파일에 한정**: `grep -rE "ExperionOpcWriteClient|Write.*Async" src/Infrastructure/Control src/Web/Controllers/FeedforwardController.cs` → 0건(현재 유지됨).
+
+---
+
+## §B. 검증된 현재 코드 기준선 (정본 — 2026-05-31 실독)
+
+다른 LLM은 아래를 **사실로 간주**하고, 기존 PhaseI/II/III 문서와 충돌 시 **본 §B를 우선**한다.
+
+### B.1 모델 (`src/Core/Application/Feedforward/FeedforwardModels.cs`)
+- `enum StreamRole { Commanded, LevelDriven, Monitor }` · `enum Confidence { A, B, C }` — 둘 다 `[JsonConverter(typeof(JsonStringEnumConverter))]`.
+- `StreamConfig`: Key, FlowTag, Role, **LevelTag(string?)**, TargetCoeff, ThetaUpSec, ThetaDnSec, TauSec, SpMin, SpMax, RateUpPerMin, RateDnPerMin, RefluxFromProduct, Grade.
+- `ColumnConfig`: Id, Name, Enabled, AdvisoryOnly(=true 강제), FeedTag, PressureTag, LevelTags, ScanSec, FeedFilterTauSec, FeedMoveThresholdPerMin, PressFilterTauSec, PressureBand, SettleSec, StaleSec, ProductKey, Streams.
+- `TagSample(Tag, Value, Good, Timestamp)`.
+- `PvSnapshot(Feed, Pressure?, Levels[], Streams{key→TagSample})`.
+- `StreamAdvisory(Key, FlowTag, Role, Pv, RecommendedSp?, Gap?, Trend, Valid, Grade, **LevelTag?**, Note)`.
+- `AdvisoryResult(ColumnId, ColumnName, ComputedAt, Enabled, Transient, TransientReason, FeedFiltered, Streams[], VLoss?, Yield?, MassBalanceState)`.
+
+### B.2 연산블록 (`src/Infrastructure/Control/ComputationBlocks.cs`)
+`Num`(Clamp/IsFinite), `FirstOrderLag`(Seed/Step), `MovingAverage(windowSamples)`(Push), `DeadTimeBuffer`(Through — 증가전용 링·비대칭 θ 보존), `RateLimiter`(Seed/Step 비대칭), `Derivative`(Update), `TempCorrection.PressureCompensated`(**미배선 죽은 코드**).
+
+### B.3 엔진 (`src/Infrastructure/Control/FeedforwardEngine.cs`)
+- `StreamState{ Dead, Lag, Rate, LastRec }`, `ColumnState{ FeedFilter, PressFilter, FeedDeriv, SettleTimerSec, Initialized, Streams{key→StreamState} }`.
+- `FeedforwardEngine.Tick(ColumnConfig cfg, PvSnapshot pv, ColumnState st, DateTime now) → AdvisoryResult` — **순수함수(I/O 없음)**.
+- 흐름: FEED 품질게이트→Hold / FEED 필터(EMA) / 시드 / 과도·압력 게이트(transient) / 스트림 2-pass(commanded→reflux) / 물질수지(transient 아닐 때 `vloss=ff-(D+P+B)`, `yield=100*P/ff`).
+- 역할별: Commanded=비대칭θ DeadTime→Lag→K→RateLimit / LevelDriven=`K*ff`(즉시) / Monitor=null.
+
+### B.4 수급/저장/컨트롤러/DI
+- `FeedforwardSupervisor`(BackgroundService): 스코프마다 `IFeedforwardConfigStore.LoadAllAsync` + `IExperionDbService.GetRealtimeRecordsByTagNamesAsync`로 `PvSnapshot` 구성 → `Tick` → `IFeedforwardAdvisoryStore.Set`. 쓰기 없음. 컬럼별 `ColumnState` 단일 루프 소유(락 없음).
+- `IFeedforwardConfigStore{ LoadAllAsync, SaveColumnAsync, DeleteColumnAsync }`, `IFeedforwardAdvisoryStore{ Set, Get, GetAll }`.
+- `FeedforwardConfigStore`: ADO(EF 커넥션). LoadAll은 컬럼+스트림 2쿼리(스트림 SELECT에 `level_tag` 인덱스 14 포함). Save/Delete는 **파라미터화 `P()` 헬퍼 + 트랜잭션**.
+- `FeedforwardController` (`api/ff`): `GET/POST/DELETE config`(**인증 없음**), `GET advisory`·`advisory/{id}`(공개). `MapColumn`/`MapConfig`로 camelCase 명시.
+- DI(Program.cs:124~128): Engine=Singleton, AdvisoryStore=Singleton, ConfigStore=Scoped, Supervisor=**단일 AddHostedService**(중복 없음). WO-6에서 singleton+hosted로 교체(A2).
+- DDL(ExperionDbContext.InitializeAsync, line ~1066~1103): `ff_column_config`, `ff_stream_config`(grade, **level_tag** 포함)을 **하나의 `ExecuteSqlRawAsync`에 여러 문장(CREATE;CREATE;ALTER)** 으로 멱등 생성(Npgsql는 다문장 허용 — PhaseI의 "한 호출 한 문장" 주의는 현재 코드에선 무효). try/catch로 "[ExperionDb] 초기화 실패" 경고 후 `return false`.
+
+### B.5 C-6111 태그 매핑 (브레인스토밍 확정)
+| 키 | 태그 | 의미 | 역할(seed) | 전환류 시 |
+|:--:|:-----|:-----|:----------|:----------|
+| FEED | ficq-6101 | 원료 투입(물질수지 기준) | (입력·외란) | **차단(→0)** |
+| R | ficq-6113 | 환류(reflux) | Commanded(RefluxFromProduct) | **최대(전량 환류)** |
+| P | ficq-6118 | 측류 제품(PGMEA) | Commanded | **차단(→0)** |
+| D | ficq-6114 | 탑정 경비물(저비점) 배출 | LevelDriven | **차단(→0)** |
+| B | ficq-6116 | 탑저 중비물(고비점) 배출 | LevelDriven | **차단(→0)** |
+| 보조 | tica-6111a(탑저/리보일러), pica-6111·pi-6111(진공 ~48.5torr), lica-6113/li-6111(레벨), ti-6111b/c/d(프로파일) | | |
+
+> 출처: D/P/B 매핑 = `knowledge/PGMEA_측류추출운전방식_주의점.md §1` + PhaseI §5.8 seed. 태그 계측현황 = `docs/보조운전-브레인스토밍.md §10.2`(ti-6111a.pv=0 고장의심 주의).
+> **운전 정석(`PGMEA_측류추출운전방식_주의점.md §4.2·§4.3`)**: 측류 조성이 목표 이탈/외란 시 → ① **측류를 먼저 줄이거나 일시 중단**(오염 제품 방지) → ② **환류비를 높여 탑 내부 재안정화** → ③ 회복되면 측류 재개. "탑을 안정시킨 후 뽑는다"가 원칙. **전환류 모드(WO-6)는 이 §4.3 정석의 극단(드로우 전면 중단·전량 환류)을 상태기계로 형식화한 것.**
+
+---
+
+## §0. 모델 공통 확장 (모든 WO 선행) — `FeedforwardModels.cs`
+
+WO들이 공유하는 필드를 **한 번에** 추가한다(레코드라 `with` 호환). **camelCase 직렬화는 컨트롤러 Map에서 명시** (PhaseI 규칙).
+
+```csharp
+// enum 추가
+[JsonConverter(typeof(JsonStringEnumConverter))]
+public enum ColumnMode { Normal, Recovering, Returning }   // WO-6 전환류 상태기계
+
+// StreamConfig 추가 필드 (DDL ff_stream_config 동반)
+//   P-1(θ제안)·전환류 reflux 식별용
+public bool   IsReflux        { get; init; }    // 전환류 시 "전량 환류" 대상. (없으면 RefluxFromProduct로 대체식별)
+public double RecoverySp       { get; init; } = double.NaN; // 전환류 중 이 스트림 권장SP. NaN이면 규칙기본(draw=0, reflux=SpMax)
+
+// ColumnConfig 추가 필드 (DDL ff_column_config 동반)
+//   P-2(PCT/차온)
+public IReadOnlyList<string> TempTags { get; init; } = Array.Empty<string>(); // 프로파일 온도 base tag (상→하 순서)
+public string? SensitiveTrayTag { get; init; }   // 민감트레이(프론트 지표). null이면 ΔT(상-하)로 대체
+public double  DTdP            { get; init; } = 0.0;   // dT/dP [°C/압력단위]. 0이면 PCT 미적용(생온도)
+public double  PRef            { get; init; } = double.NaN; // 압력 기준점. NaN이면 첫 정상압력 시드
+//   P-1(θ 자동튜닝)
+public string? SteamOpTag      { get; init; }   // TICA-6111A.OP(스팀) — 부분상관 2번째 입력(폐루프 오염 회피)
+public bool    ThetaAutoTune   { get; init; }   // θ 식별 가동 여부(제안만, 자동반영 X)
+//   P-4(느린 바이어스)
+public double  BiasMaWindowSec { get; init; } = 6*3600; // K_obs/k_V 장기 MA 창(기본 6h)
+//   WO-6(전환류 복귀)
+public bool    RecoveryEnabled { get; init; }            // 전환류 권장 기능 on/off
+public bool    RecoveryAutoArm { get; init; }            // true=자동권장, false=운전원 1클릭 무장 후에만
+public double  ImbalanceTriggerFrac { get; init; } = 0.10; // |V_loss_MA|/F 지속 초과 시 트리거(기본 10%)
+public double  ImbalanceTriggerSec  { get; init; } = 600;  // 지속 시간(기본 10분)
+public double  RecoverySettleSec    { get; init; } = 1800; // 전환류 평형 dwell(기본 30분)
+public double  ReturnRampSec        { get; init; } = 600;  // 복귀 시 draw/feed 램프(기본 10분)
+public double  FeedRecoverySp       { get; init; } = 0.0;  // 전환류 중 FEED 권장값(기본 0=차단)
+public string? DeltaPTag           { get; init; }          // 탑 차압(ΔP) — 플러딩/비산 트리거(주의점§3 4순위). null=미사용
+public double  DeltaPFloodLimit    { get; init; } = double.MaxValue; // ΔP 상한(초과 지속 시 트리거)
+
+// StreamAdvisory 추가 필드
+public string? GradeReason   { get; init; }   // P-5 강등 사유
+public double? ThetaSuggestUpSec { get; init; }   // P-1 제안 θ↑ (null=신뢰부족)
+public double? ThetaSuggestDnSec { get; init; }   // P-1 제안 θ↓
+public double? ThetaSuggestConf  { get; init; }   // P-1 상관 신뢰 0~1
+public double? KObsSuggest    { get; init; }   // P-4 관측 K 장기추세 제안
+
+// AdvisoryResult 추가 필드
+public ColumnMode Mode { get; init; } = ColumnMode.Normal;   // WO-6
+public string?    ModeReason { get; init; }
+public double?    VLossMa { get; init; }     // P-4/WO-6 장기 MA V_loss
+public IReadOnlyList<TempPoint>? Temps { get; init; }   // P-2 PCT/차온 모니터
+public string?    FrontPositionState { get; init; }     // P-3
+public string?    FrontTrimAdvice    { get; init; }     // P-3
+
+public sealed record TempPoint(string Tag, double Raw, double Pct, bool Good);
+```
+
+> **레코드 확장 주의**: `StreamAdvisory`·`AdvisoryResult`는 **위치 인자(positional) record** 다. 새 필드는 **positional 파라미터로 추가하면 기존 `new StreamAdvisory(...)` 호출이 전부 깨진다.** → **새 필드는 위와 같이 `{ get; init; }` 본문 프로퍼티로 추가**(positional 생성자 불변)하고, 생성부에서 `with { ... }` 또는 object initializer로 채운다. 엔진의 기존 `new StreamAdvisory(...)`/`new AdvisoryResult(...)` 호출은 그대로 두고 뒤에 `with { GradeReason = ..., Mode = ... }`를 붙인다.
+
+**DDL 델타** (ExperionDbContext.InitializeAsync, line ~1102 기존 ff 블록 끝 — 같은 `ExecuteSqlRawAsync` 다문장 블록에 멱등 ALTER 추가; Npgsql 다문장 허용. 위치는 `ALTER TABLE ff_stream_config ADD COLUMN IF NOT EXISTS level_tag TEXT;` 바로 뒤):
+```sql
+ALTER TABLE ff_stream_config  ADD COLUMN IF NOT EXISTS is_reflux    BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE ff_stream_config  ADD COLUMN IF NOT EXISTS recovery_sp  DOUBLE PRECISION;          -- NULL=규칙기본
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS temp_tags    TEXT;                      -- 콤마구분
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS sensitive_tray_tag TEXT;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS dtdp         DOUBLE PRECISION NOT NULL DEFAULT 0;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS p_ref        DOUBLE PRECISION;          -- NULL=시드
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS steam_op_tag TEXT;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS theta_auto_tune BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS bias_ma_window_sec DOUBLE PRECISION NOT NULL DEFAULT 21600;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS recovery_enabled  BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS recovery_auto_arm BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS imbalance_trigger_frac DOUBLE PRECISION NOT NULL DEFAULT 0.10;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS imbalance_trigger_sec  DOUBLE PRECISION NOT NULL DEFAULT 600;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS recovery_settle_sec    DOUBLE PRECISION NOT NULL DEFAULT 1800;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS return_ramp_sec        DOUBLE PRECISION NOT NULL DEFAULT 600;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS feed_recovery_sp       DOUBLE PRECISION NOT NULL DEFAULT 0;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS delta_p_tag            TEXT;
+ALTER TABLE ff_column_config  ADD COLUMN IF NOT EXISTS delta_p_flood_limit    DOUBLE PRECISION NOT NULL DEFAULT 1e9;
+```
+> **ConfigStore 동반 수정**: `LoadAllAsync`의 두 SELECT에 신규 컬럼 추가(읽기 인덱스 시프트 주의 — 새 컬럼은 **항상 SELECT 끝에 append**하고 새 인덱스로 읽을 것), `SaveColumnAsync`의 INSERT/UPDATE에 신규 파라미터 추가, `MapConfig`에 camelCase 필드 추가. **인덱스 시프트가 PhaseI 진단의 단골 버그**이므로 SELECT 컬럼 순서와 `rd.GetXxx(n)` 번호를 1:1 대조 검증.
+
+---
+
+## WO-1 — P-5 confidence 자동강등 (1순위, 노력 小)
+
+**목적**: config의 정적 `Grade`(A/B/C)를 **실시간 입력 건전성으로 강등**해, 운전원이 "지금 이 권장값을 믿을지"를 색으로 안다. PhaseIII auto-write의 **안전 게이트 전제**(Grade A만 쓰기).
+**근거**: spec §14.3(보정 3등급), §14.5(신뢰도 플래그). PhaseII §6 훅("`StreamAdvisory.Grade` ← P-5 연결점").
+
+**설계**: config `Grade`는 **상한(best-case)**. 엔진이 아래 사유로 한 단계씩 강등하고 `GradeReason`에 기록.
+
+| 강등 사유 | 적용 |
+|:----------|:-----|
+| PV stale/BAD(신선도 초과) | 해당 스트림 → 최소 B, 연속 시 C |
+| 과도(transient) 중 | → 한 단계 강등(정착 전 신뢰 낮음) |
+| 압력 불안정(pUnstable) | 컬럼 전체 → 한 단계 강등 |
+| analyzer/온도지표 부재인데 등급이 C 항목 의존(P-3 연계) | C 유지 |
+| 물질수지 불일치(`mbState`≠"정상") | commanded 스트림 → 한 단계 강등 |
+
+**구현 (`FeedforwardEngine.cs`)** — 순수함수 유지. 헬퍼 추가:
+```csharp
+private static (Confidence g, string? why) Downgrade(Confidence baseG, params (bool hit,string why)[] rules)
+{
+    int lvl = (int)baseG;                 // A=0,B=1,C=2
+    string? why = null;
+    foreach (var (hit, w) in rules) if (hit) { lvl = Math.Min(2, lvl + 1); why = why is null ? w : why + "; " + w; }
+    return ((Confidence)lvl, why);
+}
+```
+`BuildAdvisory`에서 스트림별 적용(`pv.Streams[key].Good` 신선도, `transient`, mbState 불일치 플래그를 인자로 받게 시그니처 확장), 결과를 `with { Grade = g, GradeReason = why }`. 컬럼 공통 사유(pUnstable)는 Tick에서 일괄 한 단계 추가 강등.
+
+**UI(ff.js, 기존 P-6 자산)**: 이미 `.ff-grade-A/B/C` 색 클래스 존재 → `s.gradeReason`을 셀 `title`(툴팁)로 노출만 추가.
+
+**테스트(xUnit, PhaseI §5.7 프로젝트)**:
+- 신선 PV + 정상 → config Grade 그대로.
+- stale PV → ≥B. transient → 한 단계. stale+transient+mb불일치 → C(바닥).
+- `Downgrade`는 A를 넘어 C에서 더 내려가지 않음(클램프).
+
+**검증**: 빌드 0/0, `grep`로 쓰기 0건 유지, advisory 응답에 `gradeReason` 등장, 한 스트림 강제 stale 시 해당 카드만 강등.
+
+---
+
+## WO-2 — P-2 PCT/차온 모니터 (2순위, 반쯤 완성)
+
+**목적**: 죽은 코드 `TempCorrection.PressureCompensated`를 **엔진에 배선** + `DiffTemp` 추가 → 진공노이즈 제거된 PCT·차온을 모니터로 산출. **P-3(프론트 위치)·P-5(C등급 근거)의 입력**.
+**근거**: spec §13.3(PCT/ΔT), §13.6(블록), §14.1(dT/dP≈0.5°C/torr — 진공 ±2torr가 구배 절반 → PCT 필수).
+
+**신규 블록 (`ComputationBlocks.cs`)**:
+```csharp
+/// <summary>차온/이중차온 — 공통모드(압력·계절) 상쇄, 프론트 이동만 부각. §13.3</summary>
+public static class DiffTemp
+{
+    public static double Delta(double tHi, double tLo) => tHi - tLo;            // 두 트레이 차온
+    public static double Double(double tA, double tB, double tC) => (tA - tB) - (tB - tC); // 이중차온(곡률)
+}
+```
+> `TempCorrection.PressureCompensated`는 그대로 사용(추가 코드 없음). PCT = `T_meas − dTdP·(P − P_ref)`.
+
+**엔진 배선**:
+- `ColumnState`에 `FirstOrderLag PRefSeed`(또는 단순 `double _pRef`) 추가 — `cfg.PRef`가 NaN이면 첫 정상 압력으로 시드.
+- `BuildSnapshotAsync`(Supervisor)에 `cfg.TempTags` PV 읽기를 추가(이미 feed/pressure/levels/streams 읽는 패턴 재사용). `PvSnapshot`에 `IReadOnlyList<TagSample> Temps`를 추가(positional이므로 **새 record 필드는 init 프로퍼티로** 추가하거나 `PvSnapshot`를 확장 — 본 문서는 `PvSnapshot`에 `Temps` init 프로퍼티 추가 권장).
+- Tick에서 각 온도에 PCT 계산 → `AdvisoryResult.Temps`(`TempPoint`)로 저장. `dTdP==0`이면 PCT=raw(생온도, 모니터만).
+- **advisory-only**: Temps는 표시·P-3 입력일 뿐 권장SP에 영향 없음(이번 WO 한정).
+
+**ConfigStore/Controller/DDL**: §0의 `temp_tags`·`dtdp`·`p_ref`·`sensitive_tray_tag` 반영(load/save/map).
+
+**UI(ff.js)**: 카드 하단에 온도 미니행(태그·raw·PCT) 1줄. 없으면 생략.
+
+**테스트**: `TempCorrection`(P 상승 시 PCT가 raw보다 낮아짐, dTdP=0이면 PCT=raw), `DiffTemp.Delta/Double` 산술, `PRef` NaN 시드 경로.
+
+**검증**: dtdp>0 컬럼에서 진공 흔들 때 raw는 출렁이나 PCT는 평탄(공통모드 상쇄) 확인.
+
+---
+
+## WO-3 — P-1 θ 자동튜닝 (3순위, 노력 大·통계)
+
+**목적**: seed θ/τ가 전부 placeholder(PhaseI §5.8 경고)인 문제를 해소. **정상 운전 중 자연외란**으로 θ를 **passive 식별**해 **제안만**(자동반영 금지·운전원 승인 시 config 반영).
+**근거**: spec §13.4(교차상관 θ, 스팀 부분상관으로 폐루프 오염 회피), §13.7(θ는 신뢰도 등급 붙은 추정치).
+
+> **현실 경고(spec §13.2)**: 단일점 생온도 SNR 낮음 → **WO-2의 PCT/ΔT를 입력으로** 쓰고, **스팀 OP(`SteamOpTag`)를 2번째 입력으로 부분상관**해 TICA 폐루프 동특성을 θ로 오귀속하지 않게 한다. 외란 부족 시 **신뢰도 낮음 → 제안 억제(null)**.
+
+**신규 블록 (`ComputationBlocks.cs` 또는 신규 `CrossCorrLagEstimator.cs`)** — 계약(시그니처) 고정:
+```csharp
+/// <summary>
+/// Passive 전달지연 식별. ΔF(피드 변화)와 ΔS_i(=ΔPCT/Δflow) 의 교차상관 최대 지연 = θ.
+/// 스팀 ΔS_steam 을 2번째 입력으로 부분상관(partial corr)해 폐루프 오염 제거(§13.4).
+/// 사전백색화(pre-whitening=1차차분) 적용. I/O 없음, 컬럼 루프 단일 소유(락 불필요).
+/// </summary>
+public sealed class CrossCorrLagEstimator
+{
+    public CrossCorrLagEstimator(int maxLagSamples, int historySamples, double minSignalStd);
+    /// 매 틱 호출. 반환: 충분한 외란 누적 후에만 (θup,θdn,conf), 아니면 null.
+    public (double thetaUpSec, double thetaDnSec, double conf)? Push(
+        double dFeed, double dResponse, double dSteam, double tsSec);
+}
+```
+**알고리즘(구현 지침)**:
+1. 입력은 **1차차분(Δ)** 받음(미분=사전백색화). 링버퍼(historySamples)에 `dFeed`,`dResponse`,`dSteam` 누적.
+2. 외란 검정: `std(dFeed) < minSignalStd` → 신뢰 0, null 반환(억제).
+3. **부분상관**: `dResponse`에서 `dSteam` 선형회귀 성분 제거(잔차 `r = dResponse − β·dSteam`, β=cov/var). 이후 `ρ(τ)=corr(dFeed[t], r[t+τ])` for τ∈[0,maxLag].
+4. `θ = argmax_τ ρ(τ)·ts`. `conf = max ρ`(0~1, 음수면 0).
+5. 상승/하강 비대칭: `dFeed>0` 표본만으로 θup, `dFeed<0` 표본만으로 θdn 별도 추정(표본 부족 시 공통값).
+6. `conf < 0.3`면 제안 억제(null).
+
+**배선**: `StreamState`에 컬럼당 1개 estimator(또는 commanded 스트림별). Tick에서 `cfg.ThetaAutoTune && WO-2 PCT 가용` 일 때만 `Push` → `StreamAdvisory.ThetaSuggestUpSec/DnSec/Conf` 채움. **config θ는 변경하지 않음**(제안 전용).
+
+**UI**: 카드에 "θ 제안 ↑NNs ↓NNs (conf 0.x)" 보조행. 운전원이 설정 에디터에서 수동 반영.
+
+**테스트**: 합성 신호(알려진 θ로 지연된 응답 + 노이즈)에 대해 추정 θ가 ±1 샘플 내. 외란 std 미달 시 null. 스팀 상관 주입 시 부분상관이 제거하는지(스팀만 상관된 가짜 지연은 conf 낮게).
+
+**검증**: 라이브에서 ThetaAutoTune=true 컬럼이 외란 충분 시에만 제안 노출, config 무변경(쓰기 0건) 확인.
+
+> **현실성**: 데모 시스템 온도는 인위 생성(spec §13.7) → 실플랜트 전 **검증 보류 가능**. 본 WO는 **인터페이스·블록·테스트까지** 턴키로 두되, 가동 스위치(`ThetaAutoTune`)는 기본 false.
+
+---
+
+## WO-4 — P-4 느린 바이어스 적응 (4순위)
+
+**목적**: 계절 CW 스윙 등 **크지만 느린 외란**(spec §14.4)을 정밀모델 대신 **장기 MA로 K_obs·k_V 추세**를 내어 운전원에게 "계절 보정 제안". 자동 변경 아님.
+**근거**: spec §14.4(느린 바이어스/운전원 트림), §14.3 B등급(V_loss는 장기 MA로만 의미).
+
+**설계**:
+- `ColumnState`에 `MovingAverage`(창=`BiasMaWindowSec/ScanSec` 샘플) 2개: `VLossMa`, 그리고 commanded 스트림별 `KObsMa`(=PV/FeedFiltered 의 MA).
+- **정상상태에서만 갱신**(transient·BAD 제외) — 과도 표본 오염 방지.
+- 산출: `AdvisoryResult.VLossMa`, `StreamAdvisory.KObsSuggest`(= K_obs MA, config TargetCoeff와 비교해 드리프트 표시).
+- **advisory-only**: 제안값일 뿐 엔진 K는 config 그대로.
+
+**테스트**: 일정 비율 입력 스텝 후 MA가 천천히 수렴(창 길이만큼), 과도 표본은 MA에 안 들어감.
+
+**검증**: 장기 가동 후 KObsSuggest가 config K 부근, 인위적 bias 주입 시 추세 이동.
+
+> WO-4의 `VLossMa`는 **WO-6 전환류 트리거 입력**으로 재사용(순간 V_loss는 §5.3대로 신뢰불가 → MA로 판정).
+
+---
+
+## WO-5 — P-3 Sweet-Spot / 프론트 위치 지표 (5순위, P-2 의존)
+
+**목적**: WO-2의 제품존 PCT/ΔT(민감트레이)를 **프론트 위치 프록시**로 삼아 드리프트 시 **환류/boilup 트림 권장**(advisory). analyzer 있으면 우선.
+**근거**: spec §13.5(2층 구조: 빠른 에너지=피드포워드, 느린 조성=온도 피드백), §13.2 함정②(제품존 신호 약함 → 차온 필수), §14.3 C등급.
+
+**신규 블록 (`FrontPositionIndicator.cs`)**:
+```csharp
+/// <summary>제품존 PCT/ΔT 의 기준대비 드리프트 → sweet-spot 건전성 + 트림 방향 권장. advisory.</summary>
+public sealed class FrontPositionIndicator
+{
+    public FrontPositionIndicator(double bandwidth, double refTau);
+    public (string state, string? trimAdvice, Confidence grade) Update(
+        double frontMetric, double tsSec);   // frontMetric = 민감트레이 PCT 또는 제품존 ΔT
+}
+```
+- 느린 기준(EMA refTau, 예 30~60min)에서 `frontMetric` 이탈량 산출.
+- 밴드 내=「정상」 / 위로 드리프트=「프론트 상승 — 경비물 혼입 위험: 환류↑ 권장」(브레인스토밍 Q2/Q3 정석) / 아래=「프론트 하강 — boilup↑/환류↓ 권장」.
+- 등급: 단일 생온도면 C(신호 약함), 차온/analyzer면 B 이상.
+- **트림은 권장 문구만**(`AdvisoryResult.FrontPositionState`/`FrontTrimAdvice`) — SP 미변경.
+
+**배선**: WO-2 Temps에서 `SensitiveTrayTag`(없으면 상-하 ΔT) 추출 → Indicator.Update → AdvisoryResult 필드.
+
+**UI**: 카드 배너에 프론트 상태/트림 권장 표시(P-6 `ff-note` 자리 활용).
+
+**테스트**: 기준 대비 상/하 드리프트에 대한 state·trim 분기, 밴드 내 「정상」, 등급 강등(생온도→C).
+
+---
+
+## WO-6 — 전환류(Total Reflux) 평형복귀 모드 ★ 신규
+
+**요구(운전원)**: 컬럼 균형이 **심각하게 깨졌다고 판단되면**, **전환류 모드**로 전환 — **제품(P)·원료투입(F)·경비물(D)·중비물(B) 제거를 모두 차단**하고 **환류(R)를 전량 환류**로 두어 **평형 복귀**할 때까지 유지, 회복 후 정상 복귀.
+
+**공정 근거**: 증류 정석의 *total reflux* 회복기동 = `knowledge/PGMEA_측류추출운전방식_주의점.md §4.3`("외란 시: 측류 먼저 중단 → 환류비↑ 재안정화 → 회복 후 재개")의 극단형. 외란으로 조성 프론트가 무너지면, 드로우·피드를 끊고 내부 환류만 순환시키면 단별 조성 프로파일이 **재평형**된다. 측류추출탑은 측류 조성이 상부 경비물·하부 중비물 **균형에 전적 의존**(동 §2)하므로 균형 붕괴 시 **측류 혼입(off-spec) 직전 회복 카드**.
+
+### 6.1 아키텍처 결정 (불변식 준수)
+- **Phase II 범위 = 권장·상태표시까지**. 전환류는 본질적으로 **쓰기 동작**(드로우/피드 SP=0, 환류=max)이므로, **실제 실행은 PhaseIII(WriteGuard) 경유**. 본 WO는 **모드 판정 상태기계 + 권장 SP 산출 + UI 경보/표시**까지(쓰기 0건).
+- **트리거 권위 2모드**: `RecoveryAutoArm=false`(기본) → 엔진은 "전환류 권장(ARMED)"만 띄우고 **운전원 1클릭 확인** 후 Recovering 진입(PhaseIII에서 실제 쓰기). `=true` → 자동 권장 상태기계가 직접 Recovering 진입(여전히 표시/권장, 쓰기는 PhaseIII gating).
+- **오발동 비용 큼**(피드 차단=생산중단) → 트리거는 **순간 V_loss 금지**(§5.3). 과도(transient) 중엔 트리거 금지.
+- **다신호 트리거(canonical 근거: `PGMEA_측류추출운전방식_주의점.md §3`)** — "균형 심각 붕괴"는 단일 V_loss보다 아래 **지속 조건의 OR**로 판정(어느 하나라도 `ImbalanceTriggerSec` 지속 시 ARM):
+  - **① 물질수지**: `|VLossMa|/F > ImbalanceTriggerFrac` (WO-4 장기 MA).
+  - **② 프론트(감도트레이)**: WO-5 `FrontPositionState`=심각 드리프트(주의점 §3 1순위 = 감도트레이 온도. **가장 신뢰도 높은 조기신호**).
+  - **③ 플러딩/비산**: `DeltaPTag` 가용 시 `ΔP > DeltaPFloodLimit` (주의점 §3 4순위 — 비산이 제품 오염 직결).
+  - 신호별 가용성은 config로 결정(태그 없으면 해당 조건 비활성).
+
+### 6.2 상태기계 (`ColumnMode`)
+```
+        ┌────────────────────────── Normal ──────────────────────────┐
+        │  |VLossMa|/F > ImbalanceTriggerFrac  지속> ImbalanceTriggerSec │
+        │  AND !transient                                              │
+        │  AND (RecoveryAutoArm  OR  운전원 ARM 확인)                    │
+        ▼                                                              │
+   Recovering(전환류)                                                   │
+     권장: F→FeedRecoverySp(0), P/D/B→0(또는 RecoverySp), R→SpMax(전량)  │
+     dwell: 평형지표 안정(|VLossMa|/F < Frac·0.5  AND  프론트(WO-5) 정상) │
+            을 RecoverySettleSec 동안 연속 만족                          │
+        ▼                                                              │
+   Returning(복귀 램프)                                                  │
+     ReturnRampSec 동안 F·draw를 정상 권장값으로 RateLimiter 램프 복원    │
+     완료 → Normal ──────────────────────────────────────────────────┘
+   (어느 상태든 운전원 수동 Normal 복귀 가능 / FEED BAD 지속 시 Recovering 유지)
+```
+
+### 6.3 엔진 구현 (`FeedforwardEngine.cs` + `ColumnState`)
+- `ColumnState`에 추가: `ColumnMode Mode`, `double ImbalanceTimerSec`, `double RecoverySettleTimerSec`, `double ReturnTimerSec`, `bool OperatorArmed`(컨트롤러가 set).
+- **순수성 유지**: 상태 전이는 Tick 내에서 `st`(가변 ColumnState)로 처리 — 기존 SettleTimer와 동일 패턴(I/O 없음).
+- 절차(Tick 말미, advisory 산출 후):
+  1. `severe = ① || ② || ③` (위 다신호; 가용 신호만 평가). `① frac=|VLossMa|/ff > ImbalanceTriggerFrac`, `② WO-5 FrontPositionState 심각`, `③ ΔP>DeltaPFloodLimit`.
+  2. **Normal**: `!transient && severe` → `ImbalanceTimerSec += ts` else `=0`. `ImbalanceTimerSec ≥ ImbalanceTriggerSec` + (AutoArm || OperatorArmed) → `Mode=Recovering`, 타이머 리셋, OperatorArmed=false. (AutoArm=false면 ARM 없이는 "전환류 권장(ARMED 대기)" 표시만.)
+  3. **Recovering**: 스트림 권장값을 **오버라이드** — reflux(IsReflux||RefluxFromProduct)=`SpMax`, 그 외 commanded draw=`RecoverySp(NaN→0)`, FEED 권장=`FeedRecoverySp`. 평형조건(`frac < Frac*0.5 && 프론트 정상`) 연속 만족 시 `RecoverySettleTimerSec += ts`, 도달 시 `Mode=Returning`.
+  4. **Returning**: `ReturnTimerSec += ts`; 진행률 `α=min(1, ReturnTimerSec/ReturnRampSec)`로 draw/feed 권장을 0→정상값 보간(또는 RateLimiter가 자연 램프). `α>=1` → `Mode=Normal`.
+  5. `AdvisoryResult`에 `with { Mode = st.Mode, ModeReason = ..., VLossMa = ... }`. Recovering/Returning에선 각 `StreamAdvisory.RecommendedSp`가 오버라이드값, `Note`에 "전환류 복귀" 표기. **Grade는 강등하지 않되 Valid=false(운전원 인가 필요)**.
+- **FEED 권장 노출**: FEED는 스트림이 아니므로 `AdvisoryResult`에 `FeedRecommendedSp`(double?) init 프로퍼티 추가 — Recovering 시 `FeedRecoverySp`, 그 외 null.
+
+### 6.4 컨트롤러 (`FeedforwardController.cs`)
+- `POST api/ff/recovery/{columnId}/arm` — 운전원 ARM(=Supervisor 통해 해당 ColumnState.OperatorArmed=true). **Supervisor를 singleton 주입**(A2 정정으로 가능)해 컬럼 상태 접근. 쓰기 아님(모드 판정용 플래그).
+- `POST api/ff/recovery/{columnId}/cancel` — 수동 Normal 복귀.
+- (PhaseIII에서) 실제 SP 쓰기는 별도 `apply` 엔드포인트가 WriteGuard 경유.
+
+### 6.5 UI (ff.js / ff.css)
+- 카드 헤더에 모드 뱃지: `Normal`(무표시) / `전환류 복귀중 ●`(주황) / `복귀 램프 ●`(파랑) / `전환류 권장(ARMED)`(점멸 경보 + [확인] 버튼 → arm 호출).
+- Recovering/Returning 시 표에 "권장 SP" 열이 0/max 오버라이드로 표시, Valid=false라 흐리게(`ff-stale`)·"운전원 인가" 주석.
+
+### 6.6 DDL/ConfigStore
+§0의 recovery 컬럼들(`recovery_enabled`, `recovery_auto_arm`, `imbalance_trigger_frac`, `imbalance_trigger_sec`, `recovery_settle_sec`, `return_ramp_sec`, `feed_recovery_sp`) + stream `is_reflux`/`recovery_sp` 반영.
+
+### 6.7 테스트 (xUnit)
+- 합성 시퀀스: 정상 → VLossMa 임계 지속 초과(+!transient) → `Recovering` 진입. AutoArm=false면 OperatorArmed 없이는 **진입 안 함**.
+- Recovering 권장값: reflux=SpMax, P/D/B=0, FeedRecommendedSp=FeedRecoverySp.
+- 평형 회복(frac↓ 지속 RecoverySettleSec) → `Returning` → ReturnRampSec 경과 → `Normal`.
+- transient 중엔 트리거 타이머 누적 안 됨.
+- 수동 cancel 시 즉시 Normal.
+- **쓰기 0건**(엔진/컨트롤러 grep) — 모드 판정·권장만.
+
+### 6.8 안전 결정 (문서화)
+| 항목 | 결정 |
+|:-----|:-----|
+| 실행 권한 | 권장·표시는 PhaseII, **실제 SP 쓰기는 PhaseIII WriteGuard** 경유(전환류는 대규모 조작이라 운전원 확인 강제 권장) |
+| 오발동 방지 | 순간 V_loss 금지, `VLossMa`(장기 MA) 지속 초과 + `!transient` + (AutoArm||운전원 ARM) |
+| 복귀 부드�러움 | Returning에서 RateLimiter 램프 — bumpless |
+| 트리거 보수성 | 기본 `RecoveryAutoArm=false`(운전원 1클릭). 자동무장은 신뢰 확보 후 |
+| point of no return | 프론트(WO-5) "경비물 혼입 위험" 단계에서 **선제 ARM 권장**(정석) |
+
+---
+
+## §C. 통합 검증 (감독자 — diagnosis-checklist.md 8단계)
+
+1. **빌드**: `dotnet build src/Web/ExperionCrawler.csproj` 경고0/에러0.
+2. **쓰기 불변식**(FF 경로 한정): `grep -rE "ExperionOpcWriteClient|Write.*Async" src/Infrastructure/Control src/Web/Controllers/FeedforwardController.cs` → **0건**(범용 `ExperionOpcWriteClient.cs`는 OpcUa 폴더라 미포함 — 정상). WO 전체 advisory.
+3. **DI(A2)**: WO-6 적용 시 `FeedforwardSupervisor`가 singleton+hosted로 노출되어 **인스턴스 1개만 가동**(로그 틱 루프 1회) + 컨트롤러 주입 가능. WO-6 전이면 현 단일 AddHostedService 유지.
+4. **인덱스 정합(§0)**: ConfigStore SELECT 컬럼 ↔ `rd.GetXxx(n)` 1:1, 저장→재로드 라운드트립 일치(신규 필드 포함).
+5. **단위테스트**: WO-1~WO-6 케이스 + PhaseI 기존 4 모두 green.
+6. **라이브**: Tab 18에서 등급 강등(WO-1)·PCT(WO-2)·θ제안(WO-3)·KObs추세(WO-4)·프론트 트림(WO-5)·전환류 모드 뱃지/ARM(WO-6) 표시. 폴링 누수 없음.
+7. **전환류 시나리오**: 인위적 V_loss bias 주입 → VLossMa 임계 지속 → (ARM 후) Recovering 권장(R=max, F/P/D/B=0) → 회복 → Returning → Normal. 쓰기 0건.
+
+---
+
+## §D. P-7 (PhaseIII auto-write) — 기존 문서 정정 메모
+
+PhaseIII 문서는 대체로 유효하나 착수 전 아래 정정:
+- **D1**: PhaseIII §6이 지목한 `OpcUaClientService.cs`는 **그 이름으론 부재**. 그러나 **`src/Infrastructure/OpcUa/ExperionOpcWriteClient.cs`(namespace `ExperionCrawler.Infrastructure.Control`, `Opc.Ua.Client` 사용)가 이미 존재** — 쓰기 래퍼를 **신규 작성하지 말고 이 기존 클라이언트를 재사용/확장**(가드는 WriteGuard로 상위에서). 기존 읽기 서비스(Realtime/History/Metadata 등)는 건드리지 말 것.
+- **D2**: NodeId `ns=3;s="{tag}.sp"` 는 **미검증 가정** — `ExperionOpcWriteClient`의 실제 노드 지정 방식 + 서버 브라우즈로 **확인 후 확정**.
+- **D3**: WriteGuard 게이트는 **WO-1의 동적 Grade**(정적 config Grade 아님) + `!Transient` + SafetyMaxDelta. WO-6 전환류는 별도 `apply` 경로로 **운전원 확인 강제**.
+- **D4**: PhaseIII §1.2("B/C 금지")와 §4.3("스트림 단위 A만 대상")은 **per-stream 동적 Grade 기준**으로 통일.
+- **D5**: auth 재도입(`IKbAuthService`)은 **쓰기 엔드포인트에만**(advisory/config 읽기는 공개 유지).
+
+---
+
+## §E. 턴키 요약
+
+| WO | 항목 | 노력 | 신규 파일 | 변경 파일 | 가동 스위치(기본) |
+|:--:|:-----|:----:|:----------|:----------|:------------------|
+| A | 문서 드리프트 정정(§B 기준선화) | 小 | — | (WO-6 시 Program.cs DI 교체) | — |
+| 0 | 모델·DDL 공통확장 | 中 | — | Models/ConfigStore/Context/Controller | — |
+| 1 | P-5 등급 자동강등 | 小 | — | Engine, ff.js | 항상 |
+| 2 | P-2 PCT/차온 | 小 | (DiffTemp 블록) | Blocks/Engine/Supervisor/Store/Ctrl | dtdp>0 시 |
+| 3 | P-1 θ 자동튜닝 | 大 | CrossCorrLagEstimator | Engine/State/Supervisor | ThetaAutoTune=false |
+| 4 | P-4 느린 바이어스 | 中 | — | Engine/State | 항상(제안) |
+| 5 | P-3 프론트 위치 | 中 | FrontPositionIndicator | Engine/State | 온도 가용 시 |
+| 6 | 전환류 복귀 | 大 | — | Engine/State/Ctrl/ff.js/css | RecoveryEnabled=false, AutoArm=false |
+| D | P-7 정정 | — | (PhaseIII) | — | — |
+
+**구현 순서**: A(정정) → 0(공통확장·DDL·ConfigStore 인덱스검증) → 1 → 2 → 3 → 4 → 5 → 6 → C(검증). 각 WO는 **빌드+해당 테스트 green + 쓰기 0건 grep** 후 다음 진행.
+
+**불변식 재확인**: 본 문서 전체 범위에서 **제어 레지스터 쓰기 0건**. 전환류 포함 모든 실제 SP 쓰기는 PhaseIII.
+</content>
+</invoke>
+
+<result>
+File created successfully: /home/windpacer/projects/ExperionCrawler/docs/측류추출식-통합유량설정공식-구현코딩-PhaseII-분석엔진+전환류복귀.md
\ No newline at end of file
diff --git a/docs/측류추출식-통합유량설정공식-구현코딩-PhaseII.md b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseII.md
new file mode 100644
index 0000000..53e6aee
--- /dev/null
+++ b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseII.md
@@ -0,0 +1,514 @@
+# 측류추출 통합유량 — Phase II UI 구현 코딩 (Tab 18: 설정 + 권장 SP 대시보드)
+
+> **성격**: Phase I advisory 엔진(`...-PhaseI.md`)의 **Web UI 코딩 명세 + 검증 절차**.
+> 감독자가 `diagnosis-checklist.md` 8단계로 진단한 뒤 반영. **advisory 불변식 유지** — 제어 레지스터 쓰기 0건.
+> Phase II는 **운전원이 경험상수를 공급**하고 **권장 SP를 화면에서 본다**(수동 인가). 자동 쓰기는 Phase III.
+
+**Phase II 범위 분리**:
+- **본 문서 = UI 코딩**: ① 설정 CRUD API(admin) ② Tab 18 = 설정 에디터 + 권장 SP 대시보드.
+- **Phase II-분석(별도)**: θ 자동튜닝·PCT/차온·front-position·confidence 자동강등·느린 바이어스(= PhaseI §6 P-1~P-5). 본 문서 §6에 인터페이스 훅만.
+
+---
+
+## 0. 기존 UI 아키텍처 전제 (확인됨)
+
+| 요소 | 사실 |
+|:-----|:-----|
+| 탭 라우터 | `core.js`의 `paneInit` 맵 + `activateTab(tab)` → `data-src`(`/panes/<tab>.html`) HTML을 fetch해 주입 후 `paneInit[tab]?.()` 호출 |
+| 탭 등록 | ① `index.html` `<li class="nav-item" data-tab="ff">` ② `<section class="pane" id="pane-ff" data-src="/panes/ff.html">` ③ `<script src="/js/ff.js">` ④ `ff.js`에서 `paneInit.ff = ffInit` |
+| API 헬퍼 | `core.js` `api(method, path, body)` (camelCase JSON), `esc()` XSS 이스케이프, `fmtVal/fmtTs` |
+| admin 인증 | KB 토큰 — 헤더 `X-Kb-Token`, 백엔드 `IKbAuthService.ValidateAsync`, 프론트 `sessionStorage.kbToken` (docs.js 패턴) |
+| JSON 바인딩 | `PropertyNamingPolicy=null` + **`PropertyNameCaseInsensitive=true`** → 프론트 camelCase 바디가 PascalCase DTO에 바인딩됨. 응답은 **camelCase 명시 익명객체**(CODING_CONVENTIONS) |
+| 라이브 폴링 | trend.js의 `setInterval` 패턴 |
+
+---
+
+## 1. 파일 배치 (신규/변경)
+
+```
+변경:
+  src/Core/Application/Feedforward/IFeedforwardStores.cs   # IFeedforwardConfigStore에 CRUD 추가
+  src/Infrastructure/Control/FeedforwardConfigStore.cs     # Save/Delete (파라미터화)
+  src/Web/Controllers/FeedforwardController.cs             # config CRUD(admin) 추가
+  src/Web/wwwroot/index.html                               # nav-item + pane + script 3줄
+신규:
+  src/Web/wwwroot/panes/ff.html                            # 대시보드 + 설정 에디터 마크업
+  src/Web/wwwroot/js/ff.js                                 # paneInit.ff — 폴링·렌더·에디터
+  src/Web/wwwroot/css/ff.css                               # (또는 style.css에 추가)
+```
+
+> Phase I과 동일하게 **단일 csproj**(`src/Web/ExperionCrawler.csproj`). C# 빌드: `dotnet build src/Web/ExperionCrawler.csproj`.
+
+---
+
+## 2. 백엔드 — 설정 CRUD (admin)
+
+### 2.1 Store 인터페이스 확장 (`IFeedforwardStores.cs`)
+
+```csharp
+public interface IFeedforwardConfigStore
+{
+    Task<IReadOnlyList<ColumnConfig>> LoadAllAsync(CancellationToken ct = default);
+    Task<int>  SaveColumnAsync(ColumnConfig cfg, CancellationToken ct = default);  // Id==0 INSERT, else UPDATE. 반환=id
+    Task       DeleteColumnAsync(int columnId, CancellationToken ct = default);
+}
+```
+
+### 2.2 Store 구현 추가 (`FeedforwardConfigStore.cs`)
+
+> **★ 사용자 입력이 들어오므로 전 컬럼 파라미터 바인딩**(인젝션 차단). 컬럼+스트림은 트랜잭션으로 원자적 교체.
+> `AdvisoryOnly`는 항상 TRUE 강제(불변식).
+
+```csharp
+// using System.Data.Common; 추가
+
+private static DbParameter P(DbCommand cmd, string name, object? val)
+{
+    var p = cmd.CreateParameter();
+    p.ParameterName = name;
+    p.Value = val ?? DBNull.Value;
+    cmd.Parameters.Add(p);
+    return p;
+}
+
+public async Task<int> SaveColumnAsync(ColumnConfig cfg, CancellationToken ct = default)
+{
+    var conn = _ctx.Database.GetDbConnection();
+    if (conn.State != ConnectionState.Open) await conn.OpenAsync(ct);
+    await using var tx = await conn.BeginTransactionAsync(ct);
+
+    int id = cfg.Id;
+    var levelTags = string.Join(',', cfg.LevelTags);
+
+    if (id == 0)
+    {
+        await using var cmd = conn.CreateCommand();
+        cmd.Transaction = tx;
+        cmd.CommandText = """
+            INSERT INTO ff_column_config
+              (name, enabled, feed_tag, pressure_tag, level_tags, scan_sec,
+               feed_filter_tau_sec, feed_move_thr_per_min, press_filter_tau_sec,
+               pressure_band, settle_sec, stale_sec, product_key, advisory_only)
+            VALUES (@name,@en,@feed,@pres,@lvl,@scan,@fft,@fmt,@pft,@pb,@settle,@stale,@pk,TRUE)
+            RETURNING id
+            """;
+        P(cmd,"@name",cfg.Name); P(cmd,"@en",cfg.Enabled); P(cmd,"@feed",cfg.FeedTag.ToLowerInvariant());
+        P(cmd,"@pres",(object?)cfg.PressureTag?.ToLowerInvariant()); P(cmd,"@lvl",levelTags.ToLowerInvariant());
+        P(cmd,"@scan",cfg.ScanSec); P(cmd,"@fft",cfg.FeedFilterTauSec); P(cmd,"@fmt",cfg.FeedMoveThresholdPerMin);
+        P(cmd,"@pft",cfg.PressFilterTauSec); P(cmd,"@pb",cfg.PressureBand); P(cmd,"@settle",cfg.SettleSec);
+        P(cmd,"@stale",cfg.StaleSec); P(cmd,"@pk",cfg.ProductKey ?? "P");
+        id = Convert.ToInt32(await cmd.ExecuteScalarAsync(ct));
+    }
+    else
+    {
+        await using var cmd = conn.CreateCommand();
+        cmd.Transaction = tx;
+        cmd.CommandText = """
+            UPDATE ff_column_config SET
+              name=@name, enabled=@en, feed_tag=@feed, pressure_tag=@pres, level_tags=@lvl,
+              scan_sec=@scan, feed_filter_tau_sec=@fft, feed_move_thr_per_min=@fmt,
+              press_filter_tau_sec=@pft, pressure_band=@pb, settle_sec=@settle,
+              stale_sec=@stale, product_key=@pk, advisory_only=TRUE
+            WHERE id=@id
+            """;
+        P(cmd,"@id",id); P(cmd,"@name",cfg.Name); P(cmd,"@en",cfg.Enabled);
+        P(cmd,"@feed",cfg.FeedTag.ToLowerInvariant()); P(cmd,"@pres",(object?)cfg.PressureTag?.ToLowerInvariant());
+        P(cmd,"@lvl",levelTags.ToLowerInvariant()); P(cmd,"@scan",cfg.ScanSec); P(cmd,"@fft",cfg.FeedFilterTauSec);
+        P(cmd,"@fmt",cfg.FeedMoveThresholdPerMin); P(cmd,"@pft",cfg.PressFilterTauSec); P(cmd,"@pb",cfg.PressureBand);
+        P(cmd,"@settle",cfg.SettleSec); P(cmd,"@stale",cfg.StaleSec); P(cmd,"@pk",cfg.ProductKey ?? "P");
+        await cmd.ExecuteNonQueryAsync(ct);
+    }
+
+    // 스트림 원자적 교체
+    await using (var del = conn.CreateCommand())
+    {
+        del.Transaction = tx; del.CommandText = "DELETE FROM ff_stream_config WHERE column_id=@id";
+        P(del,"@id",id); await del.ExecuteNonQueryAsync(ct);
+    }
+    foreach (var s in cfg.Streams)
+    {
+        await using var ins = conn.CreateCommand();
+        ins.Transaction = tx;
+        ins.CommandText = """
+            INSERT INTO ff_stream_config
+              (column_id, key, flow_tag, role, target_coeff, theta_up_sec, theta_dn_sec, tau_sec,
+               sp_min, sp_max, rate_up_per_min, rate_dn_per_min, reflux_from_product, grade)
+            VALUES (@cid,@key,@flow,@role,@k,@tup,@tdn,@tau,@smin,@smax,@rup,@rdn,@rfp,@grade)
+            """;
+        P(ins,"@cid",id); P(ins,"@key",s.Key); P(ins,"@flow",s.FlowTag.ToLowerInvariant());
+        P(ins,"@role",s.Role.ToString()); P(ins,"@k",s.TargetCoeff); P(ins,"@tup",s.ThetaUpSec);
+        P(ins,"@tdn",s.ThetaDnSec); P(ins,"@tau",s.TauSec); P(ins,"@smin",s.SpMin); P(ins,"@smax",s.SpMax);
+        P(ins,"@rup",s.RateUpPerMin); P(ins,"@rdn",s.RateDnPerMin); P(ins,"@rfp",s.RefluxFromProduct);
+        P(ins,"@grade",s.Grade.ToString());
+        await ins.ExecuteNonQueryAsync(ct);
+    }
+
+    await tx.CommitAsync(ct);
+    return id;
+}
+
+public async Task DeleteColumnAsync(int columnId, CancellationToken ct = default)
+{
+    var conn = _ctx.Database.GetDbConnection();
+    if (conn.State != ConnectionState.Open) await conn.OpenAsync(ct);
+    await using var cmd = conn.CreateCommand();
+    cmd.CommandText = "DELETE FROM ff_column_config WHERE id=@id";  // ON DELETE CASCADE → 스트림 동반 삭제
+    P(cmd,"@id",columnId);
+    await cmd.ExecuteNonQueryAsync(ct);
+}
+```
+
+> **누적 상태 정리(PhaseI 진단 잔여 #2)**: 컬럼 삭제 시 `AdvisoryStore`/`Supervisor._states`도 정리하려면
+> `IFeedforwardAdvisoryStore.Remove(int id)`를 추가하고 컨트롤러 DELETE에서 호출(아래 §2.3 주석). Supervisor는
+> 다음 Tick에서 enabled 목록에 없으면 자연 미갱신 — `_states` 잔존만 남으나 미미.
+
+### 2.3 컨트롤러 확장 (`FeedforwardController.cs`)
+
+```csharp
+// 생성자에 IKbAuthService 주입 (DocsController 패턴)
+private readonly IFeedforwardAdvisoryStore _store;
+private readonly IFeedforwardConfigStore   _config;
+private readonly IKbAuthService            _auth;
+public FeedforwardController(IFeedforwardAdvisoryStore store, IFeedforwardConfigStore config, IKbAuthService auth)
+{ _store = store; _config = config; _auth = auth; }
+
+private Task<bool> IsAdminAsync(CancellationToken ct)
+    => _auth.ValidateAsync(Request.Headers["X-Kb-Token"].ToString(), ct);
+
+// ── 설정 조회 (admin) ──────────────────────────────────────────
+[HttpGet("config")]
+public async Task<IActionResult> GetConfig(CancellationToken ct)
+{
+    if (!await IsAdminAsync(ct)) return Unauthorized();
+    var cols = await _config.LoadAllAsync(ct);
+    return Ok(new { columns = cols.Select(MapConfig) });
+}
+
+[HttpPost("config")]
+public async Task<IActionResult> SaveConfig([FromBody] ColumnConfig body, CancellationToken ct)
+{
+    if (!await IsAdminAsync(ct)) return Unauthorized();
+    var id = await _config.SaveColumnAsync(body, ct);
+    return Ok(new { success = true, id });
+}
+
+[HttpDelete("config/{id:int}")]
+public async Task<IActionResult> DeleteConfig(int id, CancellationToken ct)
+{
+    if (!await IsAdminAsync(ct)) return Unauthorized();
+    await _config.DeleteColumnAsync(id, ct);
+    // _store.Remove(id);   // IFeedforwardAdvisoryStore.Remove 구현 시 활성화
+    return Ok(new { success = true });
+}
+
+// camelCase 매핑 (설정 — 응답)
+private static object MapConfig(ColumnConfig c) => new
+{
+    id = c.Id, name = c.Name, enabled = c.Enabled, advisoryOnly = c.AdvisoryOnly,
+    feedTag = c.FeedTag, pressureTag = c.PressureTag, levelTags = c.LevelTags,
+    scanSec = c.ScanSec, feedFilterTauSec = c.FeedFilterTauSec,
+    feedMoveThresholdPerMin = c.FeedMoveThresholdPerMin, pressFilterTauSec = c.PressFilterTauSec,
+    pressureBand = c.PressureBand, settleSec = c.SettleSec, staleSec = c.StaleSec, productKey = c.ProductKey,
+    streams = c.Streams.Select(s => new
+    {
+        key = s.Key, flowTag = s.FlowTag, role = s.Role.ToString(), targetCoeff = s.TargetCoeff,
+        thetaUpSec = s.ThetaUpSec, thetaDnSec = s.ThetaDnSec, tauSec = s.TauSec,
+        spMin = s.SpMin, spMax = s.SpMax, rateUpPerMin = s.RateUpPerMin, rateDnPerMin = s.RateDnPerMin,
+        refluxFromProduct = s.RefluxFromProduct, grade = s.Grade.ToString()
+    })
+};
+```
+
+> `[FromBody] ColumnConfig`는 record라도 `PropertyNameCaseInsensitive=true`로 camelCase 바디가 바인딩됨.
+> `double.MaxValue`(1e9 DDL 기본) 같은 큰 수는 그대로 직렬화/역직렬화. `Enum.Parse`는 Role/Grade 문자열로 처리(StreamConfig가 enum이라 JSON 문자열 "Commanded"/"A" 그대로 바인딩).
+
+---
+
+## 3. 프론트엔드 — Tab 18
+
+### 3.1 index.html 와이어링 (3곳)
+
+```html
+<!-- (1) nav: data-tab="trend" 다음 -->
+<li class="nav-item" data-tab="ff">
+  <span class="nav-ico">⚖️</span><span class="nav-txt">유량 권장(FF)</span>
+</li>
+
+<!-- (2) pane: pane-trend 다음 -->
+<section class="pane" id="pane-ff" data-src="/panes/ff.html"></section>
+
+<!-- (3) script: /js/trend.js 다음 -->
+<script src="/js/ff.js"></script>
+<link rel="stylesheet" href="/css/ff.css">   <!-- 또는 style.css에 병합 -->
+```
+
+### 3.2 panes/ff.html
+
+```html
+<div class="ff-wrap">
+  <div class="ff-head">
+    <h2>측류추출 유량 권장 (Advisory · 보조지표)</h2>
+    <span class="ff-badge">읽기 전용 — 권장값. 인가는 운전원</span>
+    <button id="ff-cfg-toggle" class="btn">설정 ▾</button>
+  </div>
+
+  <!-- 권장 SP 대시보드 (공개 읽기) -->
+  <div id="ff-dash" class="ff-dash"><div class="ff-empty">불러오는 중…</div></div>
+
+  <!-- 설정 에디터 (admin) -->
+  <div id="ff-cfg" class="ff-cfg" style="display:none">
+    <div class="ff-cfg-bar">
+      <input id="ff-token" type="password" placeholder="admin 토큰" class="inp">
+      <button id="ff-unlock" class="btn">잠금해제</button>
+      <button id="ff-new" class="btn" disabled>+ 컬럼</button>
+      <span id="ff-cfg-msg" class="ff-msg"></span>
+    </div>
+    <div id="ff-cfg-list"></div>
+  </div>
+</div>
+```
+
+### 3.3 js/ff.js (paneInit.ff)
+
+```javascript
+/* ff.js — 측류추출 유량 권장(FF) 대시보드 + 설정 에디터.
+   대시보드는 공개 읽기(/api/ff/advisory), 설정은 admin(X-Kb-Token). */
+paneInit.ff = ffInit;
+
+let ffTimer = null;
+
+function ffToken() { return sessionStorage.getItem('kbToken') || ''; }
+async function ffApiAdmin(method, path, body) {
+  const h = { 'Content-Type': 'application/json' };
+  const t = ffToken(); if (t) h['X-Kb-Token'] = t;
+  const res = await fetch(path, { method, headers: h, body: body ? JSON.stringify(body) : undefined });
+  if (res.status === 401) throw new Error('UNAUTH');
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+  return res.status === 204 ? null : res.json();
+}
+
+async function ffInit() {
+  // 재진입 시 폴링 중복 방지
+  if (ffTimer) { clearInterval(ffTimer); ffTimer = null; }
+  await ffLoadDash();
+  ffTimer = setInterval(ffLoadDash, 3000);
+
+  document.getElementById('ff-cfg-toggle').onclick = () => {
+    const c = document.getElementById('ff-cfg');
+    c.style.display = c.style.display === 'none' ? 'block' : 'none';
+  };
+  document.getElementById('ff-unlock').onclick = ffUnlock;
+  document.getElementById('ff-new').onclick = () => ffEditColumn(null);
+  if (ffToken()) ffEnableAdmin();
+}
+
+// ── 대시보드 (공개) ──────────────────────────────────────────────
+async function ffLoadDash() {
+  let data;
+  try { data = await api('GET', '/api/ff/advisory'); }
+  catch (e) { return; }                       // 일시 오류 무시(다음 폴링)
+  const host = document.getElementById('ff-dash');
+  if (!host) { clearInterval(ffTimer); ffTimer = null; return; }   // 탭 떠남
+  const cols = data.columns || [];
+  if (!cols.length) { host.innerHTML = '<div class="ff-empty">활성 컬럼 없음</div>'; return; }
+  host.innerHTML = cols.map(ffCard).join('');
+}
+
+function ffTrendIco(t) { return t > 0 ? '▲' : t < 0 ? '▼' : '–'; }
+
+function ffCard(c) {
+  const rows = (c.streams || []).map(s => `
+    <tr class="${s.valid ? '' : 'ff-stale'}">
+      <td>${esc(s.key)}</td><td class="ff-tag">${esc(s.flowTag)}</td>
+      <td><span class="ff-role ff-role-${esc(s.role)}">${esc(s.role)}</span></td>
+      <td class="ff-num">${fmtVal(s.pv)}</td>
+      <td class="ff-num ff-rec">${s.recommendedSp==null?'–':fmtVal(s.recommendedSp)}</td>
+      <td class="ff-num">${s.gap==null?'–':fmtVal(s.gap)}</td>
+      <td>${ffTrendIco(s.trend)}</td>
+      <td><span class="ff-grade ff-grade-${esc(s.grade)}">${esc(s.grade)}</span></td>
+    </tr>`).join('');
+  const banner = c.transient
+    ? `<div class="ff-transient">과도상태: ${esc(c.transientReason)} — 권장값 정착 대기</div>` : '';
+  const mb = `물질수지: ${esc(c.massBalanceState)}` +
+    (c.vLoss!=null ? ` · V_loss ${fmtVal(c.vLoss)}` : '') +
+    (c.yield!=null ? ` · 수율 ${fmtVal(c.yield)}%` : '');
+  return `
+  <div class="ff-col-card ${c.enabled?'':'ff-disabled'}">
+    <div class="ff-col-head"><b>${esc(c.columnName)}</b>
+      <span class="ff-feed">FEED ${fmtVal(c.feedFiltered)}</span>
+      <span class="ff-time">${fmtTs(c.computedAt)}</span></div>
+    ${banner}
+    <table class="ff-tbl"><thead><tr>
+      <th>스트림</th><th>태그</th><th>역할</th><th>PV</th><th>권장 SP</th><th>Δ</th><th>추세</th><th>신뢰</th>
+    </tr></thead><tbody>${rows}</tbody></table>
+    <div class="ff-mb">${esc(mb)}</div>
+    <div class="ff-note">D·B는 레벨 제어가 구동(기대치). 권장값은 참고 — 인가는 운전원.</div>
+  </div>`;
+}
+
+// ── 설정 에디터 (admin) ──────────────────────────────────────────
+async function ffUnlock() {
+  const tok = document.getElementById('ff-token').value.trim();
+  if (!tok) return;
+  // KB 로그인 재사용: 토큰 유효성은 첫 admin 호출에서 검증
+  sessionStorage.setItem('kbToken', tok);
+  try { await ffLoadConfig(); ffEnableAdmin(); ffMsg('잠금 해제됨'); }
+  catch (e) { sessionStorage.removeItem('kbToken'); ffMsg('토큰 무효', true); }
+}
+function ffEnableAdmin() { document.getElementById('ff-new').disabled = false; ffLoadConfig().catch(()=>{}); }
+function ffMsg(m, err) { const e=document.getElementById('ff-cfg-msg'); e.textContent=m; e.className='ff-msg'+(err?' err':''); }
+
+async function ffLoadConfig() {
+  const data = await ffApiAdmin('GET', '/api/ff/config');
+  const host = document.getElementById('ff-cfg-list');
+  host.innerHTML = (data.columns||[]).map(ffCfgRow).join('') || '<div class="ff-empty">설정 없음</div>';
+  host.querySelectorAll('[data-edit]').forEach(b => b.onclick = () =>
+    ffEditColumn(data.columns.find(c => c.id == b.dataset.edit)));
+  host.querySelectorAll('[data-del]').forEach(b => b.onclick = () => ffDelete(b.dataset.del));
+}
+function ffCfgRow(c) {
+  return `<div class="ff-cfg-item"><b>${esc(c.name)}</b> (id ${c.id}) — feed ${esc(c.feedTag)},
+    스트림 ${c.streams.length}개, ${c.enabled?'활성':'비활성'}
+    <button class="btn sm" data-edit="${c.id}">편집</button>
+    <button class="btn sm danger" data-del="${c.id}">삭제</button></div>`;
+}
+async function ffDelete(id) {
+  if (!confirm(`컬럼 ${id} 삭제?`)) return;
+  try { await ffApiAdmin('DELETE', `/api/ff/config/${id}`); await ffLoadConfig(); ffMsg('삭제됨'); }
+  catch (e) { ffMsg(e.message==='UNAUTH'?'권한 없음':'삭제 실패', true); }
+}
+
+// 간단 JSON 편집(턴키 최소형). Phase II-b에서 폼 위젯화 권장.
+function ffEditColumn(c) {
+  const tmpl = c || { name:'', enabled:false, feedTag:'', pressureTag:null, levelTags:[],
+    scanSec:2, feedFilterTauSec:300, feedMoveThresholdPerMin:5, pressFilterTauSec:60,
+    pressureBand:3, settleSec:1800, staleSec:120, productKey:'P',
+    streams:[{key:'P',flowTag:'',role:'Commanded',targetCoeff:0.95,thetaUpSec:60,thetaDnSec:60,
+              tauSec:900,spMin:0,spMax:1e9,rateUpPerMin:30,rateDnPerMin:60,refluxFromProduct:false,grade:'A'}] };
+  const json = prompt('컬럼 설정(JSON) 편집:', JSON.stringify(tmpl));
+  if (!json) return;
+  let body; try { body = JSON.parse(json); } catch { return ffMsg('JSON 파싱 오류', true); }
+  if (c) body.id = c.id;
+  ffApiAdmin('POST', '/api/ff/config', body)
+    .then(() => { ffLoadConfig(); ffMsg('저장됨'); })
+    .catch(e => ffMsg(e.message==='UNAUTH'?'권한 없음':'저장 실패: '+e.message, true));
+}
+```
+
+> 에디터는 **턴키 최소형(JSON prompt)** 으로 제공. 운전원용 폼 위젯(스트림 행 추가/삭제, 검증)은 **Phase II-b**에서
+> 고도화 권장(본 문서 범위 밖). 대시보드는 완성형.
+
+### 3.4 css/ff.css (요지)
+
+```css
+.ff-wrap{padding:16px;color:var(--t1)}
+.ff-head{display:flex;align-items:center;gap:12px;margin-bottom:12px}
+.ff-badge{font-size:12px;color:var(--t2);border:1px solid var(--bd);border-radius:10px;padding:2px 8px}
+.ff-dash{display:grid;grid-template-columns:repeat(auto-fill,minmax(420px,1fr));gap:12px}
+.ff-col-card{background:var(--bg2);border:1px solid var(--bd);border-radius:8px;padding:12px}
+.ff-col-card.ff-disabled{opacity:.5}
+.ff-col-head{display:flex;justify-content:space-between;align-items:center;margin-bottom:6px}
+.ff-transient{background:#3a2e00;color:#ffd24d;padding:4px 8px;border-radius:4px;font-size:13px;margin:4px 0}
+.ff-tbl{width:100%;border-collapse:collapse;font-size:13px}
+.ff-tbl th,.ff-tbl td{padding:3px 6px;border-bottom:1px solid var(--bd);text-align:left}
+.ff-num{text-align:right;font-variant-numeric:tabular-nums}
+.ff-rec{font-weight:600;color:#7fd1ff}
+.ff-stale{opacity:.45}
+.ff-role-LevelDriven{color:#9aa}.ff-role-Monitor{color:#777}.ff-role-Commanded{color:#7fd1ff}
+.ff-grade-A{color:#4caf50}.ff-grade-B{color:#ffb300}.ff-grade-C{color:#ff5252}
+.ff-mb,.ff-note{font-size:12px;color:var(--t2);margin-top:6px}
+.ff-msg.err{color:#ff5252}
+```
+
+---
+
+## 4. 검증 절차 (diagnosis-checklist.md 8단계)
+
+### STEP 1~2 맥락·구조
+- 레이어: Web 컨트롤러(읽기 공개 + 설정 admin), Infra 스토어(파라미터화 CRUD), 프론트 탭.
+- 변경 파일 4 / 신규 3. 제어 레지스터 무관.
+
+### STEP 3 코드 읽기
+순서: IFeedforwardStores(인터페이스) → ConfigStore(Save/Delete) → Controller → ff.js → ff.html/css.
+
+### STEP 4 호출계층 지도
+```
+[대시보드] 브라우저 setInterval(3s) → GET /api/ff/advisory (공개) → AdvisoryStore (read)
+[설정]     ff.js (X-Kb-Token) → GET/POST/DELETE /api/ff/config → IsAdminAsync 게이트
+              → ConfigStore.Save/Delete (트랜잭션·파라미터화) → ff_* 테이블
+─ 제어 SP/OP 쓰기 경로 없음 (WriteTagAsync/SetModeAsync 미참조) ─
+```
+
+### STEP 5 패턴 매칭 (자가 사전점검)
+| 체크 | 상태 |
+|:-----|:-----|
+| **SQL 인젝션** | CRUD 전 컬럼 **파라미터 바인딩**(`P()` 헬퍼) — f-string/concat 없음 ✅ |
+| **인증** | 모든 변경/설정조회 엔드포인트 `IsAdminAsync` 선검사, 401 반환 ✅ |
+| **XSS** | 렌더는 `esc()` 경유, 숫자는 `fmtVal` ✅ |
+| **폴링 누수** | `ffInit` 재진입 시 `clearInterval` 선행, host 없으면(탭 이탈) 타이머 정지 ✅ |
+| **camelCase 응답** | `MapConfig`/`MapColumn` 명시 익명객체 ✅ |
+| **제어 쓰기 0건** | Control/Controllers grep `WriteTagAsync|SetModeAsync` = 0 (불변식 유지) ★ |
+| 트랜잭션 | Save는 컬럼+스트림 원자적(`BeginTransactionAsync`/`Commit`) ✅ |
+| 커넥션 | EF 소유 — 열기만 보장, 닫지 않음(스코프 종료 시 정리) |
+
+### STEP 6 교차검증 (Q1~Q4)
+- 설정 조회를 admin으로? Q3: 엔지니어링 값이라 의도. (대시보드 읽기는 공개)
+- JSON prompt 에디터: Q4 장애? 잘못된 JSON은 파싱 catch로 무해. 운영 편의는 Phase II-b 폼으로.
+- 토큰 미검증 unlock: 토큰을 sessionStorage에 넣고 **첫 admin 호출에서 검증**(401 시 제거) — docs.js와 동일.
+
+### STEP 7 심각도 가이드
+- HIGH: 인젝션/인증우회/빌드실패(없어야 함).
+- MED: 트랜잭션 누락(부분 저장), 폴링 중복.
+- LOW: 에디터 UX, 미사용 CSS.
+
+### STEP 8 보고서 양식 — 감독자 채움(파일:줄 인용).
+
+---
+
+## 5. 빌드/런타임 검증 (감독자 승인 후)
+- `dotnet build src/Web/ExperionCrawler.csproj` 경고0/에러0.
+- **제어 쓰기 불변식**: `grep -rn "WriteTagAsync\|SetModeAsync" src/Infrastructure/Control src/Web/Controllers/FeedforwardController.cs` → 0건.
+- admin 미인증 `POST /api/ff/config` → 401, 인증 후 저장→`GET /api/ff/config` 반영.
+- 인젝션: `name`에 `'); DROP TABLE ff_stream_config;--` 넣어도 **리터럴 저장**(파라미터화) 확인.
+- 브라우저: Tab 18 진입 → 대시보드 3초 폴링, 과도 배너/신뢰등급 색/레벨주석 표시, 다른 탭 이동 시 폴링 정지(타이머 누수 없음).
+- camelCase: 응답 필드가 `recommendedSp`·`massBalanceState` 등으로 옴(undefined 없음).
+
+---
+
+## 6. Phase II-분석 훅 (별도 진행 — 본 UI 문서 범위 밖)
+
+PhaseI §6 P-1~P-5(θ 자동튜닝·PCT/차온·front-position·confidence 자동강등·느린 바이어스)는
+**분석 엔진 확장**이라 UI와 분리. 본 UI는 그 산출을 표시할 **자리만** 둔다:
+- `StreamAdvisory.Grade`(이미 표시) ← confidence 자동강등(P-5) 연결점.
+- 컬럼 카드 `ff-note`/배너 ← sweet-spot 드리프트 경고(P-3) 표시 위치.
+- 설정에 `tempTags`·`analyzerTag`·`dTdP`·`pRef` 필드 추가 시 ColumnConfig 확장(P-2) — DDL ALTER + 로더/CRUD 컬럼 추가로 후속.
+
+---
+
+## 7. 턴키 상태 & 잔여
+**턴키**: 백엔드 CRUD(파라미터화)·컨트롤러·프론트(대시보드 완성, 에디터 최소형)·index 와이어링·검증절차 모두 포함.
+**구현 순서**: ① 인터페이스+ConfigStore CRUD → ② 컨트롤러(IKbAuthService 주입) → ③ index.html 3줄 + ff.html/ff.js/ff.css → ④ build → ⑤ admin 토큰으로 CRUD·인젝션·폴링 검증.
+**잔여(판단/후속)**: 에디터 폼 위젯화(II-b), `AdvisoryStore.Remove`로 삭제 컬럼 정리, 분석 훅 P-1~P-5.
+
+---
+
+## 8. Phase I 회고 — 인증 제거 (2026-05-31 적용)
+
+### 배경
+Phase I 엔진은 **어디에도 Experion SP/OP 쓰기 코드가 없다**(`WriteTagAsync`/`SetModeAsync` 0건).
+그런데 FF 설정 CRUD API에 `IKbAuthService`(KB admin 토큰) 인증이 붙어 있어,
+운전원이 대시보드를 보기 위해 RAG 관리 탭 로그인이 필요하거나 별도 토큰을 입력해야 했다.
+
+advisory(보조지표)는 늘상 운전원이 봐야 하는 페이지인데, 보지 못하게 막는 진입장벽이 불합리했다.
+
+### 적용 변경
+
+| 레이어 | 변경 내용 |
+|:-------|:----------|
+| `FeedforwardController.cs` | `IKbAuthService` 의존성 및 `IsAdminAsync()` 가드 제거. config CRUD 엔드포인트 인증 없이 동작 |
+| `ff.js` | `ffApiAdmin`(토큰 헤더) → `ffApi`(인증 없음). `ffUnlock`/`ffEnableAdmin` 제거. `ffInit`에서 바로 설정 로드 |
+| `ff.html` | `#ff-token` input + `#ff-unlock` 버튼 제거. `#ff-new` disabled 해제 |
+
+### 향후 재도입 시점 (Phase III)
+RSP 쓰기(Experion SP/OP write)가 실제로 구현되는 **Phase III**에서 `IKbAuthService`를 다시 주입하고
+프론트에 토큰 입력 UI를 복원한다. 그때는 쓰기 동작이 있으므로 인증이 정당화된다.
diff --git a/docs/측류추출식-통합유량설정공식-구현코딩-PhaseIII.md b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseIII.md
new file mode 100644
index 0000000..2f4016d
--- /dev/null
+++ b/docs/측류추출식-통합유량설정공식-구현코딩-PhaseIII.md
@@ -0,0 +1,337 @@
+# 측류추출 통합유량 — Phase III Auto-Write 구현 코딩 (RSP → DCS SP 쓰기)
+
+> **성격**: Phase I(advisory engine) + Phase II(UI 대시보드)에서 계산한 권장 SP(RSP)를 **DCS Setpoint에 직접 쓰는(auto-write) 기능**.
+> Phase I 불변식("제어 레지스터 쓰기 0건")을 해제 — **단, 안전장치(WriteGuard)를 동반**.
+
+---
+
+## 0. Phase 분할 현황
+
+| 범위 | Phase I (완료) | Phase II (완료) | Phase III (본 문서) |
+|:-----|:----|:----|:----|
+| 엔진 | FeedforwardEngine.Tick | θ 자동튜닝·바이어스 적응 (분석) | — |
+| 출력 | 권장 SP 저장 + 읽기 API | 대시보드 시각화 (흐림/선명) | **DCS SP 쓰기** |
+| 제어 | Advisory(쓰기 0건) | Advisory(쓰기 0건) | Auto-write (조건부 쓰기) |
+| 설정 | DB 테이블 + 로더 | Web UI 설정 에디터 | Auto-write On/Off 스위치 |
+| 안전 | — | — | **WriteGuard + 워치독** |
+
+---
+
+## 1. 핵심 설계 원칙
+
+### 1.1 Auto-write 조건
+
+**RSP를 DCS SP에 쓸 수 있는 조건은 다음 두 가지를 모두 만족해야 함:**
+
+```
+WriteCondition = (Grade == A) AND (!Transient)
+```
+
+| 조건 | 의미 | 위반 시 조치 |
+|:-----|:-----|:------------|
+| **Grade == A** | 모델 파라미터(K, θ, τ)가 잘 튜닝됨 | Grade B/C면 쓰지 않음 |
+| **!Transient** | Feed/압력 안정 + 정착 대기 완료 | Transient 중이면 이전 SP 홀드 |
+
+### 1.2 Grade별 Auto-write 정책
+
+| Grade | Auto-write 허용 | 근거 |
+|:------|:---------------|:------|
+| **A** | ✅ 허용 | K/θ/τ 튜닝 양호, 권장값 신뢰 가능 |
+| **B** | ❌ 금지 | 튜닝 불확실성 존재, 운전원 수동 인가 필요 |
+| **C** | ❌ 금지 | 모델 자체를 신뢰할 수 없음, 진단 우선 |
+
+### 1.3 Transient 상태별 Auto-write 정책
+
+| 상태 | Auto-write | RSP 처리 | DCS SP 처리 |
+|:-----|:----------|:---------|:------------|
+| 정상(안정) | ✅ 허용 | 최신 RSP로 갱신 | RSP = DCS SP |
+| FEED 이동 중 | ❌ 홀드 | RSP는 계산 계속 (변함) | **이전 SP 유지** |
+| 압력 불안정 | ❌ 홀드 | RSP는 계산 계속 (변함) | **이전 SP 유지** |
+| 정착 대기 중 | ❌ 홀드 | RSP는 정상 계산 | **이전 SP 유지** |
+| FEAD BAD (Hold) | ❌ 홀드 | RSP = 이전 LastRec | **이전 SP 유지** |
+
+### 1.4 홀드 동작 상세
+
+Transient 진입 시:
+
+```
+1. Transient 발생 (moving / pUnstable)
+2. 현재 DCS SP 값을 snapshot으로 저장 (LastWrittenSP)
+3. Transient가 지속되는 동안 DCS SP = LastWrittenSP 유지
+4. Transient 해제 후:
+   a. Grade == A → RSP로 즉시 갱신 (RSP는 transient 중에도 계속 계산됨)
+   b. Grade != A → 쓰지 않음, 운전원 수동 인가 대기
+```
+
+**RSP는 transient 중에도 매 틱 갱신되므로**, transient 해제 시점에는 이미 최신 Feed를 반영한 값으로 부드럽게 전환됨 — ramp-up이 필요 없음.
+
+---
+
+## 2. WriteGuard 아키텍처
+
+### 2.1 이중 조건 검증
+
+```
+[FF Engine] → RSP
+                 │
+                 ▼
+         [WriteGuard]
+           ├─ Grade == A ?
+           ├─ !Transient ?
+           └─ SP 변동폭 < SafetyLimit ?
+                 │
+          통과 ?──┤
+                 │
+              YES  NO
+               │    │
+           [Write]  [Hold]
+```
+
+### 2.2 SP 변동폭 제한 (SafetyLimit)
+
+추가 안전장치로, 한 번에 변경 가능한 SP 폭에 상한을 둠:
+
+```
+|RSP - CurrentDCS_SP| > SafetyMaxDelta
+→ 쓰지 않고 경고 로그, 운전원 확인 대기
+```
+
+제안값: `SafetyMaxDelta = RateUpPerMin × 5min` (5분 분량의 최대 변화율)
+
+### 2.3 워치독 (Watchdog Timer)
+
+```
+- Auto-write 활성화 후 일정 시간(예: 30분) 동안
+  Feed/압력 변화가 1회도 없으면 → 워치독 알람
+- 의미: "RSP가 너무 오래 같음 — DCS가 FF를 추종 중인지 확인"
+```
+
+---
+
+## 3. DCS 쓰기 인터페이스
+
+### 3.1 쓰기 방식
+
+DCS SP 쓰기는 OPC UA **Write 서비스를 통해** 수행:
+
+```
+OPC UA NodeId:     ns=3;s="{tag_name}.sp"  (예: "ficq-6118.sp")
+데이터 타입:        Double
+쓰기 권한:          WriteGuard 통과 시에만 호출
+```
+
+### 3.2 쓰기 주기
+
+```
+정상 상태:  매 Scan(2초)마다 RSP를 쓰지 않음
+           → RSP 변화 감지 시에만 Write 호출
+           → 변화 없으면 Skip (OPC UA 부하 감소)
+
+Transient: 쓰지 않음 (Hold)
+최초 쓰기: Auto-write On → 즉시 1회 Write
+```
+
+### 3.3 쓰기 실패 처리
+
+```
+- OPC UA Write 실패 → 3회 재시도 (1초 간격)
+- 3회 실패 → Auto-write 자중단, 경고 로그
+- 운전원 UI에 "DCS 쓰기 실패" 표시
+```
+
+---
+
+## 4. UI: Auto-write On/Off 제어
+
+### 4.1 설정 에디터 추가 항목 (Phase II ff.js 확장)
+
+```
+컬럼 편집 모달:
+
+  [일반 설정]         [Auto-write 설정]
+  컬럼명: C-6111      ☐ Auto-write 활성화
+  Feed: ficq-6101     SafetyMaxDelta: ____
+  ...                 워치독(분): ____
+
+  [스트림]
+  Key │ Flow 태그 │ 역할 │ 레벨태그 │ K │ θ_up │ ...
+  P   │ ficq-6118 │ Commanded │    │ 0.95 │ 60 │ ...
+  R   │ ficq-6113 │ Commanded │    │ 0.80 │  0 │ ...
+  D   │ ficq-6114 │ LevelDriven │ lica-6113 │ 0.02 │ ...
+  B   │ ficq-6116 │ LevelDriven │ li-6111   │ 0.03 │ ...
+```
+
+### 4.2 대시보드 표시
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  C-6111                          FEED 1000  12:34:56    │
+│  [Auto-Write ● 활성]                                    │
+│                                                         │
+│  스트림 │ PV    │ 권장 SP │ DCS SP │ Δ    │ 신뢰 │
+│  P      │ 780.2 │ 950.0   │ 950.0  │ —    │ A    │ ← auto-written
+│  R      │ 623.0 │ 760.0   │ 623.0  │ -137 │ A    │ ← 수동 (환류)
+│  D      │ 20.0  │ 20.0    │ 20.0   │ —    │ B    │ ← auto-written
+│  B      │ 30.0  │ 30.0    │ 30.0   │ —    │ B    │ ← auto-written
+│                                                         │
+│  물질수지: 정상  V_loss: +0.5  수율: 95.0%              │
+└─────────────────────────────────────────────────────────┘
+```
+
+- DCS SP 열 추가 (현재 DCS에 쓰여진 SP 값)
+- Δ는 권장 SP - DCS SP (auto-write 중엔 보통 0)
+- Auto-write 활성 상태를 헤더에 뱃지 표시
+
+### 4.3 Auto-write 활성화 조건
+
+```
+※ 전체 Column 단위 On/Off (스트림 개별 아님)
+
+On 전환 조건:
+  - 해당 Column의 모든 스트림이 Grade A는 아니어도 됨
+  - 단, Grade A인 스트림만 Auto-write 대상
+  - Grade B/C 스트림은 운전원 수동 유지
+
+Off 조건:
+  - 운전원 수동 Off
+  - WriteGuard 연속 실패 (3회)
+  - 워치독 타임아웃
+```
+
+---
+
+## 5. DB 변경
+
+### 5.1 ff_column_config (ALTER TABLE)
+
+```sql
+ALTER TABLE ff_column_config ADD COLUMN IF NOT EXISTS auto_write_enabled BOOLEAN NOT NULL DEFAULT FALSE;
+ALTER TABLE ff_column_config ADD COLUMN IF NOT EXISTS safety_max_delta DOUBLE PRECISION;  -- NULL=무제한
+ALTER TABLE ff_column_config ADD COLUMN IF NOT EXISTS watchdog_min INTEGER NOT NULL DEFAULT 30;
+```
+
+### 5.2 신규 테이블: ff_write_log (감사 추적)
+
+```sql
+CREATE TABLE IF NOT EXISTS ff_write_log (
+    id          BIGSERIAL PRIMARY KEY,
+    column_id   INTEGER NOT NULL REFERENCES ff_column_config(id) ON DELETE CASCADE,
+    stream_key  TEXT NOT NULL,
+    sp_before   DOUBLE PRECISION,
+    sp_after    DOUBLE PRECISION,
+    grade       TEXT NOT NULL,
+    transient   BOOLEAN NOT NULL,
+    success     BOOLEAN NOT NULL,
+    error_msg   TEXT,
+    written_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+```
+
+---
+
+## 6. 구현 파일 배치
+
+```
+변경:
+  src/Core/Application/Feedforward/
+    FeedforwardModels.cs                      # ColumnConfig: AutoWriteEnabled, SafetyMaxDelta, WatchdogMin
+    IFeedforwardStores.cs                     # (변경 없음)
+  src/Infrastructure/Control/
+    FeedforwardEngine.cs                      # (변경 없음 — RSP 계산 로직은 그대로)
+    FeedforwardSupervisor.cs                  # Auto-write 로직 추가 (WriteGuard 호출)
+    FeedforwardConfigStore.cs                 # auto_write_enabled, safety_max_delta, watchdog_min 저장/로드
+  src/Infrastructure/OpcUa/
+    OpcUaClientService.cs                     # WriteNodeAsync(tag, value) — OPC UA Write 래퍼
+  src/Web/Controllers/
+    FeedforwardController.cs                  # GET/POST config에 auto-write 필드 추가
+  src/Web/wwwroot/js/ff.js                    # 설정 에디터 + 자동쓰기 On/Off + DCS SP 표시
+  src/Web/wwwroot/css/ff.css                  # DCS SP 열, auto-write 뱃지 스타일
+
+신규:
+  src/Infrastructure/Control/
+    WriteGuard.cs                             # 조건 검증 + SafetyLimit + 워치독
+    AutoWriter.cs                             # 조건 충족 시 OPC UA Write 호출
+  docs/측류추출식-통합유량설정공식-구현코딩-PhaseIII.md  # 본 문서
+```
+
+---
+
+## 7. 안전 시나리오
+
+### 7.1 정상 동작
+
+```
+1. 운전원이 FF 설정에서 "Auto-write 활성화" ON
+2. Feed/압력 안정, Grade A
+3. RSP가 DCS SP에 자동 반영 (Scan 주기로 변화 감지 시)
+4. 운전원은 모니터링만
+5. 비정상 상황 시 수동 OFF → 즉시 쓰기 중단
+```
+
+### 7.2 Transient 발생
+
+```
+1. Feed 급변 → moving = true
+2. WriteGuard가 transient 감지 → Write 차단
+3. DCS SP는 마지막 값 유지 (변경 안 됨)
+4. RSP는 내부적으로 계속 계산
+5. 30분 후 transient 해제
+6. WriteGuard 조건 재확인 → Grade A → 새 RSP Write
+7. DCS SP가 최신 RSP로 점프 (ramp 불필요 — RSP는 transient 중에도 계산됐으므로)
+```
+
+### 7.3 OPC UA 단절
+
+```
+1. OPC UA 서버와 연결 끊김
+2. Write 실패 → 3회 재시도 → 실패
+3. Auto-write 자동 중단
+4. 운전원 UI에 "DCS 쓰기 불가" 경고
+5. 연결 복구 시 자동 재개 (선택 사항 — 운전원 확인 후 재활성화)
+```
+
+### 7.4 운전원 수동 개입
+
+```
+Auto-write 활성화 상태에서 운전원이 DCS SP를 수동 변경:
+→ WriteGuard 감지 (DCS SP != LastWrittenSP)
+→ 자동 쓰기 일시 중단 (예: 60초)
+→ 60초 후 WriteGuard가 조건 재확인
+   → 조건 만족: RSP로 다시 쓰기 (운전원 변경 덮어씀)
+   → 조건 불만족: 중단 유지
+
+※ 운전원 변경을 존중하려면:
+   "수동 변경 감지 시 auto-write 영구 중단" 정책도 고려
+   → UI에 "운전원 수동 변경 감지 — Auto-write 중단됨" 표시
+```
+
+---
+
+## 8. Phase III 마일스톤
+
+| 단계 | 내용 | 비고 |
+|:-----|:-----|:------|
+| **M1** | WriteGuard 구현 (조건 검증 + SafetyLimit) | 단위테스트 |
+| **M2** | OPC UA Write 래퍼 (WriteNodeAsync) | 기존 OpcUaClientService 확장 |
+| **M3** | AutoWriter 구현 (Guard → Write) + ff_write_log | 통합테스트 |
+| **M4** | Supervisor에 Auto-wire 루프 통합 + Transient 홀드 | Supervisor 확장 |
+| **M5** | DB: 컬럼 추가 + Config Store 확장 | 마이그레이션 |
+| **M6** | UI: 설정 에디터(Auto-write On/Off, SafetyLimit) + DCS SP 열 | ff.js 확장 |
+| **M7** | UI: Auto-write 뱃지 + 쓰기 실패 표시 | 대시보드 확장 |
+| **M8** | 종합 테스트 (시나리오 7.1~7.4) | 감독자 진단 |
+
+---
+
+## 9. Phase I 불변식 해제 선언
+
+```
+Phase I 불변식: "제어 레지스터(SP/OP)에 쓰기 호출 0건"
+Phase III에서 해제. 단, 아래 조건을 모두 만족해야 함:
+
+✅ WriteGuard가 쓰기 허가를 내린 경우에만 Write
+✅ Grade A && !Transient
+✅ SafetyMaxDelta 초과 시 Write 금지
+✅ 쓰기 실패 3회 → 자동 중단
+✅ 운전원 수동 OFF 가능
+✅ 모든 쓰기 내역은 ff_write_log에 기록 (감사 추적)
+```
diff --git a/docs/측류추출식-통합유량설정공식.md b/docs/측류추출식-통합유량설정공식.md
new file mode 100644
index 0000000..147f165
--- /dev/null
+++ b/docs/측류추출식-통합유량설정공식.md
@@ -0,0 +1,1168 @@
+# 측류 추출식 C-6111 — 통합 유량 설정 공식
+
+## 1. 기본 물질수지
+
+```
+F = D + P + B + V_loss
+```
+
+| 기호 | 의미 | 단위 |
+|:----:|:----:|:----:|
+| **F** | 원료투입량 (Feed) | kg/hr |
+| **P** | 제품 추출량 (Product, side-draw) | kg/hr |
+| **D** | 경비물 제거량 (Overhead Distillate) | kg/hr |
+| **B** | 하부/중비물 제거량 (Bottom) | kg/hr |
+| **V_loss** | **기상 손실 (Vent / Vacuum pump → Scrubber)** | kg/hr |
+
+> 일반 증류탑은 `F = D + B`이나, 측류 추출식(side-draw column)은 **제품(P)** 이 중간에서 추출되므로 4항 물질수지가 성립한다.
+>
+> 진공 증류 컬럼에서는 **vacuum pump / ejector**가 비응축성 가스(non-condensable)와 함께 **PGMEA 기상 일부를 Scrubber(SC-6128)로 강제 배출**한다. 이 손실분을 무시하면 P 수율이 실제보다 과장된다.
+
+---
+
+## 2. 분할 비율 (설계 기준)
+
+| 항목 | 계수 | 비율 | 근거 |
+|:----:|:----:|:----:|:------|
+| P | k_P | **0.94** | 주 제품 fraction (PGMEA 99%+ 순도) |
+| D | k_D | **0.02** | 경비물 (light ends) |
+| B | k_B | **0.03** | 중비물 (heavy ends) |
+| V_loss | k_V | **~0.01** | Vent/Scrubber 기상 손실 (추정) |
+
+k_D + k_P + k_B + k_V = **1.00** (총합)
+
+> **k_V = ~0.01 (1%)** 은 진공 증류 컬럼의 일반적인 vent loss 추정치다.
+> PI-6111 = **~48.5 torr** 진공압에서 PGMEA의 부분압에 따라 실제 손실률은 0.5~2% 범위에서 달라질 수 있다.
+> Vent loss flow meter는 별도로 존재하지 않으므로, **정확한 k_V는 scrubber 배출가스 분석 or 물질수지 역산**으로 결정해야 한다.
+
+---
+
+## 3. P(제품 추출량) 기준 전 항목 환산식
+
+측류 추출식에서는 **제품 추출량(P)** 이 가장 직접적인 조작 변수이므로 P를 기준으로 모든 설정값을 산출한다.
+
+### 3.1 원료투입량 (F)
+
+```
+F = P ÷ k_P
+```
+
+| P (제품 추출량) | F (원료투입량) |
+|:---------------:|:--------------:|
+| 777.2 | 777.2 ÷ 0.94 = **826.8** |
+
+### 3.2 경비물 제거량 (D)
+
+```
+D = (k_D / k_P) × P
+```
+
+| P | D |
+|:-:|:-:|
+| 777.2 | (0.02 / 0.94) × 777.2 = **16.54** |
+
+### 3.3 하부 제거량 (B)
+
+```
+B = (k_B / k_P) × P
+```
+
+| P | B |
+|:-:|:-:|
+| 777.2 | (0.03 / 0.94) × 777.2 = **24.81** |
+
+### 3.4 Vent 손실 (V_loss)
+
+```
+V_loss = (k_V / k_P) × P
+```
+
+| P | V_loss |
+|:-:|:------:|
+| 777.2 | (0.01 / 0.94) × 777.2 = **8.27** |
+
+> V_loss는 액체 상태로 계측되지 않으므로 **직접 계측 불가**. 위 값은 k_V=1%를 가정한 추정치다.
+> Scrubber(SC-6128) LI-6128 level이 0으로 계측되고 있어 scrubber 운전 상태 확인이 필요하다.
+
+### 3.5 검산
+
+```
+F = D + P + B + V_loss = 16.54 + 777.2 + 24.81 + 8.27 = 826.8 ✓
+k_D + k_P + k_B + k_V = 0.02 + 0.94 + 0.03 + 0.01 = 1.00 ✓
+```
+
+> V_loss를 포함하면 동일 P 대비 **필요 F가 818.1 → 826.8로 증가** (실제 수율은 94%, 계측기준 95%).
+
+---
+
+## 4. 환류량 (온도보정 포함)
+
+### 4.1 일반 증류탑과의 차이
+
+| 컬럼 타입 | 일반 증류탑 | 측류 추출식 (C-6111) |
+|:---------:|:----------:|:-------------------:|
+| 주 제품 | D (정상품) | **P (측류)** |
+| 환류 기준 | D | **P** |
+| 환류 공식 | R = r × D | **R = R_f × P** |
+| D의 성격 | 주 제품 (100%) | 소량 경비물 (2%) |
+
+> D가 2%에 불과하므로 `R = r × D`를 적용하면 r = 350/16.36 = **21.4**라는 비현실적 환류비가 나온다. 측류 추출식은 **반드시 P 기준**으로 계산해야 한다.
+
+### 4.2 외부 환류 (FICQ 계측값)
+
+```
+R_ext = R_f × P
+```
+
+| 변수 | 의미 | 일반 범위 |
+|:----:|:----:|:---------:|
+| R_ext | 외부 환류량 (질량유량계, FICQ-6113) | kg/hr |
+| R_f | 제품기준 환류비 (Reflux-to-Product ratio) | **0.5 ~ 1.2** |
+| P | 제품 추출량 | kg/hr |
+
+**R_f 기준값:**
+
+| R_f | 의미 | 적용 |
+|:---:|:----|:----:|
+| < 0.5 | 저환류 — 에너지 절감 우선 | 순도 타협 가능할 때 |
+| **0.5 ~ 1.2** | **설계 권장 범위** | **정상 운전** |
+| > 1.2 | 고환류 — 순도 극대화 | 에너지 비용 증가 감수 |
+
+### 4.3 온도보정 (과냉각 Subcooling)
+
+응축기에서 액화된 환류액은 보통 포화온도 이하로 과냉각되어 컬럼으로 돌아온다. 이 과냉각된 액체는 컬럼 내부에서 일부 증기를 응축시키므로 **내부 환류량이 외부 계측치보다 증가**한다.
+
+```
+R_int = R_ext × (1 + c_p × ΔT / λ)
+```
+
+| 변수 | 의미 | 단위 |
+|:----:|:----|:----:|
+| R_int | 내부 환류량 (실제 트레이 단 L/V에 기여) | kg/hr |
+| R_ext | 외부 환류량 (FICQ 계측값) | kg/hr |
+| c_p | PGMEA 비열 (액체) | kJ/kg·K |
+| λ | PGMEA 증발잠열 | kJ/kg |
+| ΔT | T_top − T_reflux_drum (과냉각도) | °C |
+
+**온도보정계수 (TCF):**
+
+```
+TCF = 1 + c_p × ΔT / λ
+```
+
+**PGMEA 물성치 (일반값, 실제 조성/압력에 따라 조정 필요):**
+
+| 물성 | 기호 | 일반값 | 단위 |
+|:----:|:----:|:-----:|:----:|
+| 비열 (액체) | c_p | **2.0** | kJ/kg·K |
+| 증발잠열 | λ | **330** | kJ/kg |
+| c_p / λ | | **0.00606** | K⁻¹ |
+
+**ΔT별 TCF:**
+
+| ΔT (°C) | TCF | 설명 |
+|:-------:|:---:|:------|
+| 0 | 1.000 | 포화액 환류 (과냉각 없음) |
+| 5 | 1.030 | 일반 수냉 응축기 |
+| 10 | 1.061 | 과냉각 충분한 경우 |
+| 15 | 1.091 | 냉동 응축기 수준 |
+| 20 | 1.121 | 과냉각 큰 경우 |
+
+### 4.4 컬럼 내부 실제 L/V 비
+
+컬럼 내부의 실제 기액비는 분리 효율의 핵심 지표다.
+
+```
+L/V = R_int / (R_int + P)
+```
+
+| R_f | R_int (ΔT=5°C) | L/V |
+|:---:|:--------------:|:---:|
+| 0.45 (현재) | 350 × 1.030 = **361** | 361/(361+777.2) = **0.317** |
+| 0.8 | 622 × 1.030 = **641** | 641/(641+777.2) = **0.452** |
+| 1.0 | 777 × 1.030 = **800** | 800/(800+777.2) = **0.507** |
+| 1.2 | 933 × 1.030 = **961** | 961/(961+777.2) = **0.553** |
+
+---
+
+## 5. 진공 Vent 손실 (V_loss) 상세
+
+### 5.1 손실 발생 경로
+
+```
+컬럼 상부 증기 (~78°C, ~48.5 torr)
+  │
+  ├─→ 응축기 → Reflux Drum → R (액체 환류)
+  │                        → D (액체 경비물)
+  │
+  └─→ Vacuum Pump / Ejector → 비응축 가스 + PGMEA vapor
+                              → SC-6128 Scrubber (수세)
+                              → V_loss (scrubber 배출 or 회수)
+```
+
+### 5.2 현재 계측 현황
+
+| 태그 | PV | 상태 |
+|:----:|:---:|:----:|
+| PI-6111 | **48.5 torr** | 컬럼 진공압 (정상 계측) |
+| LI-6128 | **0** | Scrubber SC-6128 level (계측 불가 또는 미사용) |
+| (vent flow) | **없음** | 별도 유량계 없음 |
+
+> **직접 계측이 불가능하므로 V_loss는 추정에 의존해야 한다.**
+
+### 5.3 V_loss 추정 방법
+
+**방법 A — 물질수지 역산 (권장):**
+```
+V_loss = F - (D + P + B)
+```
+F, D, P, B가 모두 신뢰할 수 있는 유량계일 때 계산 가능. 현재 검산 결과 F=820, D+P+B=817.44 → V_loss ≈ **2.6 kg/hr (0.32%)**. 단, 이 차이는 계측 오차 범위 내이므로 신뢰도가 낮다.
+
+**방법 B — 설계/경험치 적용:**
+진공 증류 컬럼(48.5 torr, PGMEA)의 일반적인 vent 손실률:
+
+| 응축기 효율 | 예상 k_V | 비고 |
+|:----------:|:--------:|:------|
+| 우수 (과냉각 10°C+, 충분한 면적) | ~0.005 (0.5%) | 고효율 응축기 |
+| **보통** (일반 수냉) | **~0.01 (1%)** | **C-6111 기본 가정** |
+| 저효율 (냉각수 온도 높음) | ~0.02 (2%) | 여름철 냉각탑 부하 증가 시 |
+
+**방법 C — vent gas 분석:**
+scrubber 전단에 sampling port가 있다면 GC 분석 or 휴대용 VOC meter로 PGMEA 농도 측정 → 유량 추정.
+
+### 5.4 V_loss가 물질수지에 미치는 영향
+
+| 항목 | V_loss 미포함 (k_P=0.95) | V_loss 포함 (k_P=0.94, k_V=0.01) |
+|:----:|:-----------------------:|:--------------------------------:|
+| 필요 F (P=777.2 기준) | 818.1 | **826.8** (+1.1%) |
+| D | 16.36 | 16.54 |
+| B | 24.54 | 24.81 |
+| V_loss | — | **8.27** |
+| 실제 P 수율 | 95.0% (과대) | **94.0%** (현실) |
+| L/V 계산 영향 | 무시 가능 (액상만 영향) | **무시 가능** (액상 유량에 V_loss 비중↓) |
+
+> V_loss는 주로 **F/D/B 보정**에 영향을 주고, **환류량(R) 계산에는 직접 영향이 없다** (V_loss는 액상 환류 loop 밖에서 일어나는 손실이므로).
+
+### 5.5 일반적인 증류 플랜트 설계 Loss 기준
+
+#### Loss 항목별 설계값
+
+| Loss 항목 | 일반 설계값 | C-6111 적용 가능성 |
+|:----------|:----------:|:------------------:|
+| **Vent loss** (진공펌프 → scrubber) | **0.5 ~ 2%** | 응축기 효율, 진공도에 따라 |
+| - 응축기 효율 좋음 (과냉각 10°C+) | 0.3~0.5% | 가능 |
+| - **보통** (일반 수냉, 40°C CW) | **0.5~1.0%** | **C-6111 현재 가정 (k_V=1%)** |
+| - 응축기 효율 낮음 (CW 온도 ↑) | 1.0~2.0% | 하절기 |
+| **Mechanical loss** (pump seal, flange, valve) | 0.1~0.3% | 무시 가능 |
+| **Drain/Flushing loss** (라인 드레인, 샘플링) | 0.1~0.2% | 무시 가능 |
+| **Storage/Transfer loss** (탱크 breathing, 증발) | 0.1~0.5% | 탱크존 별도 |
+| **Batch transition loss** (grade change) | 0.5~2.0% | C-6111 연속식 → 해당 없음 |
+| **분석/품질 margin** | 0.3~0.5% | off-spec 재처리 고려 |
+
+#### 플랜트 유형별 총 설계 loss
+
+| 플랜트 유형 | 총 설계 loss | k_V (vent only) |
+|:-----------|:----------:|:--------------:|
+| 대기압 증류 (단순) | 0.5~1% | 0% (vent minimal) |
+| **진공 증류 (고순도, PGMEA급)** | **1~3%** | **0.5~1.5%** |
+| 고진공 증류 (<10 torr, 열민감) | 2~5% | 1~3% |
+| 회분식 증류 (batch) | 3~8% | 포함 |
+
+#### 설계 예시 (PGMEA 진공 증류 기준)
+
+```
+Feed            100.0  (100%)  ← 설계 기준 (FICQ-6101)
+  ├─ Product     94.0  (94.0%) ← 제품 수율 (k_P)
+  ├─ Distillate   2.0  (2.0%)  ← 경비물 (k_D)
+  ├─ Bottom       3.0  (3.0%)  ← 중비물 (k_B)
+  └─ Vent loss    1.0  (1.0%)  ← 설계 loss (k_V)
+Total out:      100.0  (100%)
+```
+
+> C-6111에 k_V=1.0%는 **일반적인 진공 증류 설계 범위 내**에 있다. 장기 물질수지 추세로 보정하면 0.5~0.8%로 더 낮출 여지도 있다.
+
+### 6.1 현재 컬럼 온도 Profile
+
+| 태그 | 위치 | PV (°C) | SP (°C) | OP (%) |
+|:----:|:----:|:-------:|:-------:|:------:|
+| TICA-6111A | 최하부 (Reboiler) | 79.6 | 81.5 | 25.1 |
+| TI-6111B | 원료투입구 위 중부 | 79.1 | — | — |
+| TI-6111C | 제품추출 노즐 근처 중상부 | 78.8 | — | — |
+| TI-6111D | 상부 제품추출 노즐 근처 | **77.8** | — | — |
+
+컬럼 상부 온도 (T_top) = TI-6111D PV = **77.8°C**
+
+### 6.2 현재 유량 현황
+
+| 태그 | 역할 | PV (kg/hr) | SP (kg/hr) |
+|:----:|:----:|:----------:|:----------:|
+| FICQ-6101 | **F** (원료) | 820.7 | **820** |
+| FICQ-6114 | **D** (경비물) | 17.4 | **16.7** |
+| FICQ-6118 | **P** (제품) | 784.0 | **777.2** |
+| FICQ-6116 | **B** (하부) | 25.2 | **24.54** |
+| FICQ-6113 | **R_ext** (환류) | 350.7 | **350** |
+
+### 6.3 검증: 현재 분할비
+
+| 검증항목 | 계산 | 결과 | 설계 |
+|:--------:|:----:|:----:|:----:|
+| P/F | 784.0 / 820.7 | **0.955** | 0.95 ✓ |
+| D/F | 17.4 / 820.7 | **0.021** | 0.02 ✓ |
+| B/F | 25.2 / 820.7 | **0.031** | 0.03 ✓ |
+| R_f | 350 / 777.2 | **0.450** | 0.5~1.2 ✗ |
+
+> P/D/B의 분할비는 설계와 일치하나, **환류비(R_f)만 0.45로 설계 범위(0.5~1.2)를 하회**한다.
+
+### 6.4 권장 설정값 (R_f = 0.8, ΔT = 5°C 가정)
+
+| 설정값 | 태그 | **공식** | **계산값** | 현재 SP | 조정 |
+|:-----:|:----:|:--------:|:---------:|:-------:|:----:|
+| **F** | FICQ-6101 | P ÷ 0.95 | **818.1** | 820 | → 유지 |
+| **D** | FICQ-6114 | 0.02/0.95 × P | **16.4** | 16.7 | → 미세조정 |
+| **P** | FICQ-6118 | (기준) | **777.2** | 777.2 | → 유지 |
+| **B** | FICQ-6116 | 0.03/0.95 × P | **24.5** | 24.54 | → 유지 |
+| **R_ext** | FICQ-6113 | R_f × P | **622** | 350 | → **상향** |
+| R_int | (내부) | R_ext × TCF | **641** | — | — |
+| L/V | (내부) | R_int/(R_int+P) | **0.452** | 0.317 | → 상향 |
+
+### 6.5 R_f 시나리오별 비교
+
+| R_f | R_ext | R_int (ΔT=5°C) | L/V | R/F | 에너지 |
+|:---:|:-----:|:--------------:|:---:|:---:|:------:|
+| **0.45 (현재)** | **350** | **361** | 0.317 | 0.43 | ↓ 낮음 |
+| **0.8** | **622** | **641** | 0.452 | 0.76 | 중간 |
+| 1.0 | 777 | 800 | 0.507 | 0.95 | ↑ 높음 |
+| 1.2 | 933 | 961 | 0.553 | 1.14 | ↑↑ 높음 |
+
+---
+
+## 7. 운전 가이드라인
+
+### 7.1 설정 순서
+
+1. **P (FICQ-6118)** — 제품 추출량을 목표 생산량에 맞춰 설정
+2. **F (FICQ-6101)** — F = P / 0.95로 원료량 설정
+3. **D (FICQ-6114)** — D = 0.02/0.95 × P로 경비물 설정
+4. **B (FICQ-6116)** — B = 0.03/0.95 × P로 하부 설정
+5. **R (FICQ-6113)** — R = R_f × P (R_f = 0.5~1.2 범위)로 환류 설정
+6. **TICA-6111A** (Reboiler) — R 증가 시 재비기 부하 증가 → 온도 유지 확인
+
+### 7.2 환류비 결정 트레이드오프
+
+| R_f 증가 시 | 영향 |
+|:-----------|:-----|
+| 분리 효율 | ↑ (순도 증가) |
+| 재비기 증기 소비 | ↑ (에너지 비용 증가) |
+| 응축기 부하 | ↑ (냉각수 비용 증가) |
+| 컬럼 내부 flooding 위험 | ↑ (범위 내에서만) |
+
+### 7.3 주의사항
+
+- **환류 drum 온도 센서**가 확인되지 않음 — ΔT 확인 후 TCF 재계산 필요
+- **PGMEA 물성치(c_p, λ)** 는 일반값 — 실제 분석 데이터로 대체 권장
+- **R_f = 0.8**을 첫 권장값으로 제시 — 순도 분석 결과 보며 증감
+- R을 급격히 변경하지 말고 **단계적(step-wise) 조정** 후 정상상태 도달 확인
+- **V_loss (진공 vent 손실)는 직접 계측 불가** — scrubber SC-6128(LI-6128) level 계측 이상으로 운전 상태 미확인. scrubber 정상 운영 여부 점검 필요
+- **k_V = 0.01 (1%)** 은 일반적인 진공 증류 추정치. 실제 vent gas 분석 또는 물질수지 장기 추세로 보정 권장
+
+---
+
+## 8. 참고: 온도 Profile 해석
+
+| 프로파일 형태 | 의미 |
+|:------------|:------|
+| 상부 >> 하부 (정상) | 양호한 분리 |
+| 전 구간 균일 (flat) | 분리 불량, flooding, 또는 내부 이상 |
+| 하부 > 상부 (정상 역전) | 정상 — reboiler에서 가열, top으로 갈수록 가벼운 성분 |
+
+현재 C-6111 (79.6 → 79.1 → 78.8 → **77.8°C**):
+
+- 하부 > 상부: **정상적인 하강 온도 profile** ✓ (가벼운 성분이 상부로 농축)
+- 차이가 작음: **비교적 순수한 단일 성분(PGMEA) 컬럼**이므로 온도 구배가 크지 않은 것이 정상
+
+---
+
+## 9. 수식 검증 결과 및 정정
+
+본 문서(§1~§8)의 수식을 검산한 결과와 정정 사항. **DCS 적용 시 §10을 기준으로 삼는다.**
+
+### 9.1 발견된 불일치·오류
+
+| # | 위치 | 문제 | 정정 |
+|:-:|:-----|:-----|:-----|
+| **V1** | §2 vs §6 | **k_P 이중 정의**: §2·§3·§5는 V_loss 포함 4항(`k_P=0.94`, `F=P÷0.94=826.8`), §6 설정표는 3항(`k_P=0.95`, `F=P÷0.95=818.1`). 동일 문서 내 충돌 | §10.2 — 측정가능 스트림만 비례계수로, V_loss는 잔차로 분리. 재정규화 불필요 |
+| **V2** | §4.4·§6.4 | **L/V 정의 비표준**: `L/V = R/(R+P)`. 측류 추출은 P가 측류로 빠지므로 이는 열역학적 기액비가 아님 | 정류부(측류 노즐 상단) 실제 기액비 = `R/(R+D)`. §10.5 참조. 기존 식은 "제품기준 트래픽 지표"로만 명명 |
+| **V3** | §5.3 방법A | **산술 오류**: "D+P+B=817.44" → 실제 16.36+777.2+24.54=**818.10** (SP 기준 818.44) | 잔차식 자체는 유효(§10.6). 표기값만 정정 |
+| **V4** | §3.4 | **V_loss를 환산 설정값(8.27)으로 산출** — 유량계 부재로 제어 불가 변수 | V_loss는 **설정값 아님**. 물질수지 closure 계산 태그로만 운용(§10.6) |
+
+### 9.2 정합성 확인된 부분 (그대로 사용 가능)
+
+| 항목 | 확인 |
+|:-----|:-----|
+| 과냉각 보정 `TCF = 1 + c_p·ΔT/λ` | ✓ `c_p/λ = 2.0/330 = 0.00606 K⁻¹`, ΔT 0/5/10/15/20 → TCF 1.000/1.030/1.061/1.091/1.121 전부 정확 |
+| 물질수지 검산 (§3.5) | ✓ `16.54+777.2+24.81+8.27 = 826.8`, 계수합 1.00 |
+| R_f 환산 (§4.4·§6.5) | ✓ 채택된 L/V 정의 범위 내에서 내부 정합 (단 V2 적용 시 L/V 수치는 재계산 필요) |
+| 온도 profile 해석 (§8) | ✓ 하강 profile 정상 판정 타당 |
+
+### 9.3 심화 진단 — 공정제어 구조 결함 (V1~V4보다 중대) ★
+
+산술·정의 오류(§9.1)보다 **제어 구조 차원의 결함**이 더 심각하다. 아래는 본문 §1~§11 및
+연계 문서(`측류추출-시간지연-적용방식.md`, `측류추출-관계식.md`) 공통 결함이다.
+
+| # | 결함 | 근거 / 위험 | 정정 방향 |
+|:-:|:-----|:-----------|:----------|
+| **D5** | **인벤토리(레벨) 폐루프 부재 · 자유도 과지정** [치명적] | F·D·P·B를 **모두 독립 유량 SP**로 명령. 그러나 컬럼 인벤토리는 **환류드럼·탑저 2개 홀드업**을 가지며 이 중 2개 유량은 **레벨 제어**가 잡아야 함. C-6111엔 실제로 **LICA-6113(드럼 레벨 제어기, SP/OP/PV 보유)** 존재 → D(또는 환류)를 개루프 비율로 동시에 명령하면 **레벨 루프와 충돌·표류** | 자유도 정리: **F(처리량)+P(측류제품)+R(환류)만 명령**, **D·B는 레벨 제어가 구동**. K_D·K_B는 **피드포워드 바이어스/기대값·모니터링**으로만 사용 |
+| **D6** | **전달지연 독립 적용 시 인벤토리 표류** [치명적, §11 직결] | 각 스트림을 서로 다른 τ로 독립 지연하면 과도 중 `D+P+B ≠ F`, 차이 `dM/dt`가 홀드업에 누적 → 드럼/탑저 레벨 스윙 → 알람/오버플로/dry-out | **명시적 deadtime/lag는 P(및 FF 환류) 경로에만**. **D·B 인벤토리 동특성은 레벨 제어기가 적분으로 자동 정합**(별도 deadtime 튜닝 불필요) |
+| **D7** | **P 지연 방향 비대칭 위험** [중요] | 시간지연 문서는 **피드 증가만** 가정. 피드 **감소** 시 P를 15~20분 느리게 지연하면 줄어든 피드 대비 **제품 과배출** → 중간단 인벤토리 하강·불순물 상승 → **순도 위반**(의도와 반대) | `θ_up/θ_dn`·`rate_up/rate_dn` 분리. 감소 시 P는 **더 빨리 추종**(과배출 방지) |
+| **D8** | **온도기반 Step Test 부적합 (이 컬럼 한정)** [중요] | 시간지연 문서 §3은 트레이 온도로 지연 측정. 그러나 §8대로 C-6111은 **준단일성분 PGMEA, 구배 ~2°C(79.6→77.8)** → 온도는 압력지배·약한 조성지표 | 지연 측정은 **측류 analyzer·레벨 응답·유량 응답** 기준. (엔진은 "응답 지표 신호"를 컬럼별 설정) |
+| **D9** | **관계식 문서 `R=R_f×D` 모순** [중요] | `측류추출-관계식.md` §2·§4가 환류 설정식을 `R=R_f×D`로 제시 → 본문 §4.1이 측류식엔 틀림(R_f=21.4)임을 이미 증명. 같은 문서 부록은 R을 P/F 기준으로 정정 → **자체 모순** | 환류는 **일관되게 `R=R_f×P`**(외부환류 기준, §10.4) |
+| **D10** | **이동평균 ≠ 1차지연 혼용** [경미] | 시간지연 문서 §2가 MA(FIR)와 FOPDT(IIR)를 호환처럼 기술. MA는 ~window/2 군지연 추가로 동작 다름 | 역할 분리: **노이즈 제거=MA/EMA(F 전단)**, **전달보상=명시적 deadtime 링버퍼+lag**(§12 엔진에서 분리 구현) |
+| **D11** | **진공 압력 안정 가정 미명시** [중요] | PICA-6111(진공) 변동 시 질량유량·split·vent loss·boilup 관계가 흔들림 | 비율식 유효 전제 = **압력 정상**. 압력 불안정도 **과도 게이트(§11.6)** 에 포함 |
+
+> **종합**: 본 문서 계열의 비율 피드포워드는 "모든 스트림을 개루프 유량으로 명령"하는 전제가 잘못이다.
+> **레벨 제어가 인벤토리를 닫고**, 피드포워드는 **F·P·R만** 좌표화하며 D·B엔 **바이어스/기대값**만 제공해야 안정하다.
+> §10~§11의 계산식은 이 전제(D·B는 레벨 구동) 위에서 적용한다. §12 엔진은 스트림별로
+> **"명령(commanded) / 레벨추종(level-driven) / 모니터"** 역할을 컬럼마다 설정하도록 설계한다.
+
+---
+
+## 10. DCS 실무 적용 계산식 (Implementable)
+
+> **설계 원칙**
+> 1. **측정 가능한 스트림(F·D·P·B·R_ext)만 비례제어 설정값으로 산출한다.**
+> 2. **V_loss·R_int·L/V는 계측·제어 대상이 아니다** → "계산 모니터링 태그"로만 표시(설정값 금지).
+> 3. 비례식은 **하한·상한 클램프**와 **rate limit**를 반드시 동반한다(공식만 적용 금지).
+> 4. 마스터 변수는 운전 모드로 선택: **원료 주도(Feed-led)** 또는 **제품 주도(Product-led)**.
+
+### 10.1 DCS I/O 점 (Point List)
+
+| 구분 | 태그 | 역할 | 비고 |
+|:----:|:----:|:----|:-----|
+| 입력 | FICQ-6101.PV | F 원료 (측정) | 마스터 후보 |
+| 입력 | FICQ-6118.PV | P 제품 측류 (측정) | 마스터 후보 |
+| 입력 | FICQ-6114.PV | D 경비물 (측정) | |
+| 입력 | FICQ-6116.PV | B 하부 (측정) | |
+| 입력 | FICQ-6113.PV | R_ext 외부환류 (측정) | DCS는 외부환류만 제어 |
+| 출력(SP) | FICQ-6114.SP, FICQ-6118.SP, FICQ-6116.SP, FICQ-6113.SP | 비례 설정값 | 클램프·rate limit 적용 |
+| 계산 태그 | V_loss_calc, Yield_calc, LV_top_calc, R_int_calc | 모니터링 전용 | **SP 아님** |
+
+### 10.2 비례 계수 — 목표(레시피) vs 관측 분리 ★
+
+> **치명적 주의**: 비례계수를 매 스캔 PV(`K = D/F`)로 계산해서 SP에 쓰면 `D_sp = (D/F)×F = D`,
+> 즉 **설정값이 현재 PV를 그대로 따라가는 무의미한 루프**가 된다. 반드시 아래처럼 분리한다.
+
+**(a) 목표 계수 `K_*_t` — 제어 설정식 입력 (엔지니어/운전원 설정 상수)**
+설계·랩 분석·시운전 캡처로 정한 고정 레시피 값. DCS에 **튜닝 파라미터**로 저장, 품질변경 시에만 수정.
+
+```
+K_D_t = 0.020       (경비물 목표 비율, D/F)
+K_P_t = 0.950       (제품 목표 수율,   P/F)
+K_B_t = 0.030       (하부 목표 비율,   B/F)
+R_f_t = 0.80        (제품기준 환류비,  R_ext/P)
+```
+
+**(b) 관측 계수 `K_*_obs` — 모니터링·트렌드 전용 (SP 인가 금지)**
+실제 분할이 목표에서 얼마나 벗어났는지 감시용. **3항을 1.00으로 강제 정규화하지 않는다.**
+
+```
+K_D_obs = D / F ; K_P_obs = P / F ; K_B_obs = B / F
+k_V_obs = 1 − (K_D_obs + K_P_obs + K_B_obs)     ← vent 손실률 추정 (관측)
+```
+
+> §2의 "k_P=0.94 vs 0.95" 혼란은 여기서 해소된다: 관측 D/P/B는 F의 약 99%만 차지하고,
+> **나머지 ≈1%가 V_loss**다. 목표 계수는 0.94로 줄이지 말고 0.95(=관측 수율)를 그대로 쓰되,
+> 부족분 `k_V_obs`를 손실로 **보고만** 한다. (시운전 시 `K_*_obs`를 정상상태에서 캡처해 `K_*_t` 초기값으로 사용)
+
+### 10.3 피드포워드 설정식 — 모드별
+
+> **§9.3(D5) 적용**: 아래 D_SP·B_SP는 **D·B가 commanded일 때**의 식. 레벨 폐루프가 있으면(C-6111의 LICA-6113)
+> **D·B는 level_driven**으로 두고 이 식은 **기대치/바이어스**로만 쓴다(개루프 명령 금지). commanded는 통상 **P·R**.
+
+**[모드 A] 원료 주도 (Feed-led, DCS 표준·권장)** — F를 운전원이 잡고 나머지가 추종. **목표 계수(`K_*_t`) 사용**
+
+```
+D_SP = K_D_t × F_PV
+P_SP = K_P_t × F_PV
+B_SP = K_B_t × F_PV
+R_SP = R_f_t × P_SP            (또는 R_f' × F_PV)
+```
+
+**[모드 B] 제품 주도 (Product-led)** — 목표 생산량 P_target을 잡고 F를 역산 (본문 §3·§7 방식)
+
+```
+F_SP = P_target / K_P_t
+D_SP = (K_D_t / K_P_t) × P_target
+B_SP = (K_B_t / K_P_t) × P_target
+R_SP = R_f_t × P_target
+```
+
+> 연속탑은 통상 **모드 A**가 안정적(피드 변동을 즉시 추종, 레벨 컨트롤러와 충돌 적음). 생산계획상 제품량이 고정이면 모드 B로 F_SP만 산출 후 다시 모드 A로 전환 운전.
+
+### 10.4 환류 설정식 (외부환류 기준)
+
+DCS/FICQ가 계측·제어하는 것은 **외부 환류(R_ext)뿐**이다. 따라서 설정식은 R_ext 기준으로만 작성한다.
+
+```
+R_SP = R_f × P_SP            R_f ∈ [0.5, 1.2]  (정상운전 권장)
+```
+
+`R_int`(내부 환류)와 `TCF`는 **분리효율 해석용 오프라인 계산**일 뿐, 계측 불가 → **설정값으로 쓰지 않는다.**
+
+### 10.5 모니터링 계산 태그 (제어 아님)
+
+```
+# 정류부(측류 노즐 상단) 실제 기액비 — 정정된 정의 (V2)
+LV_top_calc = R_ext / (R_ext + D)
+
+# 내부 환류 (해석용)
+R_int_calc  = R_ext × (1 + c_p × ΔT / λ)        c_p/λ = 0.00606 /K
+              ΔT = T_top − T_reflux_drum  (drum 온도계 미확보 시 표시 안 함)
+
+# 참고: 본문 §4.4의 제품기준 트래픽 지표 (열역학 L/V 아님, 별도 표기)
+LV_prod_index = R_int_calc / (R_int_calc + P)
+```
+
+### 10.6 물질수지 Closure / 수율 모니터 (V_loss는 여기서만)
+
+```
+V_loss_calc = F_PV − (D_PV + P_PV + B_PV)      # 잔차 = vent + 계측오차
+Yield_calc  = P_PV / F_PV × 100                # 실제 제품 수율 [%]
+
+# 건전성 게이트 (계측 오차대 고려)
+IF |V_loss_calc| > 0.03 × F_PV  → "물질수지 불일치" 경보 (계측기 점검)
+IF V_loss_calc < 0              → 음의 손실 = 계측기 드리프트/스팬 오류 의심
+```
+
+> V_loss는 **F·D·P·B가 모두 신선·정상일 때만** 의미. 하나라도 STALE/오류면 잔차 무효 처리(§realtime corroboration 게이트 연동).
+
+### 10.7 안전 클램프 · 변화율 제한 (필수)
+
+각 설정식 출력은 아래를 통과한 뒤에야 컨트롤러 SP로 인가한다.
+
+```
+SP_clamped = CLAMP(SP_raw, SP_min, SP_max)            # 계기 레인지·운전 한계
+SP_out     = RATE_LIMIT(SP_clamped, ΔSP_max_per_min)  # 급변 방지(스텝 운전)
+
+# 권장 한계 (예시 — 실제 계기 euhi/eulo 및 운전한계로 대체)
+R_SP   : Δ ≤ 5%/min,  하한 = 최소 wetting 환류 (트레이 dry-out 방지)
+F_SP   : Δ ≤ 3%/min
+D/B_SP : 음수 금지, 0 근접 시 최소 흐름 유지(라인 막힘 방지)
+```
+
+### 10.8 스팀(재비기) 연동 — 환류 비교식 문서 정합
+
+`knowledge/측류추출-관계식.md`의 스팀식과 정합:
+
+```
+S_SP = K_S × F_PV + f(ΔP) + Bias
+       K_S = α × K_D × (R_f + 1)         (이론 비례계수)
+       f(ΔP) : 탑 차압 오버라이드 (flooding 방지 감쇄)
+       Bias  : 열손실·외기·계측오차 운전원 트림
+```
+
+> 단, `R = R_f × D`(일반탑)와 본문 `R = R_f × P`(측류)는 **R_f 기준이 다르다**. 스팀식의 `K_S = α·K_D·(R_f+1)`는 환류를 D 기준으로 본 일반탑 유도식이므로, 측류 운전(R∝P)에서는 `S_SP = α × (R_ext + D)`의 **직접 증기부하식**을 쓰는 것이 안전하다(R·D 모두 측정값 사용).
+
+### 10.9 알고리즘 참조 (Structured Text 표기)
+
+> **주의(§12.0)**: 이 의사코드는 **알고리즘 정의**다. 가변길이 데드타임·진짜 이동평균·다컬럼·dM/dt
+> 과도게이트 등은 **DCS 펑션블록으로 다 못 구현** → 실제 연산은 **우리 프로젝트 코드(§12)** 가 수행하고
+> 결과를 **권장 SP(보조지표)** 로 제시한다. 아래는 그 핵심 로직의 단일컬럼 표기.
+
+알고리즘은 ① 품질·BAD 처리 ② 0 나눗셈 가드 ③ 입력 필터링 ④ enable/모드 게이트
+⑤ BAD 입력 시 마지막 정상 SP 홀드 ⑥ deadband ⑦ SP는 클램프·rate-limit 후에만 인가를 모두 포함한다.
+
+**설정 파라미터 (엔지니어 — 1회 입력, 품질변경 시만 수정)**
+
+```text
+PARAM  MODE          : INT   = 0        # 0=A(원료주도), 1=B(제품주도)
+PARAM  ENABLE        : BOOL  = FALSE     # 마스터 인에이블 (운전원)
+PARAM  K_D_t, K_P_t, K_B_t : REAL = 0.020, 0.950, 0.030   # 목표 분할계수
+PARAM  R_f_t         : REAL  = 0.80      # 제품기준 환류비
+PARAM  P_TARGET      : REAL  = 777.2     # 모드 B 목표 생산량 [kg/hr]
+PARAM  TAU_FILT      : REAL  = 300.0     # 입력 1차필터 시정수 [s]
+PARAM  F_MIN,F_MAX   : REAL  = 100, 1000
+PARAM  D_MIN,D_MAX   : REAL  = 0,   60
+PARAM  P_MIN,P_MAX   : REAL  = 0,   950
+PARAM  B_MIN,B_MAX   : REAL  = 0,   80
+PARAM  R_MIN,R_MAX   : REAL  = 150, 1100   # R_MIN = 트레이 wetting 하한
+PARAM  DR_MAX        : REAL  = 30.0      # 환류 변화율 한계 [kg/hr/min] (≈5%/min)
+PARAM  DF_MAX        : REAL  = 25.0      # 원료 변화율 한계 [kg/hr/min]
+PARAM  DPB_MAX       : REAL  = 50.0      # 제품/하부/경비 변화율 한계
+PARAM  DEADBAND      : REAL  = 0.5       # SP 갱신 데드밴드 [kg/hr]
+```
+
+**상태 변수 (블록 내부 보존)**
+
+```text
+STATE  Ff,Df,Pf,Bf,Rf_pv : REAL        # 필터된 입력
+STATE  F_sp,D_sp,P_sp,B_sp,R_sp : REAL # 마지막 정상 SP (BAD 시 홀드)
+STATE  initDone : BOOL = FALSE
+```
+
+**헬퍼**
+
+```text
+FUNC CLAMP(x,lo,hi)        = MAX(lo, MIN(hi, x))
+FUNC RATELIM(new,old,dmax) = old + CLAMP(new-old, -dmax*Ts/60, +dmax*Ts/60)   # Ts=스캔주기[s]
+FUNC LPF(x,xf)             = xf + (x-xf)*Ts/(TAU_FILT+Ts)
+FUNC GOOD(pt)              = (pt.Quality == GOOD) AND (NOT pt.Stale)          # OPC 품질+신선도
+FUNC SAFEDIV(a,b,dflt)     = IF (ABS(b) > 1e-6) THEN a/b ELSE dflt
+```
+
+**매 스캔 (Ts = 1~5 s) 본체**
+
+```text
+# ---- 0) 입력 읽기 + 품질 게이트 ----
+okF = GOOD(FICQ_6101) ; okD = GOOD(FICQ_6114) ; okP = GOOD(FICQ_6118)
+okB = GOOD(FICQ_6116) ; okR = GOOD(FICQ_6113)
+F=FICQ_6101.PV ; D=FICQ_6114.PV ; P=FICQ_6118.PV ; B=FICQ_6116.PV ; R=FICQ_6113.PV
+
+# ---- 1) 입력 필터 (정상값만 갱신, BAD는 직전 필터값 유지) ----
+IF okF: Ff=LPF(F,Ff)  ;  IF okD: Df=LPF(D,Df)  ;  IF okP: Pf=LPF(P,Pf)
+IF okB: Bf=LPF(B,Bf)  ;  IF okR: Rf_pv=LPF(R,Rf_pv)
+IF NOT initDone AND okF AND okP:        # 초기화: 첫 정상값으로 SP 시드 (범프리스)
+    F_sp=Ff; D_sp=Df; P_sp=Pf; B_sp=Bf; R_sp=Rf_pv; initDone=TRUE
+
+# ---- 2) 모니터 계산 (항상, SP 인가 금지) ----
+IF okF AND okD AND okP AND okB:
+    V_loss   = Ff - (Df + Pf + Bf)
+    Yield    = 100 * SAFEDIV(Pf, Ff, 0)
+    K_D_obs  = SAFEDIV(Df,Ff,0); K_P_obs=SAFEDIV(Pf,Ff,0); K_B_obs=SAFEDIV(Bf,Ff,0)
+    k_V_obs  = 1 - (K_D_obs+K_P_obs+K_B_obs)
+    IF ABS(V_loss) > 0.03*Ff : ALARM("MassBalance_Mismatch")
+    IF k_V_obs < 0           : ALARM("FlowMeter_Drift")     # 음의 손실 = 스팬오류
+LV_top = IF okR AND okD THEN SAFEDIV(Rf_pv, Rf_pv+Df, 0) ELSE BAD   # 정정된 정의 R/(R+D)
+
+# ---- 3) 제어 비활성 시: SP 산출 중단, 직전 SP 홀드 (운전원 수동 우선) ----
+IF (NOT ENABLE) OR (NOT initDone):
+    RETURN        # 출력 미인가 — 컨트롤러는 운전원/캐스케이드 SP 유지
+
+# ---- 4) 피드포워드 SP 산출 (목표계수 K_*_t 사용) ----
+IF MODE == 0:                                   # 모드 A: 원료 주도
+    IF NOT okF: RETURN                           # 마스터 BAD → 홀드
+    Draw = K_D_t * Ff ; Praw = K_P_t * Ff ; Braw = K_B_t * Ff
+    Fraw = Ff                                    # F는 운전원 SP (추종 안 함)
+ELSE:                                            # 모드 B: 제품 주도
+    Fraw = SAFEDIV(P_TARGET, K_P_t, F_sp)
+    Draw = SAFEDIV(K_D_t,K_P_t,0) * P_TARGET
+    Braw = SAFEDIV(K_B_t,K_P_t,0) * P_TARGET
+    Praw = P_TARGET
+Rraw = R_f_t * Praw                              # 외부환류 기준 (R_int/TCF는 제어 안 함)
+
+# ---- 5) 클램프 → rate-limit → 데드밴드 → 인가 ----
+D_sp = RATELIM(CLAMP(Draw,D_MIN,D_MAX), D_sp, DPB_MAX)
+P_sp = RATELIM(CLAMP(Praw,P_MIN,P_MAX), P_sp, DPB_MAX)
+B_sp = RATELIM(CLAMP(Braw,B_MIN,B_MAX), B_sp, DPB_MAX)
+R_sp = RATELIM(CLAMP(Rraw,R_MIN,R_MAX), R_sp, DR_MAX)
+IF MODE == 1: F_sp = RATELIM(CLAMP(Fraw,F_MIN,F_MAX), F_sp, DF_MAX)
+
+WRITE_IF_DELTA(FICQ_6114.SP, D_sp, DEADBAND)     # 데드밴드 초과 시에만 기록
+WRITE_IF_DELTA(FICQ_6118.SP, P_sp, DEADBAND)
+WRITE_IF_DELTA(FICQ_6116.SP, B_sp, DEADBAND)
+WRITE_IF_DELTA(FICQ_6113.SP, R_sp, DEADBAND)
+IF MODE == 1: WRITE_IF_DELTA(FICQ_6101.SP, F_sp, DEADBAND)
+```
+
+**적용 체크리스트**
+
+| 항목 | 확인 |
+|:-----|:-----|
+| 목표계수 `K_*_t`는 **상수**, 관측 `K_*_obs`는 모니터 전용 (혼용 금지) | ☐ |
+| `ENABLE=FALSE` 또는 BAD 입력 시 **직전 SP 홀드**(범프리스) | ☐ |
+| 초기 시드(`initDone`)로 인에이블 순간 bump 방지 | ☐ |
+| 각 하위 FIC는 **CAS 모드**(상위 계산블록이 SP 공급) 설정 | ☐ |
+| `R_MIN`은 트레이 dry-out 방지 최소 환류로 설정 | ☐ |
+| 모드 전환 시 새 모드 SP를 현재값으로 재시드 후 전환 | ☐ |
+| 계산블록 자체 BAD/실행실패 시 하위 FIC는 **last-SP 유지**(fail-freeze) | ☐ |
+
+---
+
+## 11. FEED 변경 시 동적 보상 — 전달지연 (Dynamic Feedforward)
+
+### 11.1 문제 정의
+
+§10 모드 A는 `D_sp = K_D_t × F` 처럼 **F에 즉각(동일 스캔) 비례**한다. F를 ramp로 천천히 올려도,
+**나머지 SP는 F를 그 자리에서 따라가므로** 다음 문제가 생긴다:
+
+- 증분 원료가 **아직 추출 트레이에 도달하지 않았는데** 제품·하부를 미리 더 뽑음 → **컬럼 인벤토리(레벨) 과배출** → 조성 흐트러짐 → **hunting**.
+- 각 추출점은 피드 트레이로부터 **물리적 거리·홀드업이 달라 응답 시점이 다르다**:
+  - **상부 D / 환류** : 증기 상승은 빠르나 응축기·환류드럼 홀드업으로 **지체(τ) 큼**
+  - **측류 P** : 피드 근처 → 지연 작음
+  - **하부 B** : 액이 트레이 타고 내려가 리보일러 홀드업 → **데드타임(θ)·지체 큼**
+
+→ 각 추출 SP를 **추출점까지의 전달지연(데드타임 θ + 1차 지체 τ)** 만큼 늦춰 인가해야 한다.
+
+> **⚠ §9.3(D5·D6) 적용**: 아래 "스트림별 독립 지연"은 **D·B가 레벨 제어로 닫혀 있을 때만 안전**하다.
+> C-6111처럼 **LICA-6113(드럼 레벨)** 이 D/환류를 구동하면, **명시적 deadtime/lag는 P(및 FF 환류)에만** 걸고
+> **D·B의 전달지연은 레벨 제어기가 적분으로 자동 처리**하도록 둔다(개루프 독립 지연 금지 → 인벤토리 표류).
+> 즉 §11.3~§11.5는 **commanded 스트림(P 등)에 한정** 적용한다.
+
+### 11.2 제어 구조
+
+```
+F_target(SP1→SP2) ──[Ramp]──► F_ramp ─┐
+                                       │   (driver = F_PV 권장, 필터링)
+                      ┌────────────────┼────────────────┬───────────────┐
+                      ▼                ▼                ▼               ▼
+                 [Deadθ_D+Lagτ_D]  [Deadθ_P+Lagτ_P]  [Deadθ_B+Lagτ_B]  (R은 P 경유)
+                      │                │                │
+                   ×K_D_t           ×K_P_t           ×K_B_t
+                      │                │                │
+                  CLAMP/RATELIM    CLAMP/RATELIM    CLAMP/RATELIM
+                      ▼                ▼                ▼
+                  FICQ-6114.SP     FICQ-6118.SP     FICQ-6116.SP
+                                       │
+                                  R_sp = R_f_t × P_sp  (P가 이미 보상됨)
+```
+
+> **F 자체는 보상하지 않는다**(F가 disturbance 원천). F는 운전원 ramp 그대로,
+> **D·P·B·R만** 각자의 θ·τ로 지연시킨다. ramp로 F가 천천히 변하면 D/P/B는 "ramp 추종 + 추가 지연"으로 이중 완만해진다.
+
+### 11.3 보상기 수식
+
+각 스트림 i ∈ {D, P, B} 에 대해 **순수 전달지연(데드타임) → 1차 지체**:
+
+```
+F_i(t) = LAG_τi ( F_driver(t − θ_i) )
+SP_i   = K_i_t × F_i(t)
+```
+
+| 기호 | 의미 |
+|:----:|:-----|
+| θ_i | 피드 FT → 추출점 i 까지 **순수 이송 데드타임** [s] |
+| τ_i | 추출점 i 의 **홀드업 1차 지체 시정수** [s] |
+
+**더 엄밀히** (피드가 컬럼에 미치는 동특성 ≠ 추출이 미치는 동특성일 때) **lead-lag** 추가:
+
+```
+G_i(s) = e^(−θ_i·s) × (τ_ld_i·s + 1) / (τ_lg_i·s + 1)
+```
+초기엔 lead 끄고(τ_ld=0) **데드타임+지체만**으로 시작, hunting 잔류 시 lead로 미세 보정.
+
+### 11.4 파라미터 산정 (bump test)
+
+정상상태에서 F를 작은 스텝(예 ±5%)으로 주고, 각 추출 라인의 **조성/필요유량이 움직이기 시작하는 시각 = θ_i**,
+**63% 도달까지 추가시간 ≈ τ_i**. 전형적 범위(컬럼별 반드시 실측):
+
+| 스트림 | θ_i (데드타임) | τ_i (지체) | 근거 |
+|:------:|:-------------:|:---------:|:-----|
+| P (측류, 피드 근처) | 30~120 s | 1~3 min | 피드 인접 |
+| D / 환류 (상부) | 60~180 s | 3~8 min | 증기상승+응축기·드럼 홀드업 |
+| B (하부) | 120~300 s | 3~10 min | 트레이 하강+리보일러 홀드업 |
+
+> **방향 비대칭 옵션**: 안전상 F **증가** 시 제품·하부는 θ를 **더 길게**(인벤토리 먼저 확보), F **감소** 시 θ를 **짧게**(과충전 방지). 기본은 대칭, 필요 시 `θ_up`/`θ_dn` 분리.
+> **환류 R**: 순도 보호 위해 제품보다 **먼저** 확보되는 게 유리 → R은 P_sp 경유(P 지연 상속)하되, 원하면 R에 작은 **lead**를 줘 환류를 약간 선행시킴.
+
+### 11.5 이산 구현 (계산블록 내부)
+
+**데드타임 = 순환버퍼(FIFO)**, **지체 = IIR 1차필터**. (Experion DEADTIME·LAGLEAD 블록으로 대체 가능)
+
+```text
+# --- 초기화 (스트림별) ---
+N_i   = ROUND(θ_i / Ts)                 # 버퍼 길이 (스캔수)
+buf_i = ARRAY[N_i] of REAL, head_i = 0  # 순환버퍼
+Fi    = F_driver                        # 지체필터 상태 (정상값 시드)
+
+FUNC DEADTIME(x, buf, head, N):         # θ초 전 값 반환
+    IF N <= 0: RETURN x                  # θ<Ts면 지연 없음
+    buf[head] = x
+    head = (head + 1) MOD N
+    RETURN buf[head]                     # 가장 오래된(=θ 전) 값
+
+FUNC LAG(x, state, tau):                 # 1차 지체
+    RETURN state + (x - state) * Ts/(tau + Ts)
+```
+
+**매 스캔 — §10.9 "4) 피드포워드 SP 산출" 의 모드 A 블록을 아래로 교체**
+
+```text
+IF MODE == 0:                            # 모드 A: 원료 주도 + 동적보상
+    IF NOT okF: RETURN                    # 마스터 BAD → 홀드
+    Fd = Ff                               # driver = 필터된 F_PV
+    # 방향 비대칭 데드타임 (옵션): F 상승/하강에 따라 N 선택
+    # 스트림별: 데드타임 → 지체 → 게인
+    Fd_D = LAG( DEADTIME(Fd, buf_D, head_D, N_D), Fi_D, tau_D ) ; Fi_D = Fd_D
+    Fd_P = LAG( DEADTIME(Fd, buf_P, head_P, N_P), Fi_P, tau_P ) ; Fi_P = Fd_P
+    Fd_B = LAG( DEADTIME(Fd, buf_B, head_B, N_B), Fi_B, tau_B ) ; Fi_B = Fd_B
+    Draw = K_D_t * Fd_D
+    Praw = K_P_t * Fd_P
+    Braw = K_B_t * Fd_B
+    Fraw = Ff                             # F는 운전원 SP, 보상 안 함
+Rraw = R_f_t * Praw                       # 환류는 보상된 P 경유 (P 지연 상속)
+# 이후 §10.9 "5) 클램프→rate-limit→데드밴드→인가" 그대로
+```
+
+> 게인(K)은 선형이라 `K·DEADTIME(F)` = `DEADTIME(K·F)` 로 등가 → 위처럼 **F를 먼저 지연**시키는 게 구현상 간단.
+> 모드 B(제품 주도)는 F_target이 이미 운전원 ramp이므로, 동일하게 P_TARGET을 driver로 두고 D·B·F_SP에 θ·τ 적용.
+
+### 11.6 과도상태 물질수지 — 경보 오발 방지 ★
+
+전달지연 중에는 **인벤토리 축적항 dM/dt ≠ 0** 이라, 동적 물질수지는:
+
+```
+F = D + P + B + V_loss + dM/dt        ( dM/dt = 컬럼/드럼 홀드업 변화율 )
+```
+
+→ §10.6 의 `V_loss = F − (D+P+B)` 는 **과도 중 일시적으로 커진다(정상)**. 그대로 두면 `MassBalance_Mismatch` 오경보.
+따라서 **과도 게이트**를 둔다:
+
+```text
+moving = ( ABS(dF/dt) > 0.01*F_MAX/60 )           # F 변화 중
+settling = ( time_since_last_F_move < T_SETTLE )   # 이동 후 정착시간(= max θ_i + 3·max τ_i)
+IF moving OR settling:
+    SUPPRESS ALARM("MassBalance_Mismatch")          # 경보 보류
+    V_loss_ss = INVALID                             # 정상상태 손실 산정 보류
+ELSE:
+    # 정상상태에서만 V_loss·Yield·k_V 신뢰 (§10.6)
+```
+
+> `T_SETTLE ≈ max(θ_i) + 3×max(τ_i)` (가장 느린 스트림=B 기준, 전형 15~40 min). 이 창 안에서는
+> 물질수지·수율 KPI를 "정착 대기"로 표시하고 경보를 묶는다.
+
+---
+
+## 12. 프로젝트 코드 구현 방안 — 다중 컬럼 공유 "권장 SP(보조지표)" 엔진
+
+### 12.0 작업 단계 정의 (Scope) ★ 반드시 먼저 읽을 것
+
+> DCS 펑션블록은 **가변길이 데드타임 버퍼·진짜 이동평균·다컬럼 공유·dM/dt 과도게이트·비대칭
+> up/down 동특성·운전원 편집 경험상수**를 다 담지 못한다. 따라서 이 연산은 **우리 프로젝트 코드**에서
+> 수행하고, 결과를 **운전원에게 권장값으로 제시**한다.
+
+| 항목 | 본 단계의 정의 |
+|:-----|:----|
+| **성격** | **보조지표(Advisory)** — 폐루프 제어 **아님**. 제어 레지스터(SP/OP)에 **자동 쓰기 안 함** |
+| **모드 무관(mode-agnostic)** | 유량제어기가 **AUTO든 MANUAL이든** 무관하게, 전달지연까지 반영한 **정확한 권장 SP**를 계산·표시 |
+| **출력** | 운전원 화면(우리 Web UI, 또는 별도 **표시 전용 태그**)에 **권장 SP·현재값·차이·추세**를 띄움 |
+| **운전원 역할** | 권장값을 **참고**해 **직접(수동) 인가**. 최종 판단·조작은 운전원 |
+| **목표** | 권장값이 반복적으로 타당함을 보여 **운전원의 확신을 축적** → 추후(별도 phase) RSP 감독제어로 승격 |
+| **비침습성** | 제어 루프를 건드리지 않으므로 **즉시 가동 가능**(쓰기 가드·워치독은 Stage 3 전제조건) |
+
+> ⚠ "모든 FIC가 PID AUTO"라고 가정하지 않는다. MANUAL에서 운전원이 OP를 직접 잡고 있어도, 우리는
+> **그 운전원이 다음에 맞춰야 할 SP**(전달지연 정합)를 계산해 보여주는 것이 본질이다.
+
+### 12.1 다중 컬럼 공유 아키텍처
+
+이 연산은 **C-6111 전용이 아니라 여러 컬럼이 공유하는 라이브러리**다. **컬럼-불가지(column-agnostic)
+순수 연산 블록** + **컬럼별 설정(데이터)** + **컬럼별 런타임 상태**로 분리한다.
+
+```
+[재사용 연산 블록 (순수·단위테스트 가능, 컬럼 무관)]
+  MovingAverage / Ema      ─ 노이즈 제거 (F 전단)        ← D10
+  DeadTimeBuffer           ─ 가변길이 링버퍼 (전달지연 θ)  ← DCS 불가
+  FirstOrderLag / LeadLag  ─ 지체 τ (및 lead 보정)
+  RateLimiter (up/dn 분리) ─ 비대칭 변화율               ← D7
+  Clamp                    ─ 레인지/운전한계
+  RatioFeedforward         ─ K_i × (보상된 driver)
+  MassBalanceMonitor       ─ dM/dt(레벨) 포함 과도게이트   ← D6·D11
+
+        ▲ 위 블록들을 조합 ▲
+[FeedforwardEngine]  EngineTick(ColumnConfig cfg, Pv snapshot, ColumnState st) → AdvisoryResult
+        │
+[Supervisor]  활성 컬럼 N개를 주기적으로 Tick (ExperionRealtimeService 패턴 차용)
+        │
+[설정: Web UI → DB(컬럼/스트림 설정) → 엔진]   [출력: AdvisoryResult → Web UI/표시태그]
+```
+
+- **엔진은 상태를 cfg/st 인자로만** 다룬다(전역 상태 없음) → 컬럼마다 독립 인스턴스, 상호 격리.
+- 새 컬럼 추가 = **DB에 설정 row 추가 + 태그 바인딩**만. 코드 변경 0.
+
+### 12.2 역할 분담
+
+| 주체 | 담당 |
+|:-----|:-----|
+| **DCS** | 실제 제어(PID), **레벨 폐루프(LICA-6113 등)로 인벤토리 유지**, PV/모드 제공 (§9.3 D5) |
+| **우리 코드(엔진)** | MA/EMA·데드타임·lag·비율·클램프·**비대칭 rate**·**과도 물질수지 게이트**·권장 SP 산출. **쓰기 안 함** |
+| **Web UI** | ① 컬럼별 **경험상수 공급 페이지** ② 컬럼별 **권장 SP 대시보드**(현재 vs 권장 vs 차이 vs 추세) |
+| **운전원** | 권장값 참고해 **수동 인가**(AUTO면 SP, MANUAL이면 OP 조정). 최종 권한 |
+
+### 12.3 데이터 흐름 (Advisory)
+
+```
+realtime_table / OPC PV ─► [Supervisor.Tick]
+                             │  cfg(DB) + state(메모리/DB)
+                             ▼
+                       FeedforwardEngine ──► AdvisoryResult { perStream: {pv, recSP, gap, trend, valid}, transient, massBal }
+                             │
+                             ├─► Web UI 대시보드 (운전원 화면)
+                             └─► (옵션) 표시 전용 태그  ※ 컨트롤러 SP 레지스터 아님
+   ── 본 단계는 여기서 끝 (운전원이 보고 수동 인가) ──
+```
+
+### 12.4 신규/재사용 컴포넌트
+
+| 레이어 | 컴포넌트 | 신규/재사용 |
+|:-------|:---------|:-----------|
+| Core/Application | `IFeedforwardEngine`, `ColumnConfig`, `StreamConfig`, `AdvisoryResult` (DTO/옵션) | 신규 |
+| Infrastructure/Control | 연산 블록 6종 + `FeedforwardEngine` + `FeedforwardSupervisor` | 신규 (순수 로직, 단위테스트) |
+| Infrastructure (read) | PV/모드 스냅샷 | **재사용** — `ExperionRealtimeService`/`realtime_table` |
+| Infrastructure/Database | `ff_column_config`, `ff_stream_config`(+ 선택 `ff_state`) 테이블 | 신규 (`ExperionDbContext` boot DDL 패턴) |
+| Web/Controllers | `FeedforwardController` — 설정 CRUD(admin) + 권장값 status(공개) | 신규 |
+| Web/wwwroot | 신규 탭(예: Tab 18) — 설정 폼 + 권장 SP 대시보드 | 신규 (Tab 16/17 패턴) |
+| **쓰기/RSP/가드** | `ExperionOpcWriteClient` + WriteGuard | **본 단계 미사용** — Stage 3 전제 |
+
+### 12.5 컬럼/스트림 설정 (경험상수 = Web UI 공급)
+
+우리가 결정 못 하는 값·경험치는 **전부 Web UI에서 컬럼별로 입력**하고 DB 저장(품질변경 시만 수정).
+
+```
+ColumnConfig {
+  id, name,
+  feedTag,                     // F 유량 PV 태그
+  pressureTag,                 // 진공 압력 (안정 게이트, D11)
+  levelTags[],                 // 드럼/탑저 레벨 PV (dM/dt·과도게이트, D6)
+  maWindowSec | tauF,          // F 노이즈 필터 (D10)
+  enabled, advisoryOnly=true   // 본 단계 강제 true
+  streams: StreamConfig[]
+}
+StreamConfig {
+  tag,                         // 예: ficq-6118 (P)
+  role,                        // commanded | level_driven | monitor   ← §9.3 D5
+  K_t,                         // 목표 비율 (commanded일 때)
+  thetaUpSec, thetaDnSec,      // 전달 데드타임 (비대칭, D7)
+  tauSec, tauLeadSec,          // 지체/리드 (lead-lag)
+  spMin, spMax,                // 클램프
+  rateUp, rateDn,              // 비대칭 변화율 (D7)
+  deadband,
+  responseSignalTag            // step test 응답 지표(analyzer/level/flow, D8)
+}
+```
+
+| 역할(role) | 의미 (§9.3 적용) |
+|:----------:|:-----|
+| `commanded` | 엔진이 권장 SP 산출 (예: **P**, FF 환류 **R**) — 전달지연 적용 |
+| `level_driven` | **레벨 제어가 구동**(예: C-6111의 **D**, **B**). 권장값은 "레벨추종 기대치/바이어스"로만 표시, 독립 deadtime 미적용 (D5·D6) |
+| `monitor` | V_loss·수율 등 산출만 (SP 금지, §10.5~10.6) |
+
+> **기본 권장 매핑(C-6111)**: F=feed, **P=commanded**, **R=commanded(P 경유)**, **D·B=level_driven**, V_loss=monitor.
+> 다른 컬럼은 레벨 폐루프 구성에 맞춰 role을 재지정.
+
+### 12.6 연산 루프 (mode-agnostic · advisory, 의사코드)
+
+```text
+# Supervisor가 활성 컬럼마다 Ts(1~5s) 주기로 호출
+AdvisoryResult Tick(cfg, st):
+    snap = ReadPVs(cfg.feedTag, cfg.pressureTag, cfg.levelTags, [s.tag for s in cfg.streams],
+                   alsoMode=true)          # 모드는 표시용으로만 읽음 (AUTO/MAN 무관)
+    if not Good(snap.feed): return Hold(st, reason="FEED BAD")
+
+    # 1) F 노이즈 필터 (이동평균/EMA) — DCS가 못하는 진짜 윈도우 MA 가능
+    Ff = st.maF.Push(snap.feed.pv)         # MovingAverage 또는 Ema
+
+    # 2) 과도/압력 게이트 (D6·D11) — 레벨로 dM/dt 산출
+    dMdt   = st.levelDeriv.Update(snap.levels)         # 홀드업 변화율
+    moving = abs(st.feedDeriv.Update(Ff)) > cfg.feedMoveThresh
+    pUnstable = abs(snap.pressure.pv - st.pressFilt) > cfg.pressBand
+    transient = moving or pUnstable or st.settleTimer.Active
+
+    # 3) 스트림별 권장값
+    for s in cfg.streams:
+        if s.role == commanded:
+            theta = (Ff rising) ? s.thetaUp : s.thetaDn      # 비대칭 (D7)
+            Fd    = st[s].dead.Through(Ff, theta/Ts)         # DeadTimeBuffer (가변길이)
+            Fd    = st[s].lag.Step(Fd, s.tau, s.tauLead)     # FirstOrderLag/LeadLag
+            raw   = s.K_t * Fd
+            rec   = RateLimit(Clamp(raw, s.spMin, s.spMax),
+                              st[s].lastRec, s.rateUp, s.rateDn)  # 비대칭 rate
+            st[s].lastRec = rec
+        elif s.role == level_driven:
+            rec = s.K_t * Ff            # "기대치" 표시용 (레벨이 실제 구동). deadtime 미적용
+        else:  # monitor
+            rec = null
+        result.add(s.tag, pv=snap[s].pv, recSP=rec,
+                   gap = (rec!=null ? rec - snap[s].pv : null),
+                   trend = sign(rec - st[s].lastRec),
+                   valid = not transient)        # 과도 중엔 "정착 대기"로 표시
+
+    # 4) 물질수지 모니터 (과도 게이트로 경보 보류, §11.6)
+    if not transient and AllGood(F,D,P,B):
+        result.massBal = { Vloss: Ff-(D+P+B), yield: 100*P/Ff }
+    else:
+        result.massBal = SETTLING(remainSec = st.settleTimer.Remain)
+
+    # ★ 쓰기 없음 — result를 Web UI/표시태그로 반환만
+    return result
+```
+
+> **MANUAL 대응**: 컨트롤러가 MANUAL이어도 위 계산은 동일. UI는 "현재 PV vs 권장 SP, 차이, 추세
+> 화살표"를 보여 운전원이 **수동으로 OP를 어느 방향으로 얼마나** 움직일지 판단하게 한다.
+
+### 12.7 운전원 화면 (권장 SP 대시보드)
+
+컬럼별 카드:
+
+| 표시 | 내용 |
+|:-----|:-----|
+| 모드 배지 | 각 FIC의 AUTO/MAN/CAS (참고 표시) |
+| 스트림 행 | `현재 PV │ 권장 SP │ 차이(Δ) │ ▲/▼ 추세 │ valid/정착대기` |
+| 전달지연 상태 | "FEED 변경 감지 — P 권장값이 향후 N분에 걸쳐 X→Y로 상승" (지연 진행 시각화) |
+| 물질수지 | V_loss·수율 (정상상태만; 과도 중 "정착 N분 남음") |
+| level_driven 주석 | "D·B는 레벨 제어가 구동 — 권장값은 기대치" |
+
+### 12.8 단계적 도입 (운전원 신뢰 사다리)
+
+| Stage | 내용 | 쓰기 | 전제 |
+|:-----:|:-----|:----:|:-----|
+| **1 Shadow** | 계산·**로그만**, 화면 미표시 | ✗ | 없음 (즉시) |
+| **2 Advisory ★본 단계** | 권장 SP **화면 표시**, 운전원 **수동 인가** | ✗ | 없음 (비침습) |
+| 3 Supervisory(후속) | RSP로 SP 추종 쓰기(운전원 채택 스위치) | △ RSP | **WriteGuard(min/max·rate·Δcap)+워치독+데드맨** 신규 구현 선행 |
+
+> Stage 3은 **운전원이 Advisory 단계에서 확신을 가진 뒤** 별도 합의로 진행. `측류추출-자동운전-플랜`의
+> RSP/MAN-OP·쓰기가드 설계를 따른다(현재 `ExperionOpcWriteClient`는 가드 0건 → 그대로 쓰면 위험).
+
+### 12.9 검증 포인트 (본 단계)
+
+- 연산 블록 6종 **단위테스트**(데드타임 길이·MA 윈도·비대칭 rate·lag 스텝응답).
+- 다컬럼 **상태 격리**(한 컬럼 BAD가 타 컬럼 영향 없음).
+- 재기동 시 상태 **bumpless 시드**(첫 정상 PV로 lag/버퍼 초기화) — 권장값 점프 방지.
+- 과도 게이트가 FEED 이동·압력 불안정에 **물질수지 경보를 정확히 보류**.
+- **쓰기 경로 0건** 확인(advisory 단계 불변식): 엔진/컨트롤러에서 SP·OP write 호출 부재.
+
+---
+
+## 13. 온도 프로파일 기반 전달지연 검출 & Sweet-Spot 유지 (가능성 평가)
+
+> **착상(운전원 가설)**: FEED↑ → 탑저 TICA-6111A.PV↓ → 스팀↑로 boilup 재정합. 평형 도달까지
+> TICA-6111A·TI-6111B·TI-6111C·TI-6111D의 **온도 변화 순서/시점으로 전달지연을 검출**하고,
+> 그걸로 **제품 노즐 근처 sweet spot을 유지**하며 투입량 변화에 대응할 수 있는가?
+
+### 13.1 인과사슬 검증 (타당)
+
+고정 듀티에서 FEED↑ → 하부 액부하↑·기화율↓ → 탑저 조성이 가벼워짐(저비점) → **TICA-6111A.PV↓**,
++ 과냉각 피드 **현열 수요**가 하강을 가속 → 운전원/TICA가 **스팀↑**로 boilup 재정합. **사슬 자체는 맞다.**
+
+### 13.2 무엇이 검출되고 무엇이 안 되는가
+
+| 함정 | 내용 |
+|:-----|:-----|
+| **① 에너지 ≠ 조성** | 온도 onset 순서(A→B→C→D)는 대부분 **증기 boilup 파동(빠름)**. 제품 순도를 지배하는 **조성 프론트 이동은 느림(P 15~20분)**. → 온도로 θ를 잡으면 **빠른 에너지 지연만, 느린 조성 지연은 과소추정** |
+| **② 낮은 SNR (D8)** | 준단일성분 PGMEA, 구배 ~2°C로 평탄. 제품존 조성변화 온도효과 ≲0.1°C → 노이즈에 묻힘. **가장 지키고 싶은 지점이 가장 약한 신호** |
+| **③ 진공압 결합 (D11)** | T_bp = f(P, 조성). PICA-6111/스팀이 vapor load→압력을 흔들면 조성과 무관하게 온도 이동 |
+| **④ 폐루프 오염** | TICA가 이미 스팀 조작 → TICA-6111A.PV는 "딥-회복" **폐루프 합성응답**. 순진한 feed→onset은 **스팀 동특성을 전달지연으로 오귀속** |
+
+### 13.3 신호 조건화 (DCS 불가 · 우리 코드)
+
+| 처리 | 식 / 목적 |
+|:-----|:----------|
+| **압력보정온도 PCT** | `T_PCT = T_meas − (dT/dP)·(P − P_ref)` — 진공 노이즈 제거. `dT/dP`는 데이터 캘리브레이션 (함정 ③) |
+| **차온 ΔT / 이중차온** | `TI-6111C − TI-6111D` 등 — 공통모드 압력변동 상쇄, **프론트 이동만 부각**(고순도 컬럼 정석, 함정 ②) |
+
+### 13.4 Passive 전달지연 식별 (자연 외란 활용)
+
+딥테스트 없이 **정상 운전 중**:
+
+```
+θ_i = argmax_τ  ρ( ΔF(t),  ΔPCT_i(t+τ) )        # F→온도 교차상관 지연
+```
+
+- **스팀 S(=TICA-6111A.OP)를 2번째 입력으로 부분상관**(partial corr) → 폐루프 오염 회피(함정 ④).
+- 미분/사전백색화(pre-whitening)한 ΔF·ΔS·ΔPCT 사용. 외란 충분치 않으면 **신뢰도 낮음**으로 표시.
+- 결과 θ_i는 §12 엔진의 **deadtime 파라미터를 자동 튜닝**(advisory θ의 근거가 됨).
+
+### 13.5 Sweet-Spot 유지 = 프론트 위치 (피드포워드 + 온도 피드백)
+
+```
+        FEED 변화
+           │  (빠른 보상)
+   ┌───────┴────────┐
+   ▼                ▼
+[피드포워드 §11~§12]   [온도 피드백 §13]  ← 느린 프론트 위치 유지
+  P·R 권장 SP          제품존 PCT/ΔT = sweet-spot 지표
+                       프론트 드리프트 시 → 환류/boilup 트림 권장
+```
+
+- 사용자가 원한 그림(투입량 변해도 sweet spot 유지)은 **2층 구조**로 실현: 빠른 에너지=피드포워드,
+  느린 조성 프론트=온도 피드백. **온도는 "조성 프론트 위치 프록시"** 로 쓰는 게 정확한 용법.
+- **민감 트레이**(|dT_PCT/d위치| 최대) 또는 제품존 ΔT를 프론트 지표로 선정. 여전히 **advisory**(운전원 인가).
+
+### 13.6 §12 엔진 확장 (신규 연산블록)
+
+| 블록 | 역할 |
+|:-----|:-----|
+| `PressureComp` | PCT 계산 (온도−압력보정) |
+| `DiffTemp` | 차온/이중차온 |
+| `CrossCorrLagEstimator` | F·S 다입력 부분상관 θ 식별 + 신뢰도 |
+| `FrontPositionIndicator` | 제품존 PCT/ΔT → sweet-spot 건전성 + 드리프트 트림 권장 |
+
+> ColumnConfig에 `tempTags[]`, `pressureTag`, `sensitiveTrayTag`, `responseSignalTag(analyzer 우선)` 추가.
+> 컬럼별로 "온도지표 사용 여부/민감트레이"를 설정 → 다컬럼 공유 유지.
+
+### 13.7 평가 결론 & 전제조건
+
+- **할 만하고 옳은 방향**(피드백이 모델오차 보정 → 개루프 deadtime보다 우수).
+- 단 **단일점 생온도로는 이 컬럼에서 약함** → (a) **PCT/차온 필수**, (b) **스팀 포함 다변수 식별**,
+  (c) 측류 **analyzer 있으면 corroborate**, (d) 온도유도 θ는 **신뢰도 등급 붙은 추정치**로 취급.
+- **온도는 빠른 에너지 지연엔 강하고 느린 조성 지연엔 약함** — 둘을 구분 사용.
+- 전제: 실 플랜트 적용 시 **온도 프로파일/센서 건전성** 먼저 검증(평탄·구배 방향). (현재는 데모 시스템 — 온도값은 인위 생성)
+
+---
+
+## 14. 오차·외란 예산과 보정값 실효성 (Error Budget) ★
+
+> **질문**: 미세 보정값들이 실플랜트의 센서오차·신호전달오차·외란(특히 한국 여름/겨울
+> 냉각수 온도차)에 비해 **실제로 의미 있는 영향력**을 가지는가?
+
+### 14.1 결정적 민감도 — 진공압 → 온도
+
+PGMEA @48.5 torr, ~350K, λ≈43.6 kJ/mol → Clausius-Clapeyron:
+
+```
+dT/dP ≈ 0.5 °C / torr   (근사)
+```
+
+→ **진공 ±2 torr = 온도 ±1°C = 컬럼 전체 구배(~2°C)의 절반.** 수 torr 진공 노이즈가
+조성 온도신호를 통째로 덮음. PCT가 *필수*인 동시에 생온도의 취약성을 보여줌.
+
+### 14.2 오차예산 (이 컬럼, 근사)
+
+| 출처 | 크기 | 비교 |
+|:-----|:----:|:-----|
+| 원료 유량계 | ±1~2% | 비율 신호(피드 10~20%)보다 **훨씬 작음** ✓ |
+| 물질수지 V_loss | ~1% | 유량계 오차와 **동급** → 순간값 신뢰불가 (§5.3) |
+| 온도센서 RTD | ±0.1~0.3°C | 조성신호 <0.1°C와 **동급/이상** ⚠ |
+| **진공압→온도** | **~0.5°C/torr** | 진공 ±2 torr = 구배 절반 ⚠⚠ |
+| TCF 과냉각 | +3~6% | 유량오차보다 크나 **계절변동·해석전용** |
+| **계절 CW 스윙(한국)** | **여름/겨울 15~25°C** | k_V 0.5→2%(4배)·TCF·진공도 변동 — **느린 대형 바이어스** |
+
+### 14.3 보정값 3등급
+
+| 등급 | 항목 | 판정 |
+|:----:|:-----|:-----|
+| **A 견고** | 비율 피드포워드(D·P=K·F), 전달지연 **타이밍**, 유량 노이즈 필터 | 신호 ≫ 노이즈. θ는 ±50% 틀려도 0보다 우월(정밀도 불필요). **가치의 대부분** |
+| **B 한계** | TCF(3~6%), V_loss(0.5~2%) | 유량오차 동급 + 계절변동 + 해석/모니터 전용 → **"참고 추세"로만, 순간 정밀보정 금지**. V_loss는 **장기 MA**로만 의미 |
+| **C 취약** | 제품존 PCT 조성추론 | 조성<0.1°C < (압력 0.5°C/torr + 센서 0.1~0.3°C) → 노이즈 바닥 아래. **analyzer/차온 보조 필수** |
+
+### 14.4 계절 외란(한국 CW) = 느린 바이어스로 처리
+
+여름/겨울 냉각수 스윙은 **크지만 느린(계절·일주기)** 외란 → 피드포워드(분 단위)와 **시간척도 분리**.
+
+- **정밀 모델링 금지** — K·TCF·k_V를 고정상수로 박으면 계절마다 틀림.
+- **느린 바이어스 적응/운전원 트림(Bias)** 으로 흡수 (관계식 문서의 "Bias의 필요성"):
+  - K·k_V는 **물질수지 장기 MA로 천천히 자동 갱신**.
+  - PCT `P_ref`·`dT/dP`는 **계절 재캘리브레이션**, 또는 **차온(ΔT)** 으로 공통모드(압력·계절) 상쇄.
+- **빠르고 정밀한 보정(타이밍·비율) ↔ 느리고 큰 외란(계절)** 을 서로 다른 메커니즘으로 분리 처리.
+
+### 14.5 결론 — advisory 아키텍처를 정당화
+
+- 미세 보정(TCF·V_loss·제품존 온도)의 절대 영향력은 실플랜트 오차/계절외란에 **묻혀 작다**.
+- 따라서 그것들을 **정밀 제어식이 아니라 "신뢰도 플래그 붙은 추세"로 강등**, 계절외란은 **느린 바이어스 트림**으로 넘긴다.
+- 시스템 가치의 대부분은 **견고한 A등급(비율·타이밍·필터)** 에서 나오며, 이는 오차에 강하다.
+- advisory(자동쓰기 없음)라 **미세 보정이 애초에 정밀할 필요가 없다** — 운전원이 계절 바이어스를 자연 흡수.
+- **설계 반영(§12 엔진)**: 각 출력에 **confidence 등급(A/B/C)** 표기, V_loss·k_V는 **장기 MA**, K·TCF는
+  **느린 적응/계절 프로파일**, 제품존 지표는 **analyzer 우선·온도는 차온**.
+
+---
+
+## 부록 A. 정정 요약 (한 줄)
+
+- 설정값은 **F·D·P·B·R_ext 5개 측정 스트림에만** 부여. (§10.3)
+- **V_loss·R_int·L/V는 계산 모니터링 태그** — SP 금지. (§10.5~10.6)
+- L/V 열역학 정의는 `R/(R+D)`, 본문 `R/(R+P)`는 제품기준 지표로 별도. (§10.5)
+- 모든 비례식은 **CLAMP + RATE_LIMIT** 후 인가. (§10.7)
+- FEED 변경 시 D·P·B·R SP는 **추출점별 데드타임 θ + 지체 τ로 전달지연** 인가(즉각 연동 금지). F만 운전원 ramp. (§11)
+- 전달지연 중에는 **dM/dt≠0** → 물질수지 경보를 **과도 게이트로 보류**(오발 방지). (§11.6)
+- 온도로 전달지연 검출·sweet-spot 유지 **가능하나 조건부**: 단일점 생온도 약함 → **PCT/차온+스팀포함 다변수 식별** 필수, 온도유도 θ는 추정치. (§13)
+- **진공 0.5°C/torr** = 구배 절반. 보정 3등급(A견고:비율·타이밍·필터 / B한계:TCF·V_loss / C취약:제품존온도). 계절 CW외란은 **느린 바이어스 트림**으로(정밀모델 금지). (§14)
+- **인벤토리(레벨)는 D·B를 구동** — F·D·P·B 전부 개루프 명령은 자유도 과지정. **P·R만 commanded, D·B는 level_driven**. (§9.3 D5·D6)
+- 본 구현은 **다중 컬럼 공유 엔진** — 컬럼-불가지 연산 블록 + 컬럼별 설정(DB)/상태. (§12.1)
+- 본 단계 = **보조지표(Advisory)**: AUTO/MANUAL 무관, **권장 SP를 화면 표시·운전원 수동 인가**, **자동 쓰기 없음**. RSP는 후속 Stage 3. (§12.0·§12.8)