# Operator Workbench Efficiency (F1-F5) Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** 운영자 워크벤치의 검색 보강 수작업을 줄이고(추천 쿼리 원클릭 실행, Google 수동 검색 재노출) 케이스 판단 속도를 높인다(얼굴 크롭 썸네일, 재분석 증거 diff, KB 정비).

**Architecture:** 백엔드는 `CopyrighterStore`(SQLite, JSON 페이로드)에 메서드를 추가하고 `http_app.py`에 라우트를 잇는 기존 패턴을 그대로 따른다. 프런트는 `web/operator-gui/app.js`의 문자열 템플릿 렌더 + 이벤트 위임 패턴을 따른다. 스펙: `docs/superpowers/specs/2026-06-11-operator-workbench-efficiency-design.md`.

**Tech Stack:** Python 3.13 표준 라이브러리(http.server, sqlite3), Pillow, pytest / 바닐라 JS(프레임워크 없음), 정적 UI 계약 테스트(`tests/operator_gui/test_static_workbench.py`).

**실행 명령 공통:** 저장소 루트(`C:\Users\USER\Desktop\munsang\copyrighter`)에서 실행. 테스트는 `python -m pytest <경로> -v`.

---

### Task 1: F1 — 추천 쿼리 바로 실행 / 모두 실행

근거 보강 추천 패널의 쿼리 버튼은 현재 수동 검색 입력칸을 채우기만 한다(`applySuggestedQuery`). 쿼리별 "바로 실행"과 패널 "모두 실행"을 추가한다. 서버 변경 없음 — 기존 `/api/search/manual`을 재사용한다.

**Files:**
- Modify: `web/operator-gui/app.js` (renderEvidenceNextActions ~line 890, 모듈 상단 ~line 28, 클릭 위임 ~line 3550, 케이스 선택 ~line 2130)
- Modify: `web/operator-gui/styles.css` (말미에 추가)
- Test: `tests/operator_gui/test_static_workbench.py`

- [ ] **Step 1: 실패하는 UI 계약 테스트 작성**

`tests/operator_gui/test_static_workbench.py` 말미에 추가:

```python
def test_suggested_queries_support_one_click_and_batch_execution():
    script = _read(APP_JS)
    styles = _read(STYLES)

    assert "executeSuggestedQueries" in script
    assert "data-run-suggested-query" in script
    assert 'id="run-all-suggested-queries"' in script
    assert "모두 실행" in script
    assert "바로 실행" in script
    assert "suggested-query-run-status" in script
    # 기존 "입력칸 채우기" 버튼은 수정용으로 유지된다.
    assert "data-suggested-query" in script
    assert ".suggested-query-item" in styles
```

- [ ] **Step 2: 테스트 실패 확인**

Run: `python -m pytest tests/operator_gui/test_static_workbench.py::test_suggested_queries_support_one_click_and_batch_execution -v`
Expected: FAIL (`assert "executeSuggestedQueries" in script` AssertionError)

- [ ] **Step 3: app.js 구현**

(3a) 모듈 상단, `const searchCoverage = {};` (line ~28) 아래에 추가:

```js
let suggestedQueryRunSummary = null; // { caseId, message } — 현재 케이스의 마지막 추천 쿼리 실행 결과
```

(3b) `renderEvidenceNextActions` 전체를 다음으로 교체:

```js
function renderEvidenceNextActions(submission) {
  const summary =
    suggestedQueryRunSummary && suggestedQueryRunSummary.caseId === submission.id
      ? `<div class="inline-status" id="suggested-query-run-result">${escapeHtml(suggestedQueryRunSummary.message)}</div>`
      : "";

  if (!evidenceNeedsFollowup(submission)) return summary;

  const queries = suggestedEvidenceQueries(submission);
  const reasons = evidenceFollowupReasons(submission);
  if (!queries.length) return summary;

  return `
    <section class="evidence-next-action-panel" aria-label="근거 보강 추천">
      <div>
        <strong>근거 보강 추천</strong>
        <span>추천 쿼리를 바로 실행하거나, 쿼리 본문을 눌러 수동 검색 입력칸에서 수정할 수 있습니다.</span>
      </div>
      <ul class="evidence-followup-reasons">
        ${reasons.map((reason) => `<li>${escapeHtml(reason)}</li>`).join("")}
      </ul>
      <div class="suggested-query-list">
        ${queries
          .map(
            (query) => `
              <span class="suggested-query-item">
                <button class="row-action" type="button" data-suggested-query="${escapeHtml(query)}" data-suggested-provider="naver">
                  ${escapeHtml(query)}
                </button>
                <button class="row-action" type="button" data-run-suggested-query="${escapeHtml(query)}">바로 실행</button>
              </span>
            `,
          )
          .join("")}
      </div>
      <div class="suggested-query-actions">
        <button class="row-action" type="button" id="run-all-suggested-queries">모두 실행</button>
      </div>
      <div id="suggested-query-run-status" class="inline-status" aria-live="polite"></div>
      ${summary}
    </section>
  `;
}
```

(3c) `applySuggestedQuery` 함수 아래에 새 함수 추가:

```js
async function executeSuggestedQueries(queries) {
  const submission = getSelectedCase();
  if (!submission || !queries.length) return;

  const statusTarget = document.getElementById("suggested-query-run-status");
  const naver = providers.find((provider) => provider.id === "naver");
  if (!naver || !naver.enabled) {
    if (statusTarget) statusTarget.textContent = "네이버 외부 검색 tool이 비활성입니다.";
    return;
  }

  const results = [];
  for (const [index, query] of queries.entries()) {
    if (statusTarget) statusTarget.textContent = `"${query}" 실행 중… (${index + 1}/${queries.length})`;
    try {
      await apiJson("/api/search/manual", {
        method: "POST",
        body: JSON.stringify({ submission_id: submission.id, provider: "naver", query }),
      });
      results.push(`"${query}" 완료`);
    } catch (errorValue) {
      results.push(`"${query}" 실패: ${errorValue.message}`);
    }
  }

  suggestedQueryRunSummary = {
    caseId: submission.id,
    message: `추천 쿼리 실행 — ${results.join(" · ")}`,
  };
  await refreshFromApi();
}
```

쿼리는 순차 실행한다(쿼터 계측·상태 표시 단순화). 일부 실패해도 나머지는 계속 실행하고 쿼리별 결과를 모아 표시한다.

(3d) 문서 클릭 위임부(기존 `data-rerun-query` 처리 분기, ~line 3550) 바로 위에 추가:

```js
    const runSuggestedButton = event.target.closest("[data-run-suggested-query]");
    if (runSuggestedButton) {
      void executeSuggestedQueries([runSuggestedButton.dataset.runSuggestedQuery]);
      return;
    }

    const runAllSuggestedButton = event.target.closest("#run-all-suggested-queries");
    if (runAllSuggestedButton) {
      void executeSuggestedQueries(suggestedEvidenceQueries(getSelectedCase()));
      return;
    }
```

(3e) 케이스 전환 시 요약 초기화 — `state.selectedCaseId = caseId;` 대입이 있는 함수(~line 2130, `rg -n "state.selectedCaseId = caseId" web/operator-gui/app.js`로 전체 대입 위치 확인)마다 대입 직후에 추가:

```js
  suggestedQueryRunSummary = null;
```

(3f) `web/operator-gui/styles.css` 말미에 추가:

