@dssp/dcsp 1.0.2 → 1.0.6

package/python/inspection_ai_engine_handoff/engine.py

@@ -0,0 +1,333 @@
+"""검사 오케스트레이션 엔진.
+
+핵심 함수:
+  - inspect_one(item, decision, images, client) : 1개 항목 실행
+  - inspect_all(checklist, images, client=None) : 전체 실행
+  - build_summary_markdown(result_dict)         : 결과 → 마크다운
+"""
+from __future__ import annotations
+
+import json
+import time
+import traceback
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Callable, List, Optional, Sequence
+
+from PIL import Image
+
+# 비용 추적 (선택). 배포본에 cost_tracker.py 가 없어도 동작하도록 no-op 대체.
+try:
+    import cost_tracker
+except ImportError:
+    class _NoCost:
+        @staticmethod
+        def record(*a, **k): pass
+        @staticmethod
+        def reset(*a, **k): pass
+        @staticmethod
+        def drain(*a, **k): return []
+        @staticmethod
+        def snapshot(*a, **k): return None
+        @staticmethod
+        def snapshot_from(*a, **k): return None
+    cost_tracker = _NoCost()
+
+from checklist import CHECKLIST_VERSION, validate_checklist
+from cv_handlers import CVResult
+from cv_model_registry import list_models, resolve_handler
+from router import RouteDecision, decision_to_dict, route_all
+from vlm import VLMResult, vqa_judge
+
+
+_VERDICT_ORDER = {"fail": 0, "hold": 1, "pass": 2, "pending": 3, "error": 4}
+
+# 감리자용 한글 라벨 (JSON 기계값 pass/fail/... 은 그대로 두고, 화면 표시만 한글)
+_VERDICT_BADGE = {
+    "pass":    "🟢 적합",
+    "fail":    "🔴 부적합",
+    "hold":    "🟡 보류 (추가 확인 필요)",
+    "pending": "⏳ AI 미지원 (수동 확인)",
+    "error":   "❌ 분석 오류",
+}
+
+# 짧은 한글 라벨 (요약 카운트용)
+_VERDICT_SHORT = {
+    "pass": "적합", "fail": "부적합", "hold": "보류",
+    "pending": "AI미지원", "error": "오류",
+}
+
+# 처리 방식(내부 routing) → 감리자용 표현
+_ROUTING_LABEL = {
+    "vlm":        "AI 사진 판독",
+    "cv":         "자동 측정",
+    "cv_missing": "자동 측정 필요 (미지원)",
+}
+
+
+def _synthesize_vqa_question(item: dict) -> str:
+    """체크리스트 항목 텍스트만으로 VLM 질문 프롬프트 합성."""
+    cat = item.get("category", "")
+    cat_prefix = f"({cat}) " if cat else ""
+    return (
+        f"{cat_prefix}검사 항목: {item['text']}\n"
+        f"위 항목을 사진(들) 만으로 판정하세요. 사진에 명확한 근거가 보이면 그 위치를 "
+        f"'Image #N' 으로 인용해서 reason 에 적고, 사진만으로 단정할 수 없으면 hold "
+        f"로 처리하면서 어떤 추가 사진이 필요한지 reason 에 명시하세요."
+    )
+
+
+# ─── per-item ─────────────────────────────────────────────────────────────
+
+def inspect_one(
+    item: dict,
+    decision: RouteDecision,
+    images: Sequence[Image.Image],
+    client=None,
+) -> dict:
+    """체크리스트 1개 항목 실행 (라우팅 결정에 따라 분기)."""
+    base = {
+        "item_id":  item["item_id"],
+        "category": item.get("category", ""),
+        "text":     item["text"],
+        "routing":  decision.mode,                    # "vlm" | "cv" | "cv_missing"
+        "route_rationale":  decision.rationale,
+        "route_confidence": decision.confidence,
+    }
+    started = time.time()
+
+    try:
+        if decision.mode == "vlm":
+            r: VLMResult = vqa_judge(
+                images=images,
+                item_id=item["item_id"],
+                item_text=item["text"],
+                question=_synthesize_vqa_question(item),
+                client=client,
+            )
+            return {
+                **base,
+                "verdict":     r.verdict,
+                "confidence":  round(r.confidence, 3),
+                "reason":      r.reason,
+                "observation": r.observation,
+                "used_images": r.used_images,
+                "recapture_shots": r.recapture_shots,   # 보류 시 재촬영할 샷 목록(슬롯용)
+                "elapsed_sec": round(time.time() - started, 2),
+            }
+
+        if decision.mode == "cv":
+            try:
+                handler = resolve_handler(decision.model_id or "")
+            except Exception as e:
+                return {
+                    **base,
+                    "model_id":    decision.model_id,
+                    "verdict":     "error",
+                    "reason":      f"CV 핸들러 해석 실패: {type(e).__name__}: {e}",
+                    "elapsed_sec": round(time.time() - started, 2),
+                }
+            cv: CVResult = handler(images)
+            return {
+                **base,
+                "model_id":     decision.model_id,
+                "verdict":      cv.verdict,
+                "reason":       cv.reason,
+                "measurements": cv.measurements,
+                "used_images":  cv.used_images,
+                "overlay_b64":  cv.overlay_b64,
+                "elapsed_sec":  round(time.time() - started, 2),
+            }
+
+        if decision.mode == "cv_missing":
+            return {
+                **base,
+                "model_id":    None,
+                "verdict":     "pending",
+                "reason":      (
+                    "이 항목은 치수·각도 등 자동 측정이 필요한데, 해당 측정 기능이 "
+                    "아직 준비되지 않았습니다. 감리자가 직접 확인해 주세요."
+                ),
+                "measurements": {},
+                "used_images":  [],
+                "elapsed_sec":  round(time.time() - started, 2),
+            }
+
+        return {
+            **base,
+            "verdict":     "error",
+            "reason":      f"알 수 없는 라우팅 mode: {decision.mode}",
+            "elapsed_sec": round(time.time() - started, 2),
+        }
+
+    except Exception as e:
+        return {
+            **base,
+            "verdict":     "error",
+            "reason":      f"{type(e).__name__}: {e}",
+            "traceback":   traceback.format_exc(),
+            "elapsed_sec": round(time.time() - started, 2),
+        }
+
+
+# ─── all items ────────────────────────────────────────────────────────────
+
+ProgressCallback = Callable[[int, int, dict, Optional[dict]], None]
+
+
+def inspect_all(
+    checklist: Sequence[dict],
+    images: Sequence[Image.Image],
+    *,
+    client=None,
+    progress: Optional[ProgressCallback] = None,
+    precomputed_decisions: Optional[Sequence[RouteDecision]] = None,
+) -> dict:
+    """체크리스트 전체 실행."""
+    ok, err = validate_checklist(list(checklist))
+    if not ok:
+        return {
+            "checklist_version": CHECKLIST_VERSION,
+            "error":    f"체크리스트 유효성 검증 실패: {err}",
+            "summary":  {"pass": 0, "fail": 0, "hold": 0, "pending": 0, "error": 0, "total": 0},
+            "items":    [],
+            "items_sorted": [],
+            "routing":  [],
+        }
+    if not images:
+        return {
+            "checklist_version": CHECKLIST_VERSION,
+            "n_images": 0,
+            "error":    "이미지가 전달되지 않음.",
+            "summary":  {"pass": 0, "fail": 0, "hold": 0, "pending": 0, "error": 0, "total": 0},
+            "items":    [],
+            "items_sorted": [],
+            "routing":  [],
+        }
+
+    if client is None:
+        from openai import OpenAI
+        client = OpenAI()
+
+    t0 = time.time()
+
+    # 1) 라우팅 (배치 1회). 비용은 메인 스레드 기록에서 거둠.
+    cost_tracker.reset()
+    if precomputed_decisions is None:
+        decisions = route_all(checklist, client=client)
+    else:
+        decisions = list(precomputed_decisions)
+    all_records = cost_tracker.drain()
+
+    decisions_by_id = {d.item_id: d for d in decisions}
+
+    def _fallback_decision(item_id: str) -> RouteDecision:
+        from router import RouteDecision as _RD
+        return _RD(item_id=item_id, mode="vlm", model_id=None,
+                   rationale="라우팅 누락 → vlm 폴백", confidence=0.0)
+
+    # 2) 항목 분석을 병렬로 (각 워커 스레드의 비용은 drain 으로 따로 거둠)
+    def _run(idx_item):
+        idx, item = idx_item
+        d = decisions_by_id.get(item["item_id"]) or _fallback_decision(item["item_id"])
+        cost_tracker.reset()                      # 이 워커 스레드 기록 초기화
+        r = inspect_one(item, d, images, client)
+        return idx, r, cost_tracker.drain()       # 이 항목이 쓴 비용 기록 반환
+
+    total = len(checklist)
+    results: List[dict] = [None] * total          # type: ignore[list-item]
+    workers = max(1, min(8, total))
+    with ThreadPoolExecutor(max_workers=workers) as ex:
+        futures = [ex.submit(_run, (i, it)) for i, it in enumerate(checklist)]
+        completed = 0
+        for fut in as_completed(futures):
+            idx, r, recs = fut.result()
+            results[idx] = r
+            all_records.extend(recs)
+            completed += 1
+            if progress:
+                progress(completed, total, checklist[idx], r)
+
+    summary = {
+        "pass":    sum(1 for r in results if r["verdict"] == "pass"),
+        "fail":    sum(1 for r in results if r["verdict"] == "fail"),
+        "hold":    sum(1 for r in results if r["verdict"] == "hold"),
+        "pending": sum(1 for r in results if r["verdict"] == "pending"),
+        "error":   sum(1 for r in results if r["verdict"] == "error"),
+        "total":   len(results),
+    }
+    items_sorted = sorted(
+        results, key=lambda r: (_VERDICT_ORDER.get(r["verdict"], 99), r["item_id"])
+    )
+
+    return {
+        "checklist_version": CHECKLIST_VERSION,
+        "n_images":     len(images),
+        "n_items":      len(checklist),
+        "registry_summary": [
+            {"model_id": m.model_id, "name": m.name, "status": m.status}
+            for m in list_models()
+        ],
+        "routing":      [decision_to_dict(d) for d in decisions],
+        "summary":      summary,
+        "items":        results,
+        "items_sorted": items_sorted,
+        "elapsed_total_sec": round(time.time() - t0, 1),
+        "cost":         cost_tracker.snapshot_from(all_records),
+    }
+
+
+# ─── presentation ─────────────────────────────────────────────────────────
+
+def build_summary_markdown(result: dict) -> str:
+    """결과 dict → 감리자용 마크다운 (검측 용어로 표시)."""
+    s = result.get("summary", {})
+    elapsed = result.get("elapsed_total_sec")
+    elapsed_str = f"  ·  소요시간: **{elapsed:.0f}초**" if elapsed is not None else ""
+    lines = [
+        "# 시공감리 검사 결과",
+        "",
+        f"입력 사진: **{result.get('n_images', 0)}장**  ·  총 항목: **{s.get('total', 0)}개**{elapsed_str}",
+        f"🔴 부적합 {s.get('fail',0)} · 🟡 보류 {s.get('hold',0)} · "
+        f"🟢 적합 {s.get('pass',0)} · ⏳ AI미지원 {s.get('pending',0)} · "
+        f"❌ 오류 {s.get('error',0)}",
+        "",
+        "_정렬 순서: 부적합 → 보류 → 적합 → AI미지원 → 오류_",
+        "",
+    ]
+    for r in result.get("items_sorted", []):
+        badge = _VERDICT_BADGE.get(r["verdict"], r["verdict"])
+        used = r.get("used_images") or []
+        used_str = f" · 사용한 사진: {used}" if used else ""
+        method = _ROUTING_LABEL.get(r.get("routing", ""), "")
+        method_str = f" · {method}" if method else ""
+        cat = r.get("category", "")
+        cat_str = f" · _{cat}_" if cat else ""
+        lines.append(
+            f"### [{r['item_id']}] {r['text']}  \n"
+            f"{badge}{method_str}{cat_str}{used_str}"
+        )
+        if r.get("routing") == "vlm":
+            conf = r.get("confidence")
+            if conf is not None:
+                lines.append(f"- AI 확신도: **{conf:.2f}**")
+            obs = r.get("observation")
+            if obs:
+                lines.append(f"- 관찰 내용: {obs}")
+        if r.get("routing") == "cv":
+            meas = r.get("measurements") or {}
+            if meas:
+                lines.append("- 측정값:")
+                for k, v in meas.items():
+                    lines.append(f"    - `{k}`: {v}")
+        reason = r.get("reason") or ""
+        if reason:
+            lines.append(f"- 판정 사유: {reason}")
+        lines.append("")
+    cost = result.get("cost")
+    if cost:
+        lines.append(cost_tracker.format_cost_markdown(cost))
+    return "\n".join(lines)
+
+
+def result_to_json_string(result: dict) -> str:
+    return json.dumps(result, ensure_ascii=False, indent=2)

