# 측류추출 통합유량 — §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/판단 항목.