```css
.suggested-query-item {
  display: inline-flex;
  gap: 4px;
  align-items: center;
}

.suggested-query-actions {
  margin-top: 8px;
}
```

- [ ] **Step 4: 테스트 통과 확인**

Run: `python -m pytest tests/operator_gui/test_static_workbench.py -v`
Expected: 전체 PASS (신규 테스트 포함, 기존 계약 테스트 무손상)

- [ ] **Step 5: 커밋**

```bash
git add web/operator-gui/app.js web/operator-gui/styles.css tests/operator_gui/test_static_workbench.py
git commit -m "feat: one-click and batch execution for suggested evidence queries"
```

---

### Task 2: F2 — Google 수동 검색 재노출

서버는 `manual_search`/`collect_keyword_candidates`에서 `google_search`를 이미 지원한다. GUI 안전 계약(수동 검색 선택지에서 google_search 제외)을 **의도적으로 개정**한다(설계 승인 2026-06-11). 이미지 업로드 역검색 금지 단언은 유지한다. 서버 변경 없음.

**Files:**
- Modify: `web/operator-gui/app.js:15` (operatorSearchProviders), `renderOperatorSearchProviderOptions` (~line 616)
- Modify: `web/operator-gui/operator-search.js:28-30` (normalizeManualSearchProvider)
- Test: `tests/operator_gui/test_static_workbench.py` (기존 2개 테스트 개정)

- [ ] **Step 1: 계약 테스트 개정 (실패 상태로)**

(1a) `test_safety_rules_are_visible_in_ui_contract`(~line 455)에서 `assert 'option value="google_search"' not in html` 한 줄을 다음으로 교체:

```python
    # 2026-06-12 안전 규칙 개정(설계 승인 2026-06-11): 운영자 수동 검색에
    # 구글 근거 검색(텍스트 쿼리)을 동적 옵션으로 노출한다. 정적 HTML 기본값은
    # 네이버만 유지하고, 이미지 업로드 역검색 금지는 그대로다.
    assert '{ id: "google_search", label: providerLabels.google_search }' in script
```

(1b) `test_google_custom_search_is_not_exposed_as_operator_choice`(~line 604) 전체를 다음으로 교체:

```python
def test_google_custom_search_is_exposed_as_operator_text_query_choice():
    html = _read(INDEX)
    script = _read(APP_JS)
    search = _read(OPERATOR_SEARCH_JS)
    labels = _read(OPERATOR_LABELS_JS)

    # 정적 HTML은 네이버 기본값만 두고 부트스트랩 후 동적으로 채운다.
    assert 'value="google_search"' not in html
    assert '{ id: "google_search", label: providerLabels.google_search }' in script
    assert "구글 근거 검색" in labels
    assert 'provider === "google_search" ? "google_search" : "naver"' in search
    assert "reverse search" not in html.lower()
    assert "operatorSearchProviders" in script
    assert "visibleProviderControls" in script
```

- [ ] **Step 2: 테스트 실패 확인**

Run: `python -m pytest tests/operator_gui/test_static_workbench.py -v -k "safety_rules or google_custom_search"`
Expected: 두 테스트 모두 FAIL

- [ ] **Step 3: 구현**

(3a) `web/operator-gui/app.js:15` 교체:

```js
const operatorSearchProviders = [
  { id: "naver", label: providerLabels.naver },
  { id: "google_search", label: providerLabels.google_search },
];
```

(`retiredProviderIds`는 그대로 둔다 — 큐 화면의 제공자 상태 칩 밀도 유지용이며 안전 규칙이 아니다.)

(3b) `renderOperatorSearchProviderOptions` 전체 교체 — 어댑터 미설정/비활성 제공자는 보이되 비활성 처리:

```js
function renderOperatorSearchProviderOptions() {
  const optionHtml = operatorSearchProviders
    .map((provider) => {
      const runtime = providers.find((item) => item.id === provider.id);
      const unavailable = Boolean(runtime) && !runtime.enabled;
      const label = unavailable ? `${provider.label} (비활성)` : provider.label;
      return `<option value="${escapeHtml(provider.id)}" ${unavailable ? "disabled" : ""}>${escapeHtml(label)}</option>`;
    })
    .join("");

  ["manual-query-provider", "collection-provider"].forEach((elementId) => {
    const select = document.getElementById(elementId);
    if (!select) return;
    const current = select.value;
    select.innerHTML = optionHtml;
    select.value = operatorSearchProviders.some((provider) => provider.id === current) ? current : operatorSearchProviders[0].id;
    if (select.selectedOptions[0] && select.selectedOptions[0].disabled) {
      select.value = operatorSearchProviders[0].id;
    }
  });
}
```

(3c) `web/operator-gui/operator-search.js`의 `normalizeManualSearchProvider` 교체:

```js
  function normalizeManualSearchProvider(provider) {
    return provider === "google_search" ? "google_search" : "naver";
  }
```

(`index.html`은 변경하지 않는다 — 정적 옵션은 네이버 기본값만 두고 부트스트랩 후 동적으로 교체된다.)

- [ ] **Step 4: 테스트 통과 확인**

Run: `python -m pytest tests/operator_gui/test_static_workbench.py -v`
Expected: 전체 PASS. 참고: line 563 부근의 `assert 'option value="google_search"' not in html` 단언이 있는 다른 테스트는 정적 HTML 무변경이므로 그대로 통과한다.

- [ ] **Step 5: 커밋**

```bash
git add web/operator-gui/app.js web/operator-gui/operator-search.js tests/operator_gui/test_static_workbench.py
git commit -m "feat: expose google_search as operator manual text-query provider"
```

---

### Task 3: F5 서버 — KB 편집 / 비활성 / 재활성 엔드포인트

`knowledge_entries` 항목의 별칭·키워드·메모 수정(PATCH), 비활성화, 재활성화(메모 필수)를 추가한다. 라이프사이클 작업은 `entryStatus == "confirmed"` 항목만 허용한다 — watchlist/excluded는 기존 promote/exclude 흐름을 쓴다. 비활성 항목은 `_knowledge_repository()`(sqlite_store.py:2366-2371)가 이미 `active=False`/`excluded`를 건너뛰므로 점수 계산에서 자동 제외된다(신규 로직 불필요).

**Files:**
- Modify: `src/rights_filter/server/sqlite_store.py` (`exclude_watchlist_entry` 메서드 뒤, ~line 1074)
- Modify: `src/rights_filter/server/http_app.py` (do_POST ~line 155, do_PATCH ~line 168)
- Test: `tests/rights_filter/server/test_http_app.py`

- [ ] **Step 1: 실패하는 서버 테스트 작성**

`tests/rights_filter/server/test_http_app.py` 말미에 추가:

```python
def test_knowledge_entry_update_deactivate_reactivate_lifecycle(tmp_path: Path):
    static_dir, image_store, store = _fixtures(tmp_path)
    server = build_server(host="127.0.0.1", port=0, store=store, image_store=image_store, static_dir=static_dir)
    _start(server)
    base = f"http://127.0.0.1:{server.server_port}"

    try:
        _json(
            base + "/api/knowledge/manual",
            method="POST",
            body={"name": "윈터", "type": "public_figure", "aliases": ["에스파 윈터"], "keywords": ["aespa"], "memo": "초상권 주의"},
        )
        entry = next(item for item in store._all("knowledge_entries") if item["name"] == "윈터")
        entry_id = entry["id"]

        updated = _json(
            base + f"/api/knowledge/{entry_id}",
            method="PATCH",
            body={"aliases": "윈터, winter", "keywords": ["aespa", "윈터 화보"], "memo": "수정된 메모"},
        )
        updated_entry = next(item for item in updated["knowledgeEntries"] if item["id"] == entry_id)
        assert updated_entry["aliases"] == ["윈터", "winter"]
        assert updated_entry["keywords"] == ["aespa", "윈터 화보"]
        assert updated_entry["memo"] == "수정된 메모"

        deactivated = _json(base + f"/api/knowledge/{entry_id}/deactivate", method="POST", body={"reason": "중복 항목"})
        deactivated_entry = next(item for item in deactivated["knowledgeEntries"] if item["id"] == entry_id)
        assert deactivated_entry["active"] is False

        with pytest.raises(Exception):
            _json(base + f"/api/knowledge/{entry_id}/reactivate", method="POST", body={"reason": ""})

        reactivated = _json(base + f"/api/knowledge/{entry_id}/reactivate", method="POST", body={"reason": "검토 후 재사용"})
        reactivated_entry = next(item for item in reactivated["knowledgeEntries"] if item["id"] == entry_id)
        assert reactivated_entry["active"] is True

        with pytest.raises(Exception):
            _json(base + f"/api/knowledge/{entry_id}", method="PATCH", body={})

        events = _json(base + "/api/audit-events")
        event_names = [event["event"] for event in events]
        assert "Knowledge entry updated" in event_names
        assert "Knowledge entry deactivated" in event_names
        assert "Knowledge entry reactivated" in event_names
    finally:
        server.shutdown()
```

- [ ] **Step 2: 테스트 실패 확인**

Run: `python -m pytest tests/rights_filter/server/test_http_app.py::test_knowledge_entry_update_deactivate_reactivate_lifecycle -v`
Expected: FAIL — PATCH `/api/knowledge/{id}`가 404(`{"error": "not found"}`)를 반환해 `_json`이 HTTPError를 던진다.

- [ ] **Step 3: 스토어 메서드 구현**

`src/rights_filter/server/sqlite_store.py`의 `exclude_watchlist_entry` 메서드(~line 1074) 바로 뒤에 추가:

```python
    def update_knowledge_entry(self, entry_id: str, payload: dict[str, Any]) -> dict[str, Any]:
        entry = self._get("knowledge_entries", entry_id)
        updates: dict[str, Any] = {}
        if "aliases" in payload:
            updates["aliases"] = _text_list(payload.get("aliases"))
        if "keywords" in payload:
            updates["keywords"] = _text_list(payload.get("keywords"))
        if "memo" in payload:
            updates["memo"] = str(payload.get("memo", "")).strip()
        if not updates:
            raise ValueError("aliases, keywords, memo 중 수정할 값이 필요합니다")

        before = {key: entry.get(key) for key in updates}
        entry.update(updates)
        self._put("knowledge_entries", entry_id, entry)
        self.add_audit_event(
            "rights.ops",
            "Knowledge entry updated",
            str(entry.get("name", entry_id)),
            f"{json.dumps(before, ensure_ascii=False)} -> {json.dumps(updates, ensure_ascii=False)}",
        )
        return self.bootstrap()

    def deactivate_knowledge_entry(self, entry_id: str, reason: str = "") -> dict[str, Any]:
        entry = self._get("knowledge_entries", entry_id)
        if entry.get("entryStatus", "confirmed") != "confirmed":
            raise ValueError("확정 DB 항목만 비활성화할 수 있습니다")
        if not entry.get("active", False):
            raise ValueError("이미 비활성 상태입니다")
        entry["active"] = False
        entry["deactivatedAt"] = _now_label()
        entry["deactivatedBy"] = "rights.ops"
        entry["deactivatedReason"] = reason.strip()
        self._put("knowledge_entries", entry_id, entry)
        self.add_audit_event(
            "rights.ops",
            "Knowledge entry deactivated",
            str(entry.get("name", entry_id)),
            reason.strip() or "운영자 비활성화",
        )
        return self.bootstrap()

    def reactivate_knowledge_entry(self, entry_id: str, reason: str) -> dict[str, Any]:
        if not reason.strip():
            raise ValueError("재활성에는 사유 메모가 필요합니다")
        entry = self._get("knowledge_entries", entry_id)
        if entry.get("entryStatus", "confirmed") != "confirmed":
            raise ValueError("확정 DB 항목만 재활성화할 수 있습니다")
        if entry.get("active", False):
            raise ValueError("이미 활성 상태입니다")
        entry["active"] = True
        entry["reactivatedAt"] = _now_label()
        entry["reactivatedBy"] = "rights.ops"
        entry["reactivatedReason"] = reason.strip()
        self._put("knowledge_entries", entry_id, entry)
        self.add_audit_event(
            "rights.ops",
            "Knowledge entry reactivated",
            str(entry.get("name", entry_id)),
            reason.strip(),
        )
        return self.bootstrap()
```

- [ ] **Step 4: HTTP 라우트 구현**

(4a) `src/rights_filter/server/http_app.py` `do_POST`에서 `elif path == "/api/providers/emergency-disable":` 분기 **앞**에 추가:

```python
                elif path.startswith("/api/knowledge/") and path.endswith("/deactivate"):
                    entry_id = unquote(path.split("/")[3])
                    self._json(store.deactivate_knowledge_entry(entry_id, str(body.get("reason", ""))))
                elif path.startswith("/api/knowledge/") and path.endswith("/reactivate"):
                    entry_id = unquote(path.split("/")[3])
                    self._json(store.reactivate_knowledge_entry(entry_id, str(body.get("reason", ""))))
```

(4b) `do_PATCH`에서 `if path.startswith("/api/providers/"):` 분기의 `else:` **앞**에 추가:

```python
                elif path.startswith("/api/knowledge/"):
                    entry_id = unquote(path.split("/")[3])
                    self._json(store.update_knowledge_entry(entry_id, body))
```

- [ ] **Step 5: 테스트 통과 확인**

Run: `python -m pytest tests/rights_filter/server/test_http_app.py::test_knowledge_entry_update_deactivate_reactivate_lifecycle -v`
Expected: PASS

- [ ] **Step 6: 커밋**

```bash
git add src/rights_filter/server/sqlite_store.py src/rights_filter/server/http_app.py tests/rights_filter/server/test_http_app.py
git commit -m "feat: knowledge entry update/deactivate/reactivate endpoints with audit events"
```

---

### Task 4: F5 GUI — KB 검색 / 필터 / 인라인 편집 / 라이프사이클

"등록된 기준" 탭에 검색·필터를 달고, 항목 인라인 편집과 서버 연동 비활성/재활성을 붙인다. 기존 `data-toggle-kb`(클라이언트 전용 토글 — 새로고침 시 유실)는 제거하고 Task 3의 서버 엔드포인트로 대체한다.

**Files:**
- Modify: `web/operator-gui/index.html` (registered 패널, line 330-337)
- Modify: `web/operator-gui/app.js` (모듈 상단, renderKnowledgeBase ~line 1706, toggleKnowledgeEntry ~line 3138 제거, 클릭 위임 ~line 3467, disable-derived ~line 3393, 이벤트 와이어링)
- Modify: `web/operator-gui/styles.css`
- Test: `tests/operator_gui/test_static_workbench.py`