package/python/inspection_ai_engine_handoff/requirements.txt

@@ -0,0 +1,12 @@
+openai>=1.30
+Pillow>=9.0
+pillow-heif>=1.0          # HEIC/HEIF (아이폰·아이패드 기본 촬영 포맷) 디코딩
+python-dotenv>=1.0
+
+# HTTP API 서버
+fastapi>=0.110
+uvicorn[standard]>=0.27
+python-multipart>=0.0.9
+
+# 데모 UI (demo_ui.py 만 쓰지 않으면 생략 가능)
+gradio>=4.0

package/python/inspection_ai_engine_handoff/router.py

@@ -0,0 +1,200 @@
+"""체크리스트 항목별 라우터 — VLM 단독 처리 vs CV 모델 처리 결정.
+
+각 검사항목에 대해 LLM 이:
+  - "사진만 보고 VLM 이 직접 판단 가능" → mode="vlm"
+  - "수치 측정/검출이 필요. 레지스트리의 X 모델 써야함" → mode="cv", model_id="X"
+  - "측정이 필요하지만 적합한 CV 모델이 레지스트리에 없음" → mode="cv_missing"
+
+항목별 1회만 결정 — 이후 엔진이 같은 결정을 사진 분석 단계에서 그대로 사용.
+사진 자체를 보지는 않고 텍스트만 봅니다.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, List, Literal, Optional, Sequence
+
+from cv_model_registry import CVModelMeta, list_models, summarize_for_router
+from shot_planner import _call_text_json   # 같은 텍스트 LLM 패턴 재사용
+
+
+_DEFAULT_MODEL    = os.environ.get("OPENAI_MODEL", "gpt-5.5")
+_REASONING_EFFORT = os.environ.get("REASONING_EFFORT", "high").strip()
+
+RouteMode = Literal["vlm", "cv", "cv_missing"]
+
+
+@dataclass
+class RouteDecision:
+    item_id: str
+    mode: RouteMode
+    model_id: Optional[str]    # mode=="cv" 일 때만 채워짐
+    rationale: str             # 왜 이 결정인지 한국어 1~2문장
+    confidence: float          # 0.0~1.0
+    raw: str = ""              # 디버그용
+
+
+_BATCH_PROMPT_TEMPLATE = """당신은 건설현장 시공감리 AI 의 **라우터** 입니다.
+아래 검사항목들을 각각 어떤 방식으로 판정해야 가장 정확할지 한 번에 분류하세요.
+
+선택지 (항목마다 하나):
+  (A) "vlm" — 사진을 비전 언어 모델이 보고 직접 정성 판정 (있다/없다, 양호/불량,
+              균열·파손 유무, 청소·충전·마감 상태 등 눈으로 판단 가능한 것).
+  (B) "cv"  — 정량 측정·검출이 필요 (각도·치수·비율·IoU 등). 아래 등록된 CV 모델 중
+              적합한 게 있으면 그 model_id 를 고름.
+  (C) "cv_missing" — 측정이 필요하지만 등록된 CV 모델 중 적합한 게 없을 때.
+
+[사용 가능한 CV 모델 레지스트리]
+{registry_block}
+
+[검사항목 ({n_items}개)]
+{items_block}
+
+판단 가이드:
+1) "수직/수평/정렬/치수/각도/크기/도면 일치/기울기" 등 숫자·측정이 본질이면 cv 후보.
+2) "파손/오염/청소/사춤 밀실/고정철물 설치/균열/마감/도장" 등 시각적 정성 판정이면 vlm.
+3) cv 라도 위 레지스트리에 명확히 맞는 모델이 없으면 cv_missing.
+4) 애매하면 vlm.
+
+반드시 아래 JSON 객체 하나만 출력하세요. 모든 항목을 빠짐없이 포함하세요.
+다른 텍스트/주석/코드블록 금지.
+
+{{
+  "decisions": [
+    {{"item_id": "...", "mode": "vlm" | "cv" | "cv_missing",
+      "model_id": "<mode==cv 일 때만, 아니면 null>",
+      "rationale": "왜 이 결정인지 1문장.", "confidence": 0.0}}
+  ]
+}}"""
+
+
+def _build_registry_block(models: Sequence[CVModelMeta]) -> str:
+    if not models:
+        return "(등록된 CV 모델 없음)"
+    lines = []
+    summaries = summarize_for_router(models)
+    for s in summaries:
+        status_mark = "ready" if s["status"] == "ready" else "stub"
+        lines.append(
+            f"- {s['model_id']} [{status_mark}] {s['name']}\n"
+            f"    설명: {s['description']}\n"
+            f"    적용: {', '.join(s['applicable_to'])}\n"
+            f"    출력: {', '.join(s['output_keys'])}"
+        )
+    return "\n".join(lines)
+
+
+def _build_items_block(checklist: Sequence[dict]) -> str:
+    lines = []
+    for i, it in enumerate(checklist, 1):
+        cat = it.get("category", "")
+        cat_str = f" ({cat})" if cat else ""
+        lines.append(f"{i}. [{it['item_id']}]{cat_str} {it['text']}")
+    return "\n".join(lines)
+
+
+def _parse_decision(d: dict, valid_ids: set, raw: str) -> Optional[RouteDecision]:
+    """배치 응답의 항목 하나(dict) → RouteDecision. item_id 없으면 None."""
+    if not isinstance(d, dict):
+        return None
+    iid = str(d.get("item_id") or "").strip()
+    if not iid:
+        return None
+
+    mode = str(d.get("mode") or "").strip().lower()
+    if mode not in ("vlm", "cv", "cv_missing"):
+        mode = "vlm"
+
+    mid = d.get("model_id")
+    mid = mid.strip() if isinstance(mid, str) and mid.strip() else None
+
+    try:
+        conf = max(0.0, min(1.0, float(d.get("confidence") or 0.0)))
+    except (TypeError, ValueError):
+        conf = 0.0
+    rationale = str(d.get("rationale") or "").strip()
+
+    # cv 인데 레지스트리에 없는 model_id → cv_missing 으로 강등
+    if mode == "cv" and mid not in valid_ids:
+        return RouteDecision(
+            item_id=iid, mode="cv_missing", model_id=None,
+            rationale=f"LLM 이 model_id='{mid}' 를 골랐으나 레지스트리에 없음 → cv_missing. {rationale}",
+            confidence=conf, raw=raw,
+        )
+
+    return RouteDecision(
+        item_id=iid, mode=mode,                       # type: ignore[arg-type]
+        model_id=mid if mode == "cv" else None,
+        rationale=rationale, confidence=conf, raw=raw,
+    )
+
+
+def route_all(
+    checklist: Sequence[dict],
+    *,
+    client=None,
+    registry: Optional[Sequence[CVModelMeta]] = None,
+    model: Optional[str] = None,
+    max_completion_tokens: int = 6000,
+    reasoning_effort: Optional[str] = None,
+) -> list[RouteDecision]:
+    """체크리스트 전체를 **한 번의 LLM 호출**로 라우팅 (배치)."""
+    if not checklist:
+        return []
+    if registry is None:
+        registry = list_models()
+    if client is None:
+        from openai import OpenAI
+        client = OpenAI()
+    model = model or _DEFAULT_MODEL
+
+    prompt = _BATCH_PROMPT_TEMPLATE.format(
+        n_items=len(checklist),
+        registry_block=_build_registry_block(registry),
+        items_block=_build_items_block(checklist),
+    )
+    data, raw = _call_text_json(
+        client=client, prompt=prompt, model=model,
+        max_completion_tokens=max_completion_tokens,
+        reasoning_effort=reasoning_effort,
+    )
+
+    valid_ids = {m.model_id for m in registry}
+    by_id: dict[str, RouteDecision] = {}
+    if data and isinstance(data.get("decisions"), list):
+        for entry in data["decisions"]:
+            dec = _parse_decision(entry, valid_ids, raw)
+            if dec is not None:
+                by_id[dec.item_id] = dec
+
+    # 누락된 항목은 vlm 폴백
+    out: list[RouteDecision] = []
+    for it in checklist:
+        iid = it["item_id"]
+        out.append(by_id.get(iid) or RouteDecision(
+            item_id=iid, mode="vlm", model_id=None,
+            rationale="배치 라우팅에서 누락 → vlm 폴백.",
+            confidence=0.0, raw=raw,
+        ))
+    return out
+
+
+def route_item(
+    item: dict,
+    *,
+    client=None,
+    registry: Optional[Sequence[CVModelMeta]] = None,
+    model: Optional[str] = None,
+) -> RouteDecision:
+    """단일 항목 라우팅 (배치 route_all 재사용)."""
+    return route_all([item], client=client, registry=registry, model=model)[0]
+
+
+def decision_to_dict(d: RouteDecision) -> dict:
+    return {
+        "item_id":    d.item_id,
+        "mode":       d.mode,
+        "model_id":   d.model_id,
+        "rationale":  d.rationale,
+        "confidence": round(d.confidence, 3),
+    }

package/python/inspection_ai_engine_handoff/shot_catalog.py

@@ -0,0 +1,79 @@
+"""자주 쓰는 샷 종류 카탈로그 — LLM 샷 플래너의 *힌트* 로만 사용.
+
+v3 에서는 체크리스트가 동적이므로 항목별 required_shots 매핑을 미리 못 합니다.
+LLM 이 매번 체크리스트를 보고 통합 샷 플랜을 짜는데, 그 때 LLM 에게
+"이런 식의 샷이 흔히 쓰입니다" 라는 참고용으로 이 카탈로그를 전달합니다.
+LLM 은 카탈로그 샷을 그대로 골라도 되고, 새 샷 종류를 정의해도 됩니다.
+
+새 샷 패턴이 자주 쓰이면 여기 추가하면 LLM 출력이 더 안정적이 됩니다.
+"""
+from __future__ import annotations
+
+from typing import TypedDict
+
+
+class ShotSpec(TypedDict):
+    shot_id: str        # 샷 식별자 (영문 snake_case)
+    title: str          # 짧은 한국어 제목
+    instruction: str    # 사용자에게 보여줄 촬영 지시
+    priority: int       # 1=필수, 2=권장, 3=선택
+
+
+SHOT_CATALOG: dict[str, ShotSpec] = {
+    "full_front": {
+        "shot_id": "full_front",
+        "title": "전체 풀샷 (정면)",
+        "instruction": (
+            "검사 부재 전체가 한 프레임에 들어오도록 정면에서 1~2m 떨어져 촬영. "
+            "상·하·좌·우 사방이 모두 화면에 잡혀야 함. 카메라가 수평·수직이 되도록 "
+            "(기울이지 말 것)."
+        ),
+        "priority": 1,
+    },
+    "surface_closeup": {
+        "shot_id": "surface_closeup",
+        "title": "표면 마감 클로즈업",
+        "instruction": (
+            "마감 표면의 질감, 색상, 얼룩, 흠집을 30cm 이내 근접으로 촬영. "
+            "의심 구간이 있으면 그 부분을 우선적으로. 최소 1장."
+        ),
+        "priority": 1,
+    },
+    "joint_closeup": {
+        "shot_id": "joint_closeup",
+        "title": "이음새·실런트·사춤 클로즈업",
+        "instruction": (
+            "이음새, 실런트, 사춤(틈새 충전재) 시공면을 30cm 이내 근접으로 촬영. "
+            "들뜸·공극·균열이 보이는 구간이 있다면 우선적으로 잡을 것."
+        ),
+        "priority": 1,
+    },
+    "anchor_corners": {
+        "shot_id": "anchor_corners",
+        "title": "고정철물 / 모서리 근접",
+        "instruction": (
+            "고정철물 (앵커/브라켓/피스) 이나 부재 모서리를 근접 촬영. "
+            "사방 4면 모두 1장씩 권장. 시간이 부족하면 가장 의심되는 면 위주로 1~2장."
+        ),
+        "priority": 2,
+    },
+    "cleanliness": {
+        "shot_id": "cleanliness",
+        "title": "표면 청소상태 / 보양",
+        "instruction": (
+            "표면, 주변 바닥의 청소상태가 보이도록 촬영. 보양 스티커 잔존, "
+            "모르타르·실란트 잔재, 폐자재, 먼지 등이 있는지 한눈에 보이게."
+        ),
+        "priority": 2,
+    },
+    "alignment_reference": {
+        "shot_id": "alignment_reference",
+        "title": "수직·수평 기준선 비교",
+        "instruction": (
+            "부재의 직선 성분(모서리, 프레임 라인)이 수직·수평축에 맞는지 보기 위해 "
+            "정면 풀샷. 가능하면 옆에 다림추, 수평계, 그리드 격자 같은 기준선이 "
+            "같이 잡히도록."
+        ),
+        "priority": 2,
+    },
+}