- [ ] **Step 1: 사전 점검 — 제거 대상 참조 확인**

Run: `rg -n "toggle-kb|toggleKnowledgeEntry" tests web/operator-gui`
Expected: `web/operator-gui/app.js`에서만 검출(테스트에는 없음). 테스트에서 검출되면 해당 단언을 Step 3의 신규 버튼(`data-deactivate-kb`/`data-reactivate-kb`)으로 함께 갱신한다.

- [ ] **Step 2: 실패하는 UI 계약 테스트 작성**

`tests/operator_gui/test_static_workbench.py` 말미에 추가:

```python
def test_registered_knowledge_panel_supports_search_filter_edit_and_lifecycle():
    html = _read(INDEX)
    script = _read(APP_JS)

    registered_panel = html.split('data-knowledge-panel="registered"', 1)[1].split('data-knowledge-panel="manual"', 1)[0]
    assert 'id="knowledge-search"' in registered_panel
    assert 'id="knowledge-type-filter"' in registered_panel
    assert 'id="knowledge-status-filter"' in registered_panel
    assert 'id="knowledge-active-filter"' in registered_panel

    assert "filteredKnowledgeEntries" in script
    assert "data-edit-kb" in script
    assert "data-knowledge-edit-form" in script
    assert "saveKnowledgeEntryEdit" in script
    assert "data-deactivate-kb" in script
    assert "data-reactivate-kb" in script
    assert "재활성 사유 메모" in script
    assert "data-toggle-kb" not in script
```

Run: `python -m pytest tests/operator_gui/test_static_workbench.py::test_registered_knowledge_panel_supports_search_filter_edit_and_lifecycle -v`
Expected: FAIL

- [ ] **Step 3: index.html — registered 패널 교체**

line 330-337의 registered 패널을 다음으로 교체:

```html
            <section class="knowledge-panel" data-knowledge-panel="registered" hidden>
              <section class="pane">
                <div class="pane-heading">
                  <h2>등록된 기준</h2>
                </div>
                <div class="knowledge-filter-bar">
                  <label for="knowledge-search">
                    <span>검색</span>
                    <input id="knowledge-search" type="search" autocomplete="off" placeholder="이름, 별칭, 키워드">
                  </label>
                  <label for="knowledge-type-filter">
                    <span>유형</span>
                    <select id="knowledge-type-filter">
                      <option value="all">전체</option>
                      <option value="public_figure">연예인/유명인</option>
                      <option value="work">작품</option>
                      <option value="character">캐릭터</option>
                      <option value="game">게임</option>
                      <option value="rejected_image">반려 이미지</option>
                    </select>
                  </label>
                  <label for="knowledge-status-filter">
                    <span>상태</span>
                    <select id="knowledge-status-filter">
                      <option value="all">전체</option>
                      <option value="confirmed">확정 DB</option>
                      <option value="watchlist">주의 후보</option>
                      <option value="excluded">제외됨</option>
                    </select>
                  </label>
                  <label for="knowledge-active-filter">
                    <span>활성</span>
                    <select id="knowledge-active-filter">
                      <option value="all">전체</option>
                      <option value="active">활성</option>
                      <option value="inactive">비활성</option>
                    </select>
                  </label>
                </div>
                <div id="knowledge-list" class="stack-list"></div>
              </section>
            </section>
```

- [ ] **Step 4: app.js 구현**

(4a) 모듈 상단(Task 1의 `suggestedQueryRunSummary` 선언 아래)에 추가:

```js
const knowledgeFilters = { query: "", type: "all", status: "all", active: "all" };
let editingKnowledgeEntryId = "";
```

(4b) `renderKnowledgeBase` 위에 필터 함수 추가:

```js
function filteredKnowledgeEntries() {
  const query = knowledgeFilters.query.trim().toLowerCase();
  return knowledgeEntries.filter((entry) => {
    const typeOk = knowledgeFilters.type === "all" || entry.type === knowledgeFilters.type;
    const statusOk = knowledgeFilters.status === "all" || (entry.entryStatus || "confirmed") === knowledgeFilters.status;
    const activeOk = knowledgeFilters.active === "all" || (knowledgeFilters.active === "active") === Boolean(entry.active);
    const haystack = [entry.name, ...(entry.aliases || []), ...(entry.keywords || [])].join(" ").toLowerCase();
    const queryOk = !query || haystack.includes(query);
    return typeOk && statusOk && activeOk && queryOk;
  });
}
```

(4c) `renderKnowledgeBase`를 다음으로 교체 (행 템플릿의 썸네일/칩/메타 부분은 기존과 동일하며, 목록 소스·액션·편집 폼만 다르다):

```js
function renderKnowledgeBase() {
  const entries = filteredKnowledgeEntries();
  document.getElementById("knowledge-list").innerHTML = entries.length
    ? entries
        .map((entry) => {
          const aliases = entry.aliases || [];
          const keywords = entry.keywords || [];
          const entryStatus = entry.entryStatus || "confirmed";
          const statusMeta =
            entryStatus === "watchlist"
              ? `<span>원 케이스: ${escapeHtml(entry.sourceSubmissionId || "-")}</span><span>미래 검출 ${escapeHtml(entry.contributionCount || 0)}건</span>`
              : "";
          const memoInline = entry.memo && entry.memo.startsWith("외부 후보 수집에서 반영:") ? `<span>${escapeHtml(entry.memo)}</span>` : "";
          const memoBlock = memoInline ? "" : `<p class="muted small">${escapeHtml(entry.memo)}</p>`;
          const lifecycleActions =
            entryStatus === "watchlist"
              ? `
                  <button class="row-action" type="button" data-promote-watchlist="${escapeHtml(entry.id)}">확정 DB 반영</button>
                  <button class="row-action danger" type="button" data-exclude-watchlist="${escapeHtml(entry.id)}">오탐 제외</button>
                `
              : entryStatus === "excluded"
                ? ""
                : entry.active
                  ? `<button class="row-action danger" type="button" data-deactivate-kb="${escapeHtml(entry.id)}">비활성</button>`
                  : `<button class="row-action" type="button" data-reactivate-kb="${escapeHtml(entry.id)}">재활성</button>`;
          const editForm =
            editingKnowledgeEntryId === entry.id
              ? `
                  <form class="knowledge-edit-form" data-knowledge-edit-form="${escapeHtml(entry.id)}">
                    <label>
                      <span>별칭</span>
                      <input name="aliases" type="text" value="${escapeHtml(aliases.join(", "))}">
                    </label>
                    <label>
                      <span>검색 키워드</span>
                      <input name="keywords" type="text" value="${escapeHtml(keywords.join(", "))}">
                    </label>
                    <label class="wide-field">
                      <span>정책 메모</span>
                      <textarea name="memo" rows="3">${escapeHtml(entry.memo || "")}</textarea>
                    </label>
                    <div class="knowledge-edit-actions">
                      <button class="primary-action" type="submit">저장</button>
                      <button class="secondary-action" type="button" data-cancel-edit-kb="${escapeHtml(entry.id)}">취소</button>
                    </div>
                  </form>
                `
              : "";
          return `
            <article class="knowledge-row ${entry.active ? "" : "inactive"} ${entryStatus === "watchlist" ? "watchlist" : ""}">
              ${
                entry.imageAsset
                  ? `<img class="knowledge-thumb" src="${escapeHtml(entry.imageAsset)}" alt="${escapeHtml(entry.name)} 참조 이미지">`
                  : `<div class="knowledge-thumb empty" aria-hidden="true"></div>`
              }
              <div class="knowledge-main">
                <div class="row-title knowledge-title">
                  <span>${escapeHtml(entry.name)}</span>
                </div>
                <div class="knowledge-detail-line">
                  <div class="knowledge-chip-row">
                    <span class="provenance-chip ${escapeHtml(entry.provenance)}">${escapeHtml(formatProvenance(entry.provenance))}</span>
                    <span class="watchlist-chip ${escapeHtml(entryStatus)}">${escapeHtml(formatKnowledgeStatus(entryStatus))}</span>
                  </div>
                  <div class="row-meta knowledge-meta">
                    <span>${escapeHtml(formatKnowledgeType(entry.type))}</span>
                    <span>별칭: ${escapeHtml(aliases.join(", ") || "-")}</span>
                    <span>키워드: ${escapeHtml(keywords.join(", ") || "-")}</span>
                    <span>샘플 지문 ${(entry.sampleFingerprints || []).length}</span>
                    ${statusMeta}
                    ${memoInline}
                  </div>
                </div>
                ${memoBlock}
                ${editForm}
              </div>
              <div class="knowledge-actions">
                <button class="row-action" type="button" data-edit-kb="${escapeHtml(entry.id)}">편집</button>
                ${lifecycleActions}
              </div>
            </article>
          `;
        })
        .join("")
    : `<div class="empty-state">조건에 맞는 기준 항목이 없습니다.</div>`;
  renderCollectionCandidates();
}
```

(4d) `toggleKnowledgeEntry` 함수(~line 3138, 클라이언트 전용 토글)를 **삭제**하고 그 자리에 추가:

```js
async function saveKnowledgeEntryEdit(form) {
  const entryId = form.dataset.knowledgeEditForm;
  const body = {
    aliases: form.elements.aliases.value.split(",").map((item) => item.trim()).filter(Boolean),
    keywords: form.elements.keywords.value.split(",").map((item) => item.trim()).filter(Boolean),
    memo: form.elements.memo.value.trim(),
  };
  try {
    const payload = await apiJson(`/api/knowledge/${encodeURIComponent(entryId)}`, {
      method: "PATCH",
      body: JSON.stringify(body),
    });
    editingKnowledgeEntryId = "";
    applyBootstrap(payload);
    renderAll();
  } catch (errorValue) {
    showApiError(errorValue.message);
  }
}

async function deactivateKnowledgeEntry(entryId) {
  try {
    const payload = await apiJson(`/api/knowledge/${encodeURIComponent(entryId)}/deactivate`, {
      method: "POST",
      body: JSON.stringify({ reason: "" }),
    });
    applyBootstrap(payload);
    renderAll();
  } catch (errorValue) {
    showApiError(errorValue.message);
  }
}

async function reactivateKnowledgeEntry(entryId) {
  const reason = window.prompt("재활성 사유 메모(필수)") || "";
  if (!reason.trim()) {
    showApiError("재활성에는 사유 메모가 필요합니다.");
    return;
  }
  try {
    const payload = await apiJson(`/api/knowledge/${encodeURIComponent(entryId)}/reactivate`, {
      method: "POST",
      body: JSON.stringify({ reason: reason.trim() }),
    });
    applyBootstrap(payload);
    renderAll();
  } catch (errorValue) {
    showApiError(errorValue.message);
  }
}
```

(4e) 클릭 위임부의 `data-toggle-kb` 분기(~line 3467)를 다음으로 교체:

```js
    const editKnowledgeButton = event.target.closest("[data-edit-kb]");
    if (editKnowledgeButton) {
      editingKnowledgeEntryId = editingKnowledgeEntryId === editKnowledgeButton.dataset.editKb ? "" : editKnowledgeButton.dataset.editKb;
      renderKnowledgeBase();
      return;
    }

    const cancelEditKnowledgeButton = event.target.closest("[data-cancel-edit-kb]");
    if (cancelEditKnowledgeButton) {
      editingKnowledgeEntryId = "";
      renderKnowledgeBase();
      return;
    }

    const deactivateKnowledgeButton = event.target.closest("[data-deactivate-kb]");
    if (deactivateKnowledgeButton) {
      void deactivateKnowledgeEntry(deactivateKnowledgeButton.dataset.deactivateKb);
      return;
    }

    const reactivateKnowledgeButton = event.target.closest("[data-reactivate-kb]");
    if (reactivateKnowledgeButton) {
      void reactivateKnowledgeEntry(reactivateKnowledgeButton.dataset.reactivateKb);
      return;
    }
```

(4f) `disable-derived` 핸들러(~line 3393)를 다음으로 교체:

```js
  document.getElementById("disable-derived").addEventListener("click", () => {
    const automaticEntry = knowledgeEntries.find(
      (entry) => entry.provenance === "automatic" && entry.active && (entry.entryStatus || "confirmed") === "confirmed",
    );
    if (automaticEntry) void deactivateKnowledgeEntry(automaticEntry.id);
  });
```

(4g) 이벤트 와이어링부(`document.getElementById("knowledge-form").addEventListener(...)` 부근, ~line 3380)에 추가:

```js
  document.getElementById("knowledge-search").addEventListener("input", (event) => {
    knowledgeFilters.query = event.target.value;
    renderKnowledgeBase();
  });
  [
    ["knowledge-type-filter", "type"],
    ["knowledge-status-filter", "status"],
    ["knowledge-active-filter", "active"],
  ].forEach(([elementId, key]) => {
    document.getElementById(elementId).addEventListener("change", (event) => {
      knowledgeFilters[key] = event.target.value;
      renderKnowledgeBase();
    });
  });
  document.addEventListener("submit", (event) => {
    const editFormElement = event.target.closest("[data-knowledge-edit-form]");
    if (!editFormElement) return;
    event.preventDefault();
    void saveKnowledgeEntryEdit(editFormElement);
  });
```

(4h) `styles.css` 말미에 추가:

```css
.knowledge-filter-bar {
  display: flex;
  flex-wrap: wrap;
  gap: 8px 12px;
  margin-bottom: 12px;
}

.knowledge-edit-form {
  display: grid;
  gap: 8px;
  margin-top: 8px;
  padding: 10px;
  border: 1px solid #d4d4d8;
  border-radius: 8px;
}

.knowledge-edit-actions {
  display: flex;
  gap: 8px;
}
```

- [ ] **Step 5: 테스트 통과 확인**

Run: `python -m pytest tests/operator_gui/ -v`
Expected: 전체 PASS

- [ ] **Step 6: 커밋**

```bash
git add web/operator-gui/index.html web/operator-gui/app.js web/operator-gui/styles.css tests/operator_gui/test_static_workbench.py
git commit -m "feat: knowledge base search/filter, inline edit, and server-backed lifecycle actions"
```

---

### Task 5: F3 — 얼굴 크롭 썸네일 (서버 + GUI)

분석 시 감지된 얼굴 박스로 크롭을 디스크에 저장하고(`<db dir>/face-crops/{submission_id}/crop-N.jpg`), `/face-crop-media/` 라우트로 서빙하며, submission 페이로드에 `faceCrops`를 싣는다. Google 얼굴 크롭 웹 탐지는 저장된 박스를 재사용한다(중복 감지 제거). 워크벤치 이미지 패널에 크롭 스트립을 표시한다.

**Files:**
- Modify: `src/rights_filter/server/sqlite_store.py` (`__init__` ~line 404, `collected_media_path` 뒤 ~line 1710, `_refresh_existing_local_face_evidence` 뒤 ~line 1830, `seed_from_image_store` ~line 677/732, `_rerun_internal_analysis` ~line 1872, `_google_face_crop_web_detection` ~line 1938)
- Modify: `src/rights_filter/server/http_app.py` (do_GET, `/collected-media/` 분기 뒤)
- Modify: `web/operator-gui/index.html` (~line 237), `web/operator-gui/app.js` (renderCaseReview/renderNoSelectedCase), `web/operator-gui/styles.css`
- Test: `tests/rights_filter/server/test_http_app.py`, `tests/operator_gui/test_static_workbench.py`

- [ ] **Step 1: 실패하는 서버 테스트 작성**

`tests/rights_filter/server/test_http_app.py` 말미에 추가 (`OneFaceBoxDetector`는 기존 `OneFaceDetector` 클래스 아래에 정의):

```python
class OneFaceBoxDetector:
    def detect(self, image):
        return FacePersonSignal(face_count=1, person_count=1, face_boxes=((40, 40, 120, 120),))


def test_face_crops_are_persisted_served_and_listed_in_review(tmp_path: Path, monkeypatch):
    monkeypatch.setattr(sqlite_store_module, "HeuristicFacePersonDetector", lambda: OneFaceBoxDetector())
    static_dir, image_store, store = _png_fixtures(tmp_path)
    server = build_server(host="127.0.0.1", port=0, store=store, image_store=image_store, static_dir=static_dir)
    _start(server)
    base = f"http://127.0.0.1:{server.server_port}"

    try:
        review = _json(base + "/api/submissions/SUB-API1/review")
        assert review["faceCrops"], "face crops should be listed for a face submission"
        crop = review["faceCrops"][0]
        assert crop["index"] == 1
        assert crop["box"] == [40, 40, 120, 120]
        assert crop["url"].startswith("/face-crop-media/SUB-API1/")

        with urlopen(base + crop["url"], timeout=5) as response:
            content = response.read()
        assert content[:3] == b"\xff\xd8\xff"  # JPEG magic bytes
    finally:
        server.shutdown()


def test_face_crops_are_empty_for_undetectable_images(tmp_path: Path):
    # autouse OneFaceDetector는 face_boxes를 반환하지 않고, SVG는 PIL로 크롭할 수 없다.
    static_dir, image_store, store = _fixtures(tmp_path)
    server = build_server(host="127.0.0.1", port=0, store=store, image_store=image_store, static_dir=static_dir)
    _start(server)
    base = f"http://127.0.0.1:{server.server_port}"

    try:
        review = _json(base + "/api/submissions/SUB-API1/review")
        assert review.get("faceCrops", []) == []
    finally:
        server.shutdown()
```

Run: `python -m pytest tests/rights_filter/server/test_http_app.py -v -k face_crops`
Expected: 첫 테스트 FAIL (`KeyError: 'faceCrops'`), 둘째 테스트는 `review.get` 폴백으로 PASS할 수 있음 — 첫 테스트 FAIL 확인이 핵심.

- [ ] **Step 2: 스토어 구현**

(2a) `__init__`의 `self.collection_public_prefix = ...` (line ~404) 아래에 추가:

```python
        self.face_crop_image_dir = self.db_path.parent / "face-crops"
        self.face_crop_public_prefix = "/face-crop-media"
```

(2b) `collected_media_path` 메서드(~line 1709) 뒤에 추가:

```python
    def face_crop_media_path(self, relative_path: str) -> Path:
        root = self.face_crop_image_dir.resolve()
        path = (root / relative_path.lstrip("/")).resolve()
        if path != root and root not in path.parents:
            raise ValueError("face crop media path points outside image store")
        return path
```

(2c) `_refresh_existing_local_face_evidence` 메서드 뒤(~line 1830)에 추가:

```python
    def _sync_face_crops(
        self,
        submission_id: str,
        image_store: LocalSubmissionImageStore | None,
    ) -> None:
        if image_store is None:
            return
        try:
            original = image_store.image_payload(submission_id)
        except Exception:
            return

        signal = HeuristicFacePersonDetector().detect(original)
        crop_dir = self.face_crop_image_dir / submission_id
        if crop_dir.exists():
            for stale in crop_dir.glob("crop-*.jpg"):
                stale.unlink()

        face_crops: list[dict[str, Any]] = []
        for index, box in enumerate(signal.face_boxes[:3], start=1):
            crops = build_face_crop_derivatives(original, [box])
            if not crops:
                continue
            crop_dir.mkdir(parents=True, exist_ok=True)
            crop_path = crop_dir / f"crop-{index}.jpg"
            crop_path.write_bytes(crops[0].content)
            face_crops.append(
                {
                    "index": index,
                    "url": f"{self.face_crop_public_prefix}/{submission_id}/crop-{index}.jpg",
                    "box": [int(value) for value in box],
                }
            )

        submission = self._get("submissions", submission_id)
        submission["faceCrops"] = face_crops
        self._put("submissions", submission_id, submission)
```

(`build_face_crop_derivatives`와 `HeuristicFacePersonDetector`는 sqlite_store.py에 이미 import되어 있다. 박스별로 1개씩 크롭을 만들어 실패한 박스를 건너뛰어도 index-박스 대응이 어긋나지 않게 한다.)

(2d) `seed_from_image_store`: `self._refresh_existing_local_face_evidence(...)` 호출(~line 677) 아래에 기존 제출 백필 추가:

```python
        for submission in self._all("submissions", queue_id=queue_id):
            if "faceCrops" not in submission:
                self._sync_face_crops(str(submission["id"]), image_store)
```

그리고 신규 레코드 루프 안의 `self._sync_search_result_image_similarity(record["id"], run.evidence, image_store)` (~line 732) 아래에 추가:

```python
            self._sync_face_crops(record["id"], image_store)
```

(2e) `_rerun_internal_analysis`: `self._rescore_submission(submission_id)` (~line 1872) 아래, `return domain_evidence` 앞에 추가:

```python
        self._sync_face_crops(submission_id, image_store)
```

(2f) `_google_face_crop_web_detection`(~line 1938)에서 다음 3줄을:

```python
        signal = HeuristicFacePersonDetector().detect(original_image)
        if not signal.face_boxes:
            return [], 0

        crops = build_face_crop_derivatives(original_image, signal.face_boxes)
```

다음으로 교체 (저장된 감지 결과 재사용 — 스펙의 "크롭 생성 일원화"):

```python
        submission = self._get("submissions", submission_id)
        stored_crops = submission.get("faceCrops")
        if stored_crops is None:
            signal = HeuristicFacePersonDetector().detect(original_image)
            face_boxes: tuple = signal.face_boxes
        else:
            face_boxes = tuple(
                tuple(int(value) for value in item.get("box", []))
                for item in stored_crops
                if len(item.get("box", [])) == 4
            )
        if not face_boxes:
            return [], 0

        crops = build_face_crop_derivatives(original_image, face_boxes)
```

(2g) 거버넌스(스펙 R26): 제출 레코드가 정리될 때 크롭 파일도 함께 삭제한다. `_prune_missing_submission_files`(~line 757)의 `conn.executemany(...)` 블록 뒤, audit 루프 앞에 추가:

```python
        for submission_id in missing_ids:
            crop_dir = self.face_crop_image_dir / submission_id
            if crop_dir.exists():
                shutil.rmtree(crop_dir, ignore_errors=True)
```

파일 상단 import 블록에 `import shutil`이 없으면 추가한다(`rg -n "^import shutil" src/rights_filter/server/sqlite_store.py`로 확인).

- [ ] **Step 3: HTTP 라우트 추가**

`src/rights_filter/server/http_app.py` `do_GET`의 `/collected-media/` 분기 뒤에 추가:

```python
                elif path.startswith("/face-crop-media/"):
                    self._file(store.face_crop_media_path(unquote(path.removeprefix("/face-crop-media/"))), untrusted=True)
```

- [ ] **Step 4: 서버 테스트 통과 확인**

Run: `python -m pytest tests/rights_filter/server/test_http_app.py -v`
Expected: 전체 PASS (기존 테스트 포함 — autouse `OneFaceDetector`는 `face_boxes=()`라 기존 테스트의 `faceCrops`는 빈 배열로 채워질 뿐 다른 동작 변화 없음)

- [ ] **Step 5: 실패하는 GUI 계약 테스트 작성**

`tests/operator_gui/test_static_workbench.py` 말미에 추가:

```python
def test_workbench_shows_detected_face_crop_strip():
    html = _read(INDEX)
    script = _read(APP_JS)

    assert 'id="face-crop-strip"' in html
    assert "faceCrops" in script
    assert "얼굴 영역" in script
    assert "동일 인물 판정 아님" in script
```

Run: `python -m pytest tests/operator_gui/test_static_workbench.py::test_workbench_shows_detected_face_crop_strip -v`
Expected: FAIL

- [ ] **Step 6: GUI 구현**

(6a) `index.html` line ~237의 `<div class="similar-strip" id="similar-strip" ...></div>` 아래에 추가:

```html
                <div class="similar-strip face-crop-strip" id="face-crop-strip" aria-label="감지된 얼굴 영역"></div>
```

(6b) `app.js` `renderCaseReview`의 similar-strip 렌더 블록(~line 1245-1263) 아래에 추가:

```js
  document.getElementById("face-crop-strip").innerHTML = (submission.faceCrops || [])
    .map(
      (crop) => `
        <div class="similar-item face-crop-item">
          <img src="${escapeHtml(crop.url)}" alt="얼굴 영역 ${escapeHtml(String(crop.index))} 크롭">
          <span>얼굴 영역 ${escapeHtml(String(crop.index))} · 동일 인물 판정 아님</span>
        </div>
      `,
    )
    .join("");
```

(6c) `renderNoSelectedCase`(~line 1201, `similar-strip` 초기화 줄 아래)에 추가:

```js
  document.getElementById("face-crop-strip").innerHTML = "";
```

(6d) `styles.css` 말미에 추가:

```css
.face-crop-strip .face-crop-item img {
  border: 1px solid #d4d4d8;
  border-radius: 6px;
}
```

- [ ] **Step 7: 전체 테스트 통과 확인**

Run: `python -m pytest tests/operator_gui/test_static_workbench.py tests/rights_filter/server/test_http_app.py -v`
Expected: 전체 PASS

- [ ] **Step 8: 커밋**

```bash
git add src/rights_filter/server/sqlite_store.py src/rights_filter/server/http_app.py web/operator-gui/index.html web/operator-gui/app.js web/operator-gui/styles.css tests/rights_filter/server/test_http_app.py tests/operator_gui/test_static_workbench.py
git commit -m "feat: persist and display detected face crop thumbnails in workbench"
```

---

### Task 6: F4 — 재분석 증거 diff

`rerun_enrichment`가 실행 전 증거 ID·점수를 스냅샷하고, 완료 후 `lastRerunDiff`를 submission JSON 페이로드에 저장한다. GUI는 점수 변화·신규 배지·제거 요약을 표시한다. 재분석 마커 증거(`ev-{id}-rerun-*`)는 diff에서 제외한다.

**Files:**
- Modify: `src/rights_filter/server/sqlite_store.py` (`rerun_enrichment`, line 1140-1179)
- Modify: `web/operator-gui/index.html` (evidence-pane, ~line 244), `web/operator-gui/app.js`, `web/operator-gui/styles.css`
- Test: `tests/rights_filter/server/test_http_app.py`, `tests/operator_gui/test_static_workbench.py`

- [ ] **Step 1: 실패하는 서버 테스트 작성**

`tests/rights_filter/server/test_http_app.py` 말미에 추가:

```python
def test_rerun_enrichment_records_evidence_diff(tmp_path: Path):
    static_dir, image_store, store = _fixtures(tmp_path)
    server = build_server(host="127.0.0.1", port=0, store=store, image_store=image_store, static_dir=static_dir)
    _start(server)
    base = f"http://127.0.0.1:{server.server_port}"

    try:
        initial = _json(base + "/api/submissions/SUB-API1/review")
        assert "lastRerunDiff" not in initial

        rerun = _json(base + "/api/submissions/SUB-API1/rerun-enrichment", method="POST", body={})
        diff = rerun["lastRerunDiff"]
        assert isinstance(diff["scoreBefore"], int)
        assert isinstance(diff["scoreAfter"], int)
        assert isinstance(diff["addedEvidenceIds"], list)
        assert isinstance(diff["removedEvidenceIds"], list)
        assert isinstance(diff["removedSummaries"], list)
        assert diff["at"]
        marker_prefix = "ev-SUB-API1-rerun-"
        assert all(not evidence_id.startswith(marker_prefix) for evidence_id in diff["addedEvidenceIds"])
    finally:
        server.shutdown()
```

Run: `python -m pytest tests/rights_filter/server/test_http_app.py::test_rerun_enrichment_records_evidence_diff -v`
Expected: FAIL (`KeyError: 'lastRerunDiff'`)

- [ ] **Step 2: 서버 구현**

(2a) `rerun_enrichment`에서 `submission = self._get("submissions", submission_id)` (line 1145) 바로 아래에 추가:

```python
        score_before = int(submission.get("riskScore", 0) or 0)
        evidence_before = {
            str(item.get("id", "")): item
            for item in self._evidence_by_submission().get(submission_id, [])
        }
```

(2b) 같은 메서드 끝의 `return self.review(submission_id)` (line 1179) 를 다음으로 교체:

```python
        evidence_after = {
            str(item.get("id", "")): item
            for item in self._evidence_for_submission(submission_id)
        }
        rerun_marker_prefix = f"ev-{submission_id}-rerun-"
        added_ids = [
            evidence_id
            for evidence_id in evidence_after
            if evidence_id not in evidence_before and not evidence_id.startswith(rerun_marker_prefix)
        ]
        removed_items = [
            evidence_before[evidence_id]
            for evidence_id in evidence_before
            if evidence_id not in evidence_after
        ]
        refreshed = self._get("submissions", submission_id)
        refreshed["lastRerunDiff"] = {
            "at": _now_label(),
            "scoreBefore": score_before,
            "scoreAfter": int(refreshed.get("riskScore", 0) or 0),
            "addedEvidenceIds": added_ids,
            "removedEvidenceIds": [str(item.get("id", "")) for item in removed_items],
            "removedSummaries": [
                {"source": str(item.get("source", "")), "title": str(item.get("title", ""))}
                for item in removed_items
            ],
        }
        self._put("submissions", submission_id, refreshed)
        return self.review(submission_id)
```

- [ ] **Step 3: 서버 테스트 통과 확인**

Run: `python -m pytest tests/rights_filter/server/test_http_app.py -v`
Expected: 전체 PASS

- [ ] **Step 4: 실패하는 GUI 계약 테스트 작성**

`tests/operator_gui/test_static_workbench.py` 말미에 추가:

```python
def test_rerun_diff_summary_and_new_evidence_badges_are_rendered():
    html = _read(INDEX)
    script = _read(APP_JS)
    styles = _read(STYLES)

    assert 'id="rerun-diff-summary"' in html
    assert "renderRerunDiffSummary" in script
    assert "lastRerunDiff" in script
    assert "evidence-new-chip" in script
    assert "이번 재분석에서 제거됨" in script
    assert ".evidence-new-chip" in styles
    assert ".evidence-row-new" in styles
```

Run: `python -m pytest tests/operator_gui/test_static_workbench.py::test_rerun_diff_summary_and_new_evidence_badges_are_rendered -v`
Expected: FAIL

- [ ] **Step 5: GUI 구현**

(5a) `index.html` evidence-pane의 `<div id="case-reasons" class="reason-list"></div>` (~line 245) 바로 위에 추가:

```html
                <div id="rerun-diff-summary" class="rerun-diff-summary"></div>
```

(5b) `app.js` 모듈 상단(Task 4의 `editingKnowledgeEntryId` 아래)에 추가:

```js
let activeRerunAddedIds = new Set(); // 현재 렌더 중인 케이스의 lastRerunDiff.addedEvidenceIds
```

(5c) `renderCaseReview`에서 `document.getElementById("case-reasons").innerHTML = ...` 줄 **앞**에 추가:

```js
  activeRerunAddedIds = new Set(submission.lastRerunDiff?.addedEvidenceIds || []);
  document.getElementById("rerun-diff-summary").innerHTML = submission.lastRerunDiff
    ? renderRerunDiffSummary(submission.lastRerunDiff)
    : "";
```

(5d) `renderEvidenceSearch`에서 `results.innerHTML = ...` 줄 **앞**에 추가:

```js
  activeRerunAddedIds = new Set(submission.lastRerunDiff?.addedEvidenceIds || []);
```

(5e) `renderNoSelectedCase`에 추가:

```js
  activeRerunAddedIds = new Set();
  document.getElementById("rerun-diff-summary").innerHTML = "";
```

(5f) `renderEvidenceRow`에서 `const sourceEvidenceIds = ...` 줄 앞에 추가:

```js
  const isNewFromRerun = activeRerunAddedIds.has(evidence.id);
  const newChip = isNewFromRerun ? `<span class="evidence-new-chip">신규</span>` : "";
```

그리고 같은 함수의 반환 템플릿에서 두 곳 수정:
- `<article class="evidence-row ${hasPreview ? "" : "no-preview"}"` → `<article class="evidence-row ${hasPreview ? "" : "no-preview"} ${isNewFromRerun ? "evidence-row-new" : ""}"`
- `evidence-title` div 안에서 `<span class="source-chip ...>...</span>` 바로 뒤에 `${newChip}` 삽입

(5g) `renderRerunDiffSummary` 함수를 `renderEvidenceSummary` 함수 앞에 추가:

```js
function renderRerunDiffSummary(diff) {
  const scoreBefore = Number(diff.scoreBefore || 0);
  const scoreAfter = Number(diff.scoreAfter || 0);
  const delta = scoreAfter - scoreBefore;
  const direction = delta > 0 ? `상승 ${delta}` : delta < 0 ? `하락 ${Math.abs(delta)}` : "변동 없음";
  const removedSummaries = diff.removedSummaries || [];
  const removedBlock = removedSummaries.length
    ? `
      <details class="rerun-removed">
        <summary>이번 재분석에서 제거됨 · ${removedSummaries.length}개</summary>
        <ul>
          ${removedSummaries
            .map((item) => `<li>${escapeHtml(sourceLabels[item.source] || item.source || "내부")} · ${escapeHtml(formatReason(item.title || ""))}</li>`)
            .join("")}
        </ul>
      </details>
    `
    : "";
  return `
    <section class="rerun-diff-panel" aria-label="재분석 변경 요약">
      <strong>재분석 ${escapeHtml(diff.at || "")}</strong>
      <span>점수 ${escapeHtml(String(scoreBefore))} → ${escapeHtml(String(scoreAfter))} (${escapeHtml(direction)})</span>
      <span>신규 증거 ${(diff.addedEvidenceIds || []).length}개</span>
      ${removedBlock}
    </section>
  `;
}
```

(점수 변화 방향은 색이 아니라 "상승/하락" 텍스트로 표기 — 기존 접근성 규칙 준수.)

(5h) `styles.css` 말미에 추가:

```css
.rerun-diff-panel {
  display: flex;
  flex-wrap: wrap;
  gap: 8px 16px;
  align-items: center;
  padding: 10px 12px;
  border: 1px solid #d4d4d8;
  border-radius: 8px;
  margin-bottom: 12px;
}

.evidence-new-chip {
  border: 1px solid #1d4ed8;
  border-radius: 999px;
  padding: 0 8px;
  font-size: 12px;
  color: #1d4ed8;
}

.evidence-row-new {
  box-shadow: inset 0 0 0 2px #1d4ed8;
}
```

- [ ] **Step 6: 전체 테스트 통과 확인**

Run: `python -m pytest tests/operator_gui/test_static_workbench.py tests/rights_filter/server/test_http_app.py -v`
Expected: 전체 PASS

- [ ] **Step 7: 커밋**

```bash
git add src/rights_filter/server/sqlite_store.py web/operator-gui/index.html web/operator-gui/app.js web/operator-gui/styles.css tests/rights_filter/server/test_http_app.py tests/operator_gui/test_static_workbench.py
git commit -m "feat: rerun enrichment evidence diff with score delta and new-evidence badges"
```

---

### Task 7: 전체 회귀 검증

- [ ] **Step 1: 전체 테스트 실행**

Run: `python -m pytest tests/ -v`
Expected: 전체 PASS (기준선 359개 + 신규 ~7개). 실패 시 실패한 테스트의 단언과 구현을 대조해 수정한다 — 테스트가 옛 계약을 검사하는 경우(예: Task 2의 안전 계약처럼 의도적으로 개정된 것)만 테스트를 고치고, 그 외에는 구현을 고친다.

- [ ] **Step 2: 서버 기동 스모크**

Run: `python run_copyrighter_server.py` 백그라운드 기동 후 `Invoke-WebRequest http://127.0.0.1:<포트>/health` 로 `{"status": "ok"}` 확인, 종료.
(포트는 run_copyrighter_server.py 출력 참조. 자동화 어려우면 생략 가능 — 테스트가 build_server 경로를 이미 커버한다.)

- [ ] **Step 3: 미커밋 변경 확인 및 마무리 커밋**

```bash
git status
git add -A
git commit -m "test: full regression pass for workbench efficiency round"
```

(미커밋 변경이 없으면 마무리 커밋은 생략한다.)
