fix(ds-watch): 실기기 설치용 서명 허용 — 프로젝트 기본 CODE_SIGNING 차단 제거

헤드리스 시뮬 빌드용으로 박아둔 CODE_SIGNING_ALLOWED/REQUIRED=NO 가 Xcode 실기기
설치를 막아, 프로젝트 기본에서 제거(자동 서명 유지). 시뮬 빌드는 CLI 플래그로 계속 처리.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

app/ai/client.py

@@ -264,7 +264,7 @@ class AIClient:
         """벡터 임베딩 — GPU 서버 전용"""
         response = await self._http.post(
             self.ai.embedding.endpoint,
-            json={"model": self.ai.embedding.model, "prompt": text},
+            json={"model": self.ai.embedding.model, "prompt": text, "keep_alive": -1},  # bge-m3 GPU 상주(홈랩 sparse 검색 cold reload ~6s 방지)
         )
         response.raise_for_status()
         return response.json()["embedding"]

app/api/documents.py

@@ -680,7 +680,12 @@ class SectionItem(BaseModel):
     level: int | None = None
     node_type: str | None = None      # window | chapter_split | clause_split | section_split | null
     is_leaf: bool
+    parent_id: int | None = None      # 트리 부모 chunk_id. window child 의 parent_id = 그 split-parent.
+                                      # 프런트 collapseWindows 가 비인접 window 를 split-parent 에 흡수할 때 사용.
     char_start: int | None = None     # md_content 내 heading offset(UTF-16). jump-target 만 값, 그 외 None (Path B)
+    text: str | None = None           # 절 본문 = 청크 원문. 대형 split 문서는 md_content 가 앞 5만 자만 보존
+                                      # (marker LARGE_DOC_MD_CONTENT_HEAD_CHARS)이고 char_start 도 NULL 이라
+                                      # md_content 슬라이스로는 본문이 비므로, 청크 text 를 직접 렌더한다.
     section_type: str | None = None
     summary: str | None = None        # status='summarized' 인 분석행에만, 그 외 None
     confidence: float | None = None
@@ -719,12 +724,12 @@ async def get_document_sections(
         await session.execute(
             sql_text(
                 """
-                SELECT chunk_id, section_title, heading_path, level, node_type, is_leaf, char_start,
-                       section_type, summary, confidence
+                SELECT chunk_id, section_title, heading_path, level, node_type, is_leaf, parent_id, char_start,
+                       text, section_type, summary, confidence
                 FROM (
                   SELECT DISTINCT ON (c.id)
                          c.id AS chunk_id, c.chunk_index, c.section_title, c.heading_path,
-                         c.level, c.node_type, c.is_leaf, c.char_start,
+                         c.level, c.node_type, c.is_leaf, c.parent_id, c.char_start, c.text,
                          a.section_type,
                          CASE WHEN a.status = 'summarized' THEN a.summary ELSE NULL END AS summary,
                          a.confidence

app/api/queue_overview.py

@@ -103,6 +103,20 @@ class StageRow(BaseModel):
     oldest_pending_age_sec: int | None
 
 
+class BackgroundJobItem(BaseModel):
+    """큐 밖 관리 스크립트(백필 등) 작업 — processing_queue 가 못 보는 사각지대 노출.
+    stale = running 인데 heartbeat 가 오래 끊김(프로세스 사망 추정)."""
+    id: int
+    kind: str
+    label: str | None
+    state: Literal["running", "done", "failed"]
+    processed: int
+    total: int | None
+    elapsed_sec: int
+    stale: bool
+    error: str | None
+
+
 class QueueOverviewResponse(BaseModel):
     machines: list[MachineCard]
     stages: list[StageRow]
@@ -110,6 +124,7 @@ class QueueOverviewResponse(BaseModel):
     summarize_by_machine: SummarizeByMachine
     trend_24h: list[TrendBucket]
     totals: Totals
+    background_jobs: list[BackgroundJobItem] = []
 
 
 class FailedItem(BaseModel):

app/main.py

@@ -56,6 +56,9 @@ async def lifespan(app: FastAPI):
     from workers.mailplus_archive import run as mailplus_run
     from workers.statute_collector import run as statute_run
     from workers.news_collector import run as news_collector_run
+    from workers.arxiv_collector import run as arxiv_collector_run
+    from workers.openalex_collector import run as openalex_collector_run
+    from workers.paper_doi_reconcile import run as paper_doi_reconcile_run
     from workers.fulltext_worker import reconcile_unresolved as fulltext_reconcile_run
     from workers.kosha_collector import run as kosha_collector_run
     from workers.csb_collector import run as csb_collector_run
@@ -139,6 +142,9 @@ async def lifespan(app: FastAPI):
     # plan ds-s1-backend-1 B-4: dedup 컬럼(duplicate_of/duplicate_count) 야간 절대 재계산.
     # soft-delete 잔여 드리프트 정리(멱등, 드리프트 없으면 no-op). cron 03:30 (다른 잡과 비충돌).
     scheduler.add_job(dedup_reconcile_run, CronTrigger(hour=3, minute=30, timezone=KST), id="dedup_reconcile")
+    # B-3 PR4: 레거시 paper 행 arXiv DataCite DOI 스탬프(재유입 차단). keyless·in-DB·enqueue 0.
+    # dedup_reconcile(03:30)·fulltext_reconcile(03:40) 와 별 worker·비충돌 슬롯.
+    scheduler.add_job(paper_doi_reconcile_run, CronTrigger(hour=3, minute=50, timezone=KST), id="paper_doi_reconcile")
     # crawl-24x7 C-2: KOSHA 재해사례 diff + GUIDE 점진 백필 (daily, 새벽 잡들과 비충돌 슬롯).
     scheduler.add_job(kosha_collector_run, CronTrigger(hour=6, minute=40, timezone=KST), id="kosha_collector")
     # 사이클 3 C-2 잔여: CSB sitemap lastmod diff (weekly 월, cap 40 + 워터마크 점진 백필).
@@ -147,6 +153,12 @@ async def lifespan(app: FastAPI):
     scheduler.add_job(api_standards_run, CronTrigger(day=5, hour=7, minute=5, timezone=KST), id="api_standards_collector")
     # 사이클 3 C-2 잔여: CCPS Beacon 월간 PDF (playwright 익명 경유 — WAF 차단 시 health 로 가시화).
     scheduler.add_job(ccps_collector_run, CronTrigger(day=5, hour=7, minute=20, timezone=KST), id="ccps_collector")
+    # B-3 PR2: arXiv 키워드 필터 수집기 (daily 07:30 KST — statute 07:00 직후 빈 슬롯).
+    # signal-only 초록 색인, per-run cap 으로 임베드 큐 보호. keyless.
+    scheduler.add_job(arxiv_collector_run, CronTrigger(hour=7, minute=30, timezone=KST), id="arxiv_collector")
+    # B-3 PR3: OpenAlex 백본 수집기 (daily 07:45 KST). scaffold-first(키 부재 explicit-skip),
+    # signal-only 초록 색인, per-run cap + cursor watermark. 키=OPENALEX_API_KEY(credentials.env).
+    scheduler.add_job(openalex_collector_run, CronTrigger(hour=7, minute=45, timezone=KST), id="openalex_collector")
     scheduler.start()
 
     # Phase 2.1 (async 구조): QueryAnalyzer prewarm.

app/services/background_jobs.py

@@ -0,0 +1,93 @@
+"""off-queue 관리 스크립트(백필 등) 진행 가시화 — background_jobs (migration 357).
+
+processing_queue 는 파이프라인 stage 전용이라 hier_overnight_backfill /
+section_summary_pilot 같은 스크립트 작업은 대시보드 보드에 안 잡힌다. 이 모듈로
+스크립트가 진행상황을 남기면 queue_overview 가 "백그라운드 작업" 패널로 노출한다.
+
+설계 불변식:
+- **자율 트랜잭션**: 각 기록은 engine.begin() 짧은 트랜잭션으로 즉시 commit한다.
+  스크립트 본 작업은 별도 세션(긴 트랜잭션)이라, 같이 묶으면 commit 전까지 안 보여
+  실시간 가시화가 깨진다. 그래서 전용 connection 으로 독립 commit.
+- **best-effort**: 관측 기록 실패가 본 작업을 깨면 안 된다 — 모든 함수 try/except,
+  실패 시 warning 로그만. job_id=None 이면 조용히 no-op (start 실패해도 이어서 동작).
+"""
+
+import json
+import logging
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncEngine
+
+logger = logging.getLogger(__name__)
+
+
+async def start_job(
+    engine: AsyncEngine, kind: str, label: str | None = None, total: int | None = None
+) -> int | None:
+    """작업 시작 기록 → background_jobs.id (실패 시 None — 호출측은 그대로 진행)."""
+    try:
+        async with engine.begin() as conn:
+            row = (
+                await conn.execute(
+                    text(
+                        "INSERT INTO background_jobs (kind, label, total) "
+                        "VALUES (:k, :l, :t) RETURNING id"
+                    ),
+                    {"k": kind, "l": label, "t": total},
+                )
+            ).first()
+            return int(row[0]) if row else None
+    except Exception as exc:  # noqa: BLE001 — 관측은 부가, 본작업 보호
+        logger.warning(f"[background_jobs] start 실패(무시): {type(exc).__name__}: {exc}")
+        return None
+
+
+async def heartbeat(
+    engine: AsyncEngine,
+    job_id: int | None,
+    *,
+    processed: int | None = None,
+    total: int | None = None,
+    detail: dict | None = None,
+) -> None:
+    """진행 갱신(processed/total/detail). job_id=None 또는 실패 시 no-op."""
+    if job_id is None:
+        return
+    try:
+        async with engine.begin() as conn:
+            await conn.execute(
+                text(
+                    "UPDATE background_jobs SET "
+                    "processed = COALESCE(:p, processed), "
+                    "total = COALESCE(:t, total), "
+                    "detail = COALESCE(CAST(:d AS jsonb), detail), "
+                    "updated_at = now() WHERE id = :id"
+                ),
+                {
+                    "id": job_id,
+                    "p": processed,
+                    "t": total,
+                    "d": json.dumps(detail, ensure_ascii=False) if detail is not None else None,
+                },
+            )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(f"[background_jobs] heartbeat 실패(무시): {type(exc).__name__}: {exc}")
+
+
+async def finish_job(
+    engine: AsyncEngine, job_id: int | None, *, state: str = "done", error: str | None = None
+) -> None:
+    """종료 기록(done/failed). job_id=None 또는 실패 시 no-op."""
+    if job_id is None:
+        return
+    try:
+        async with engine.begin() as conn:
+            await conn.execute(
+                text(
+                    "UPDATE background_jobs SET state = :s, error = :e, "
+                    "finished_at = now(), updated_at = now() WHERE id = :id"
+                ),
+                {"id": job_id, "s": state, "e": (error or None)},
+            )
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(f"[background_jobs] finish 실패(무시): {type(exc).__name__}: {exc}")

app/services/papers/__init__.py

@@ -0,0 +1,5 @@
+"""B-3 논문 수집 트랙 공유 모듈 (plan safety-library-b3-1).
+
+doi    — DOI 정규화·dedup 키·2-Document(holder/parent_doi child) extract_meta 계약 (순수).
+holder — 서지 holder 공유 dedup 조회 (DB).
+"""

app/services/papers/doi.py

@@ -0,0 +1,141 @@
+"""B-3 논문 DOI 코어 — 정규화·dedup 키·2-Document(서지 holder / parent_doi child) 계약.
+
+plan safety-library-b3-1 PR1 (keyless·마이그 0).
+
+핵심 계약(모든 논문 수집기·reconcile·구매 PDF 스탬프가 공유):
+- DOI 정규화는 이 단일 함수(normalize_doi) 경유 — **저장=조회 동일 함수**
+  (migration 351 주석 명시, news_collector._normalize_url 의 store=lookup 불변식 선례).
+  같은 논문이 다른 표기(https://doi.org/ vs doi: vs 대문자)로 들어와도 한 holder 로 붕괴.
+- dedup 키 = lower(extract_meta #>> '{paper,doi}') — 라이브 partial-unique 인덱스
+  uq_documents_paper_doi(WHERE material_type='paper' AND ... IS NOT NULL)가 강제.
+- 2-Document(R2-B1): paper.doi 는 **서지 Document 단일 보유**. OA/구매 전문 PDF 는
+  doi 없이 paper.parent_doi 로 holder 링크(NULL doi 라 인덱스 밖 → 다중행 무충돌).
+  holder 와 child 는 doi/parent_doi 를 **상호 배타**로 가진다.
+"""
+
+import hashlib
+import re
+
+# 소문자화 후 비교하므로 전부 소문자 prefix. 긴 것부터(dx.doi.org 가 doi.org 보다 먼저).
+_DOI_PREFIXES = (
+    "https://dx.doi.org/",
+    "http://dx.doi.org/",
+    "https://doi.org/",
+    "http://doi.org/",
+    "dx.doi.org/",
+    "doi.org/",
+    "doi:",
+)
+
+
+def normalize_doi(raw: str | None) -> str | None:
+    """DOI 정규화 — 소문자 + URL/doi: prefix 제거 + 양끝 공백·잡음 제거. 단일 함수(저장=조회).
+
+    유효 DOI(10. 으로 시작)가 아니면 None. 저장측·조회측·dedup 키 생성이 모두 이 함수를
+    공유해야 dedup 이 성립한다(raw 를 그대로 저장하고 정규화로 조회하면 영구 미스).
+    """
+    if not raw:
+        return None
+    s = raw.strip().lower()
+    for p in _DOI_PREFIXES:
+        if s.startswith(p):
+            s = s[len(p):]
+            break
+    s = s.strip()
+    # 인용문 끝 잡음(마침표/쉼표/세미콜론)만 제거. 괄호 '()' 는 DOI 일부일 수 있어 보존한다
+    # (예: 10.1016/s0010-8650(00)80003-2) — 과삭제는 서로 다른 논문을 한 holder 로 병합하는
+    # 데이터 손상이라 near-dup(과소삭제)보다 위험. API 소스(OpenAlex/arXiv)의 doi 는 이미 깨끗.
+    s = s.rstrip(".,;")
+    if not s.startswith("10."):
+        return None
+    return s
+
+
+# arXiv id: 신형 'YYMM.NNNNN'(+vN) 또는 구형 'archive(.SUBJ)/NNNNNNN'. 'arXiv:' 접두 흡수.
+_ARXIV_ID_RE = re.compile(
+    r"arxiv:\s*([a-z\-]+(?:\.[a-z]{2})?/\d{7}|\d{4}\.\d{4,5})(v\d+)?", re.IGNORECASE
+)
+
+
+def parse_arxiv_id(text: str | None) -> str | None:
+    """본문/제목에서 arXiv id(versionless) 추출. 없으면 None. 레거시 reconcile 의 입력."""
+    if not text:
+        return None
+    m = _ARXIV_ID_RE.search(text)
+    return m.group(1) if m else None
+
+
+def arxiv_doi(arxiv_id: str | None) -> str | None:
+    """arXiv DataCite DOI = 10.48550/arxiv.{id} (정규화). 저널 DOI 없는 프리프린트의 canonical
+    paper.doi 통일 키 — OpenAlex 가 프리프린트에 동일 DOI 부여(실측 확인). 모든 수집기·reconcile 가
+    같은 함수로 같은 DOI 를 써야 교차소스 dedup 이 성립."""
+    if not arxiv_id:
+        return None
+    return normalize_doi(f"10.48550/arXiv.{arxiv_id}")
+
+
+_DOI_IN_TEXT_RE = re.compile(r"10\.\d{4,9}/[^\s\"'<>]+", re.IGNORECASE)
+
+
+def parse_doi_from_text(text: str | None) -> str | None:
+    """본문에서 첫 DOI 추출(정규화). 구매 PDF 의 paper.parent_doi 링크용(PDF 구조 무관 — 전체 스캔).
+    DOI 끝 구두점은 normalize_doi 가 정리. 없으면 None."""
+    if not text:
+        return None
+    m = _DOI_IN_TEXT_RE.search(text)
+    return normalize_doi(m.group(0)) if m else None
+
+
+def paper_doi_hash(normalized_doi: str) -> str:
+    """서지 holder 의 Document.file_hash — sha256('paper|{doi}')[:32].
+
+    statute 의 'statute|{jur}|{native_id}|{version_key}' 다중부 키 선례를 따른다.
+    인자는 normalize_doi() 출력(정규화 완료값)이어야 한다 — raw 를 넣으면 dedup 이 깨진다.
+    """
+    if not normalized_doi:
+        raise ValueError("paper_doi_hash 는 정규화된 DOI 필요 (normalize_doi 먼저)")
+    return hashlib.sha256(f"paper|{normalized_doi}".encode()).hexdigest()[:32]
+
+
+def read_paper_doi(extract_meta: dict | None) -> str | None:
+    """holder 의 정규화 DOI 읽기 — 인덱스 식 lower(extract_meta #>> '{paper,doi}') 의 조회측 거울.
+
+    방어적 재정규화(이미 정규화돼 저장되지만 레거시·외부 주입 대비).
+    """
+    if not extract_meta:
+        return None
+    paper = extract_meta.get("paper")
+    if not isinstance(paper, dict):
+        return None
+    return normalize_doi(paper.get("doi"))
+
+
+def with_paper_doi(extract_meta: dict | None, normalized_doi: str) -> dict:
+    """서지 holder 의 extract_meta 에 paper.doi 주입 (merge-safe, 타 키 보존).
+
+    holder 전용 — parent_doi 는 제거(상호 배타). 반환값은 새 dict(입력 비변경).
+    """
+    if not normalized_doi:
+        raise ValueError("with_paper_doi 는 정규화된 DOI 필요")
+    meta = dict(extract_meta or {})
+    paper = dict(meta.get("paper") or {})
+    paper["doi"] = normalized_doi
+    paper.pop("parent_doi", None)
+    meta["paper"] = paper
+    return meta
+
+
+def with_parent_doi(extract_meta: dict | None, parent_normalized_doi: str) -> dict:
+    """child(OA/구매 전문 PDF)의 extract_meta 에 paper.parent_doi 주입 (merge-safe, 타 키 보존).
+
+    child 는 paper.doi 를 갖지 않는다(NULL → partial-unique 인덱스 밖, 2-Document 무충돌).
+    반환값은 새 dict(입력 비변경).
+    """
+    if not parent_normalized_doi:
+        raise ValueError("with_parent_doi 는 정규화된 DOI 필요")
+    meta = dict(extract_meta or {})
+    paper = dict(meta.get("paper") or {})
+    paper["parent_doi"] = parent_normalized_doi
+    paper.pop("doi", None)
+    meta["paper"] = paper
+    return meta

app/services/papers/holder.py

@@ -0,0 +1,38 @@
+"""B-3 논문 서지 holder 공유 dedup 조회.
+
+모든 논문 수집기(OpenAlex/arXiv/KoreaScience/J-STAGE)·reconcile·구매 PDF 스탬프가
+ingest 전 이 함수로 holder 존재를 확인한다(있으면 skip 또는 child 링크).
+
+- 조회 키 = lower(extract_meta #>> '{paper,doi}') == normalize_doi(...) — 라이브 partial-unique
+  인덱스 uq_documents_paper_doi 와 동일 식(인덱스 사용).
+- .scalars().first() — 교차게시·다중 landing-page 로 2행 이상 매칭 시 MultipleResultsFound
+  raise 방지(scalar_one_or_none 금지, 2026-06 BBC 수집 중단 선례 / news_collector 동일 규율).
+- 서지 holder Document 의 **생성**은 각 수집기/스탬프 경로가 소유한다(초록 signal 문서 vs 구매
+  최소 holder 로 shape 가 다름). 이 모듈은 dedup 조회만 공유한다.
+
+DB 조회라 본 모듈은 PR2(arXiv 실수집)에서 라이브 검증한다 — PR1 단위 테스트 대상은 doi.py(순수).
+"""
+
+from sqlalchemy import func, select
+
+from models.document import Document
+from services.papers.doi import normalize_doi
+
+# 인덱스 식과 동일: lower(extract_meta #>> '{paper,doi}')
+_DOI_EXPR = func.lower(Document.extract_meta[("paper", "doi")].astext)
+
+
+async def find_paper_holder(session, raw_or_normalized_doi):
+    """정규화 DOI 로 서지 holder Document 조회. 없으면 None.
+
+    인자는 raw 든 정규화든 받아 normalize_doi 로 통일(저장=조회 동일 함수 보장).
+    """
+    doi = normalize_doi(raw_or_normalized_doi)
+    if not doi:
+        return None
+    result = await session.execute(
+        select(Document)
+        .where(Document.material_type == "paper", _DOI_EXPR == doi)
+        .limit(1)
+    )
+    return result.scalars().first()

app/services/queue_overview.py

@@ -412,7 +412,7 @@ async def build_overview(session: AsyncSession) -> dict:
         for row in current_result
     ]
 
-    return compose_overview(
+    result = compose_overview(
         rows_to_stage_stats(stage_rows),
         rows_to_summarize_split(split_rows),
         {row[0]: int(row[1]) for row in inflow_rows},
@@ -421,6 +421,44 @@ async def build_overview(session: AsyncSession) -> dict:
         deep_enabled=deep_enabled,
         now_kst=now_kst,
     )
+    # 큐 밖 관리 스크립트(백필 등) = background_jobs (migration 357). 테이블 부재 시 graceful([]).
+    result["background_jobs"] = await _fetch_background_jobs(session)
+    return result
+
+
+_BACKGROUND_JOBS_SQL = """
+    SELECT id, kind, label, state, processed, total,
+           EXTRACT(EPOCH FROM (now() - started_at))::int AS elapsed_sec,
+           (state = 'running' AND updated_at < now() - interval '5 minutes') AS stale,
+           error
+    FROM background_jobs
+    WHERE state = 'running' OR finished_at > now() - interval '6 hours'
+    ORDER BY (state = 'running') DESC, started_at DESC
+    LIMIT 20
+"""
+
+
+async def _fetch_background_jobs(session: AsyncSession) -> list[dict]:
+    """running + 최근 6h 완료 background_jobs. 테이블 없거나 오류면 [] (보드 무영향).
+
+    요청 세션과 **별도 connection**으로 조회한다 — 테이블 부재(마이그 357 미적용 등) 시
+    SELECT 실패가 요청 세션의 트랜잭션을 오염시키지 않도록 물리적으로 분리(실패 시 그
+    임시 connection만 폐기). 관측은 부가 기능이라 보드 본체를 절대 깨면 안 된다.
+    """
+    try:
+        async with session.bind.connect() as conn:  # 풀에서 독립 connection
+            rows = (await conn.execute(text(_BACKGROUND_JOBS_SQL))).mappings().all()
+    except Exception:  # noqa: BLE001 — 관측 부가, 보드 본체 보호
+        return []
+    return [
+        {
+            "id": r["id"], "kind": r["kind"], "label": r["label"], "state": r["state"],
+            "processed": int(r["processed"] or 0), "total": r["total"],
+            "elapsed_sec": int(r["elapsed_sec"] or 0), "stale": bool(r["stale"]),
+            "error": r["error"],
+        }
+        for r in rows
+    ]
 
 
 # ─── 실패 처리 (plan ds-board-engines-1) ─────────────────────────────────────

app/services/search/retrieval_service.py

@@ -361,7 +361,7 @@ async def search_text(
                        + similarity(coalesce(d.ai_tags::text, ''), :q) * 2.5
                        + similarity(coalesce(d.user_note, ''), :q) * 2.0
                        + similarity(coalesce(d.ai_summary, ''), :q) * 1.5
-                       + similarity(coalesce(d.extracted_text, ''), :q) * 1.0
+                       + similarity(left(coalesce(d.extracted_text, ''), 2000), :q) * 1.0
                        -- FTS 보너스 (idx_documents_fts_full 활용)
                        + coalesce(ts_rank(
                            to_tsvector('simple',
@@ -369,7 +369,7 @@ async def search_text(
                                coalesce(d.ai_tags::text, '') || ' ' ||
                                coalesce(d.ai_summary, '') || ' ' ||
                                coalesce(d.user_note, '') || ' ' ||
-                               coalesce(d.extracted_text, '')
+                               left(coalesce(d.extracted_text, ''), 2000)
                            ),
                            plainto_tsquery('simple', :q)
                        ), 0) * 2.0
@@ -380,7 +380,7 @@ async def search_text(
                        WHEN similarity(coalesce(d.ai_tags::text, ''), :q) >= 0.3 THEN 'tags'
                        WHEN similarity(coalesce(d.user_note, ''), :q) >= 0.3 THEN 'note'
                        WHEN similarity(coalesce(d.ai_summary, ''), :q) >= 0.3 THEN 'summary'
-                       WHEN similarity(coalesce(d.extracted_text, ''), :q) >= 0.3 THEN 'content'
+                       WHEN similarity(left(coalesce(d.extracted_text, ''), 2000), :q) >= 0.3 THEN 'content'
                        ELSE 'fts'
                    END AS match_reason,
                    d.material_type, d.jurisdiction, d.published_date

app/workers/arxiv_collector.py

@@ -0,0 +1,370 @@
+"""arXiv 키워드 필터 수집기 — B-3 PR2 (plan safety-library-b3-1).
+
+bespoke arXiv API(Atom) 수집기. 카테고리 RSS 통째(firehose)가 아니라
+cat:{category} AND (abs:키워드 ...) 로 안전/신뢰성/압력용기 관련분만 좁혀 수집한다.
+
+- signal-only: 초록만 색인(embed+chunk), summarize 절대 미enqueue — 맥미니 Qwen 큐 무접촉.
+- DOI 보유 → paper.doi(서지 holder, partial-unique 인덱스 진입). 없으면 versionless arXiv id 로
+  dedup(향후 PR4 reconcile 가 DOI 백필).
+- etiquette: 요청 간 ≥3s + HTTP 429 지수 백오프. 카테고리별 submittedDate 워터마크로 증분.
+- per-run insert cap(_RUN_CAP) — 광역 수집이 GPU bge-m3 embed 큐를 범람시키지 않게(적대리뷰 A major).
+  잔여는 silent-cap 금지(csb idiom): 누락 건수 로깅.
+- keyless. enabled=False news_sources 행(6h 뉴스 사이클 비대상) + main.py CronTrigger(자체 폴링).
+- arXiv API 는 https 필수(http=301). UA = CRAWL_UA.
+"""
+
+import asyncio
+import hashlib
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+import httpx
+from sqlalchemy import select
+
+from core.crawl_politeness import CRAWL_UA
+from core.database import async_session
+from core.utils import setup_logger
+from models.document import Document
+from models.news_source import NewsSource
+from models.queue import enqueue_stage
+from services.papers.doi import arxiv_doi, normalize_doi
+from services.papers.holder import find_paper_holder
+from workers.news_collector import (
+    FeedError,
+    _get_or_create_health,
+    _record_failure,
+    _record_success,
+)
+
+logger = setup_logger("arxiv_collector")
+
+_ARXIV_API = "https://export.arxiv.org/api/query"
+_SOURCE_NAME = "arXiv 안전·공학 (keyword)"
+
+# 신규 카테고리만 — 기존 RSS 행(id 62 physics.app-ph, id 64 cond-mat.mtrl-sci)과 비중복.
+_CATEGORIES = (
+    "eess.SY",        # systems & control
+    "physics.flu-dyn",  # 유체 — 압력/유동
+    "physics.comp-ph",  # 전산물리
+    "math.OC",        # 최적화·제어
+    "math.NA",        # 수치해석 (FEM 등)
+    "stat.AP",        # 응용통계 — 신뢰성
+    "cs.CE",          # computational engineering
+)
+# 압력용기·공정안전·구조건전성 도메인 키워드(abs: OR 게이트). 좁게 유지 = 관련성↑·볼륨↓ (튜너블).
+_KEYWORDS = (
+    "pressure vessel",
+    "process safety",
+    "structural integrity",
+    "fracture mechanics",
+    "fatigue life",
+    "corrosion",
+)
+
+_RUN_CAP = 80           # 1회 run 신규 적재 상한(임베드 큐 보호). bulk 시 해제.
+_PAGE_SIZE = 50         # max_results per request
+_MAX_PAGES_PER_CAT = 4  # 카테고리당 최대 페이지(증분이라 보통 1페이지에 워터마크 도달)
+_REQ_SLEEP = 3.0        # arXiv etiquette ≥3s
+_MAX_RETRY = 4
+_BACKOFF_BASE = 5.0
+
+_NS = {
+    "a": "http://www.w3.org/2005/Atom",
+    "arxiv": "http://arxiv.org/schemas/atom",
+    "opensearch": "http://a9.com/-/spec/opensearch/1.1/",
+}
+_ABS_ID_RE = re.compile(r"arxiv\.org/abs/(.+?)(v\d+)?$")
+_WS_RE = re.compile(r"\s+")
+
+
+# ───────────────────────── 순수 파서 (fixture 단위 테스트 대상) ─────────────────────────
+
+@dataclass
+class ArxivEntry:
+    arxiv_id: str            # versionless, 예: "1209.2405"
+    version: str | None      # "v1" 또는 None
+    title: str
+    summary: str             # 초록
+    published: datetime | None
+    doi: str | None          # normalize_doi 적용
+    journal_ref: str | None
+    primary_category: str | None
+    categories: list = field(default_factory=list)
+    abs_url: str | None = None
+    pdf_url: str | None = None
+
+
+def _clean(text: str | None) -> str:
+    return _WS_RE.sub(" ", text).strip() if text else ""
+
+
+def _parse_id(raw_id: str | None) -> tuple[str | None, str | None]:
+    """'http://arxiv.org/abs/1209.2405v1' → ('1209.2405', 'v1'). versionless id 가 dedup 키."""
+    m = _ABS_ID_RE.search((raw_id or "").strip())
+    if not m:
+        return None, None
+    return m.group(1), m.group(2)
+
+
+def _parse_dt(s: str | None) -> datetime | None:
+    if not s:
+        return None
+    try:
+        return datetime.fromisoformat(s.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+
+
+def build_search_query(category: str, keywords=_KEYWORDS) -> str:
+    """cat:{category} AND (abs:kw1 OR abs:"kw with space" ...). 공백 키워드는 따옴표 구절."""
+    kw = " OR ".join(f'abs:"{k}"' if " " in k else f"abs:{k}" for k in keywords)
+    return f"cat:{category} AND ({kw})"
+
+
+def parse_arxiv_feed(xml_text: str) -> tuple[int, list[ArxivEntry]]:
+    """arXiv Atom 응답 → (total_results, [ArxivEntry]). 순수 함수."""
+    root = ET.fromstring(xml_text)
+    raw_total = root.findtext("opensearch:totalResults", default="0", namespaces=_NS)
+    try:
+        total = int(raw_total)
+    except (TypeError, ValueError):
+        total = 0
+    entries: list[ArxivEntry] = []
+    for e in root.findall("a:entry", _NS):
+        aid, ver = _parse_id(e.findtext("a:id", namespaces=_NS))
+        if not aid:
+            continue
+        prim = e.find("arxiv:primary_category", _NS)
+        abs_url = pdf_url = None
+        for ln in e.findall("a:link", _NS):
+            if ln.get("rel") == "alternate" and (ln.get("type") or "").startswith("text/html"):
+                abs_url = ln.get("href")
+            elif ln.get("title") == "pdf":
+                pdf_url = ln.get("href")
+        entries.append(ArxivEntry(
+            arxiv_id=aid,
+            version=ver,
+            title=_clean(e.findtext("a:title", namespaces=_NS)),
+            summary=_clean(e.findtext("a:summary", namespaces=_NS)),
+            published=_parse_dt(e.findtext("a:published", namespaces=_NS)),
+            doi=normalize_doi(e.findtext("arxiv:doi", namespaces=_NS)),
+            journal_ref=_clean(e.findtext("arxiv:journal_ref", namespaces=_NS)) or None,
+            primary_category=prim.get("term") if prim is not None else None,
+            categories=[c.get("term") for c in e.findall("a:category", _NS)],
+            abs_url=abs_url,
+            pdf_url=pdf_url,
+        ))
+    return total, entries
+
+
+# ───────────────────────── 적재 (DB — PR2 라이브 검증) ─────────────────────────
+
+def _build_paper_meta(source: NewsSource, entry: ArxivEntry, doi: str | None) -> dict:
+    """extract_meta — license + source + paper 식별. 서지 holder 는 paper.doi(있으면) 보유."""
+    paper: dict = {"arxiv_id": entry.arxiv_id}
+    if doi:
+        paper["doi"] = doi          # partial-unique 인덱스 진입 (교차소스 dedup)
+    if entry.journal_ref:
+        paper["journal_ref"] = entry.journal_ref
+    if entry.primary_category:
+        paper["primary_category"] = entry.primary_category
+    meta: dict = {
+        "source_id": source.id,
+        "source_name": source.name,
+        "source_region": "INT",   # arXiv = 국제 preprint. paper.jurisdiction 은 NULL 유지(A-2).
+        "paper": paper,
+        # arXiv 기본 라이선스 = 비배포(보수적). restricted 부재 → 초록은 RAG 사용 가능.
+        # (명시 CC 검출은 OAI 인터페이스 필요 — Atom API 미포함, PR 후속/관찰.)
+        "license": {"scheme": "arxiv", "redistribute": False, "attribution": "arXiv"},
+    }
+    if entry.published:
+        meta["published_at"] = entry.published.isoformat()
+    return meta
+
+
+async def _ingest_entry(session, source: NewsSource, entry: ArxivEntry) -> bool:
+    """1건 적재. 반환 = 신규 여부. signal-only(embed+chunk, summarize 없음)."""
+    arxiv_hash = hashlib.sha256(f"arxiv|{entry.arxiv_id}".encode()).hexdigest()[:32]
+    # 재수집 dedup(arXiv id) — .first()(다중행 방어)
+    dup = await session.execute(
+        select(Document.id).where(Document.file_hash == arxiv_hash).limit(1)
+    )
+    if dup.scalars().first():
+        return False
+    # arXiv canonical DOI = 저널 DOI 또는 arXiv DataCite DOI(프리프린트도 paper.doi 보유 → PR3 와 dedup)
+    doi = entry.doi or arxiv_doi(entry.arxiv_id)
+    # 교차소스 dedup(DOI holder 이미 존재 — partial-unique 인덱스 백스톱 선제 회피)
+    if doi and await find_paper_holder(session, doi):
+        return False
+
+    body = entry.summary or entry.title
+    doc = Document(
+        file_path=f"crawl/arxiv/{entry.arxiv_id}",
+        file_hash=arxiv_hash,
+        file_format="article",
+        file_size=len(body.encode()),
+        file_type="note",
+        title=entry.title,
+        extracted_text=f"{entry.title}\n\n{body}",
+        extracted_at=datetime.now(timezone.utc),
+        extractor_version="arxiv-api-signal",
+        md_status="skipped",
+        md_extraction_error="arXiv abstract: signal-only, markdown 비대상",
+        source_channel="crawl",
+        data_origin="external",
+        edit_url=entry.abs_url,
+        review_status="approved",
+        material_type="paper",
+        jurisdiction=None,   # paper = NULL 불변(A-2). 지역은 extract_meta.paper.source_region.
+        published_date=entry.published.date() if entry.published else None,
+        extract_meta=_build_paper_meta(source, entry, doi),
+    )
+    session.add(doc)
+    await session.flush()
+    # signal-only: 검색 색인만. summarize/fulltext 절대 enqueue 안 함(맥미니 큐 무접촉).
+    await enqueue_stage(session, doc.id, "embed")
+    await enqueue_stage(session, doc.id, "chunk")
+    return True
+
+
+async def _get_or_create_source(session) -> NewsSource:
+    result = await session.execute(
+        select(NewsSource).where(NewsSource.name == _SOURCE_NAME)
+    )
+    source = result.scalars().first()
+    if source is None:
+        source = NewsSource(
+            name=_SOURCE_NAME, feed_url=_ARXIV_API, feed_type="atom",
+            fetch_method="signal-only", fulltext_policy="none",
+            source_channel="crawl", category="Engineering", language="en",
+            country=None,            # paper → jurisdiction NULL (country 미전파)
+            material_type="paper",
+            license_scheme="arxiv", license_redistribute=False,
+            enabled=False,           # 6h 뉴스 사이클 비대상 — 본 워커가 자체 폴링
+        )
+        session.add(source)
+        await session.flush()
+    return source
+
+
+def _watermark(source: NewsSource, category: str) -> datetime | None:
+    raw = (source.selector_override or {}).get("arxiv_watermark", {}).get(category)
+    if not raw:
+        return None
+    return _parse_dt(raw)
+
+
+def _set_watermark(source: NewsSource, category: str, value: datetime) -> None:
+    cfg = dict(source.selector_override or {})
+    wm = dict(cfg.get("arxiv_watermark") or {})
+    wm[category] = value.isoformat()
+    cfg["arxiv_watermark"] = wm
+    source.selector_override = cfg   # JSONB 변경 감지 위해 재할당
+
+
+async def _fetch(client: httpx.AsyncClient, query: str, start: int) -> str:
+    params = {
+        "search_query": query, "start": start, "max_results": _PAGE_SIZE,
+        "sortBy": "submittedDate", "sortOrder": "descending",
+    }
+    for attempt in range(_MAX_RETRY):
+        resp = await client.get(_ARXIV_API, params=params)
+        if resp.status_code == 429:
+            await asyncio.sleep(_BACKOFF_BASE * (2 ** attempt))
+            continue
+        resp.raise_for_status()
+        return resp.text
+    raise FeedError(f"arXiv 429 재시도 초과: {query[:48]}")
+
+
+async def run(bulk: bool = False, limit: int = 0) -> None:
+    """daily 진입점(스케줄러). bulk/limit 은 CLI 전용(bulk=cap 해제·깊은 페이징)."""
+    now = datetime.now(timezone.utc)
+    async with async_session() as session:
+        source = await _get_or_create_source(session)
+        await session.commit()
+        source_id = source.id
+
+    run_cap = (limit or 10**9) if bulk else (min(limit, _RUN_CAP) if limit else _RUN_CAP)
+    inserted = 0
+    seen = 0
+    failures: list[str] = []
+
+    async with httpx.AsyncClient(
+        timeout=30.0, headers={"User-Agent": CRAWL_UA}, follow_redirects=True
+    ) as client:
+        for category in _CATEGORIES:
+            if inserted >= run_cap:
+                break
+            query = build_search_query(category)
+            async with async_session() as session:
+                src = await session.get(NewsSource, source_id)
+                watermark = _watermark(src, category)
+            newest_seen: datetime | None = None
+            max_pages = (10**6 if bulk else _MAX_PAGES_PER_CAT)
+            try:
+                for page in range(max_pages):
+                    if inserted >= run_cap:
+                        break
+                    xml_text = await _fetch(client, query, page * _PAGE_SIZE)
+                    total, entries = parse_arxiv_feed(xml_text)
+                    if not entries:
+                        break
+                    stop = False
+                    for entry in entries:
+                        seen += 1
+                        if entry.published:
+                            newest_seen = max(newest_seen or entry.published, entry.published)
+                            # 증분: 워터마크 이하 도달 시 이 카테고리 종료(이미 본 구간)
+                            if watermark and not bulk and entry.published <= watermark:
+                                stop = True
+                                break
+                        async with async_session() as session:
+                            src = await session.get(NewsSource, source_id)
+                            if await _ingest_entry(session, src, entry):
+                                inserted += 1
+                                await session.commit()
+                            else:
+                                await session.rollback()
+                        if inserted >= run_cap:
+                            break
+                    await asyncio.sleep(_REQ_SLEEP)
+                    if stop or (page + 1) * _PAGE_SIZE >= total:
+                        break
+                # 카테고리 워터마크 전진(이번 run 최신 발행일)
+                if newest_seen:
+                    async with async_session() as session:
+                        src = await session.get(NewsSource, source_id)
+                        _set_watermark(src, category, newest_seen)
+                        await session.commit()
+            except (httpx.HTTPError, FeedError, ET.ParseError) as e:
+                msg = f"[{category}] {e or repr(e)}"
+                logger.error(f"[arxiv] {msg}")
+                failures.append(msg)
+
+    async with async_session() as session:
+        health = await _get_or_create_health(session, source_id)
+        if failures and inserted == 0:
+            _record_failure(health, "; ".join(failures)[:500], now)
+        else:
+            _record_success(health, inserted, False, now)
+        await session.commit()
+
+    deferred = "" if inserted < run_cap else f" (cap {run_cap} 도달 — 잔여는 다음 run 이월)"
+    logger.info(
+        f"[arxiv] {len(_CATEGORIES)}개 카테고리 스캔 {seen}건 → 신규 {inserted}건{deferred}"
+        + (f" / 실패 {len(failures)}건" if failures else "")
+    )
+
+
+if __name__ == "__main__":
+    # CLI = 수동/백필 전용. --bulk = cap 해제·깊은 페이징, --limit N = 상한 N(라이브 검증용).
+    import argparse
+
+    parser = argparse.ArgumentParser(description="arXiv 안전·공학 키워드 수집기")
+    parser.add_argument("--bulk", action="store_true", help="cap 해제 + 깊은 페이징 백필")
+    parser.add_argument("--limit", type=int, default=0, help="신규 적재 상한(0=기본 cap)")
+    args = parser.parse_args()
+    asyncio.run(run(bulk=args.bulk, limit=args.limit))

app/workers/classify_worker.py

@@ -411,6 +411,15 @@ async def process(
         logger.info(f"doc {document_id}: devonagent → classify skip")
         return
 
+    # 논문(material_type='paper') — 요약/분류 LLM 스킵(맥미니 큐 무접촉, B-3 signal-only 유지).
+    # embed/chunk/markdown 은 queue_consumer 가 chain (early-return 후에도 다음 stage enqueue).
+    if doc.material_type == "paper":
+        if not doc.ai_domain:
+            doc.ai_domain = "논문"
+        await session.commit()
+        logger.info(f"doc {document_id}: paper → classify skip (no summarize)")
+        return
+
     if not doc.extracted_text:
         raise ValueError(f"문서 ID {document_id}: extracted_text가 비어있음")
 

app/workers/openalex_collector.py

@@ -0,0 +1,393 @@
+"""OpenAlex 백본 수집기 — B-3 PR3 (plan safety-library-b3-1).
+
+OpenAlex = 발견+dedup 글로벌 백본(JP/EU/US 논문 다 색인 + 정본 DOI). 전문은 안 줌(oa_url 포인터만).
+- scaffold-first: OPENALEX_API_KEY 부재 시 FeedError(explicit-skip, silent fallback 금지). 키=무료.
+- signal-only: 초록(inverted-index 복원)만 색인(embed+chunk), summarize 절대 미enqueue(맥미니 큐 무접촉).
+  PDF 는 절대 OpenAlex 경유로 안 받음(oa_url 은 링크/신호일 뿐).
+- 관련성 사전필터 = title_and_abstract.search 키워드(서버측) + per-run insert cap(임베드 firehose 차단,
+  적대리뷰 A major). cursor 페이징 + from_publication_date 워터마크로 증분.
+- 초록 없는 thin 레코드(주로 비-OA 메타)는 skip — Phase-1 재료 품질 유지.
+- DOI → paper.doi(holder, partial-unique 인덱스, 교차소스 dedup). 없으면 openalex id fallback.
+- license: 명시 CC → redistribute=true / 그 외 OA·closed → false(restricted 부재 = 초록 RAG 사용 가능).
+- enabled=False news_sources 행 + main.py CronTrigger(자체 폴링). list+filter 비용 미미($1/일 크레딧).
+"""
+
+import asyncio
+import hashlib
+import json
+import os
+from dataclasses import dataclass
+from datetime import date, datetime, timezone
+
+import httpx
+from sqlalchemy import select
+
+from core.crawl_politeness import CRAWL_UA
+from core.database import async_session
+from core.utils import setup_logger
+from models.document import Document
+from models.news_source import NewsSource
+from models.queue import enqueue_stage
+from services.papers.doi import normalize_doi
+from services.papers.holder import find_paper_holder
+from workers.news_collector import (
+    FeedError,
+    _get_or_create_health,
+    _record_failure,
+    _record_success,
+)
+
+logger = setup_logger("openalex_collector")
+
+_API = "https://api.openalex.org/works"
+_SOURCE_NAME = "OpenAlex 안전·공학 (keyword)"
+_ENV_KEY = "OPENALEX_API_KEY"
+
+# 압력용기·공정안전·구조건전성 도메인 키워드(키워드별 1쿼리 = 관련성 사전필터).
+_KEYWORDS = (
+    "pressure vessel safety",
+    "process safety",
+    "structural integrity",
+    "fracture mechanics",
+    "fatigue life assessment",
+)
+
+# 도메인 직결 저널 ISSN 시드(OpenAlex sources 실측 확인) — 키워드 매칭 누락분까지 전수 커버.
+# KR 안전/가스/기계 + JP 고압. KR/JP 관심 = OpenAlex 깨끗한 API 로 직접(KoreaScience/J-STAGE 전용
+# 스크래퍼 불요 — Phase-1 메타는 OpenAlex 와 중복, 전용 수집기의 유니크 가치=무료 전문 PDF=Phase-2).
+_JOURNAL_ISSNS = (
+    ("한국안전학회지", "1738-3803"),
+    ("한국가스학회지", "1226-8402"),
+    ("대한기계학회논문집 A", "1226-4873"),
+    ("대한기계학회논문집 B", "1226-4881"),
+    ("KSME International J.", "1226-4865"),
+    ("Review of High Pressure Sci&Tech (JP)", "0917-639X"),
+)
+
+_RUN_CAP = 60           # 1회 run 신규 적재 상한(임베드 큐 보호). bulk 시 해제.
+_PER_PAGE = 50
+_MAX_PAGES_PER_KW = 4   # 키워드당 최대 페이지(증분이라 보통 1페이지에 워터마크 도달)
+_REQ_SLEEP = 1.0        # 페이지 간 polite 간격
+_MAX_RETRY = 4
+_BACKOFF_BASE = 5.0
+
+
+# ───────────────────────── 순수 파서 (fixture 단위 테스트 대상) ─────────────────────────
+
+@dataclass
+class OpenAlexWork:
+    openalex_id: str           # "W2910511816"
+    doi: str | None            # normalize_doi 적용
+    title: str
+    abstract: str              # inverted-index 복원 (없으면 "")
+    publication_date: str | None
+    oa_status: str | None      # closed/green/bronze/hybrid/gold/diamond
+    oa_url: str | None
+    is_oa: bool
+    license: str | None        # cc-by / cc-by-nc-nd / None
+    source_name: str | None
+    primary_topic: str | None
+    work_type: str | None
+
+
+def _clean(text):
+    return " ".join(text.split()).strip() if text else ""
+
+
+def _reconstruct_abstract(inv: dict | None) -> str:
+    """abstract_inverted_index({word:[positions]}) → 평문 초록. 없으면 ''."""
+    if not inv:
+        return ""
+    positions = [(pos, word) for word, idxs in inv.items() for pos in idxs]
+    positions.sort()
+    return " ".join(w for _, w in positions)
+
+
+def license_meta(license_str: str | None, is_oa: bool, source_name: str | None) -> dict:
+    """extract_meta.license — 명시 CC/public-domain 만 redistribute=true. restricted 부재(초록 색인 자유).
+
+    redistribute=false 라도 restricted 가 없으면 RAG 사용 가능(초록). 비-CC 전문의 RAG verbatim 차단은
+    Phase-2 전문 승격 단계가 restricted=true 로 처리(L-1) — Phase-1(초록)은 무해.
+    """
+    attribution = source_name or "OpenAlex"
+    if license_str and (license_str.startswith("cc") or license_str == "public-domain"):
+        return {"scheme": license_str, "redistribute": True, "attribution": attribution}
+    return {
+        "scheme": "open-unspecified" if is_oa else "proprietary",
+        "redistribute": False,
+        "attribution": attribution,
+    }
+
+
+def parse_openalex_works(json_text: str) -> tuple[int, str | None, list[OpenAlexWork]]:
+    """OpenAlex /works 응답 → (count, next_cursor, [OpenAlexWork]). 순수 함수."""
+    d = json.loads(json_text)
+    meta = d.get("meta") or {}
+    count = meta.get("count") or 0
+    next_cursor = meta.get("next_cursor")
+    works: list[OpenAlexWork] = []
+    for w in d.get("results") or []:
+        oid = (w.get("id") or "").rstrip("/").rsplit("/", 1)[-1]
+        if not oid:
+            continue
+        oa = w.get("open_access") or {}
+        pl = w.get("primary_location") or {}
+        pt = w.get("primary_topic") or {}
+        works.append(OpenAlexWork(
+            openalex_id=oid,
+            doi=normalize_doi(w.get("doi")),
+            title=_clean(w.get("title")),
+            abstract=_reconstruct_abstract(w.get("abstract_inverted_index")),
+            publication_date=w.get("publication_date"),
+            oa_status=oa.get("oa_status"),
+            oa_url=oa.get("oa_url") or None,
+            is_oa=bool(oa.get("is_oa")),
+            license=pl.get("license"),
+            source_name=(pl.get("source") or {}).get("display_name"),
+            primary_topic=pt.get("display_name"),
+            work_type=w.get("type"),
+        ))
+    return count, next_cursor, works
+
+
+def build_filter(keyword: str, from_date: str | None = None) -> str:
+    f = f"title_and_abstract.search:{keyword}"
+    if from_date:
+        f += f",from_publication_date:{from_date}"
+    return f
+
+
+def build_issn_filter(issn: str, from_date: str | None = None) -> str:
+    f = f"primary_location.source.issn:{issn}"
+    if from_date:
+        f += f",from_publication_date:{from_date}"
+    return f
+
+
+def _seeds() -> list[tuple[str, str, str]]:
+    """수집 시드 = (라벨, 워터마크키, 종류). 도메인 저널 ISSN 우선(cap 우선권) → 키워드."""
+    s: list[tuple[str, str, str]] = [(label, issn, "issn") for label, issn in _JOURNAL_ISSNS]
+    s += [(kw, kw, "kw") for kw in _KEYWORDS]
+    return s
+
+
+# ───────────────────────── 적재 (DB — PR3 라이브 검증) ─────────────────────────
+
+def _build_paper_meta(source: NewsSource, w: OpenAlexWork) -> dict:
+    paper: dict = {"openalex_id": w.openalex_id}
+    if w.doi:
+        paper["doi"] = w.doi          # partial-unique 인덱스 진입(교차소스 dedup)
+    if w.oa_status:
+        paper["oa_status"] = w.oa_status
+    if w.oa_url:
+        paper["oa_url"] = w.oa_url     # 링크/신호 — 자동 fetch 안 함
+    if w.primary_topic:
+        paper["topic"] = w.primary_topic
+    meta: dict = {
+        "source_id": source.id,
+        "source_name": source.name,
+        "source_region": "INT",        # OpenAlex = 글로벌. paper.jurisdiction 은 NULL 유지(A-2).
+        "paper": paper,
+        "license": license_meta(w.license, w.is_oa, w.source_name),
+    }
+    if w.publication_date:
+        meta["published_at"] = w.publication_date
+    return meta
+
+
+async def _ingest_work(session, source: NewsSource, w: OpenAlexWork) -> bool:
+    """1건 적재. 반환 = 신규 여부. signal-only. 초록 없으면 skip(thin 레코드 배제)."""
+    if not w.abstract:
+        return False  # 초록 없는 thin 레코드(주로 비-OA 메타) — Phase-1 재료 품질 유지
+    oid_hash = hashlib.sha256(f"openalex|{w.openalex_id}".encode()).hexdigest()[:32]
+    dup = await session.execute(
+        select(Document.id).where(Document.file_hash == oid_hash).limit(1)
+    )
+    if dup.scalars().first():
+        return False
+    if w.doi and await find_paper_holder(session, w.doi):
+        return False  # 교차소스 dedup(arXiv 등이 이미 holder 보유)
+
+    pub_date = None
+    if w.publication_date:
+        try:
+            pub_date = date.fromisoformat(w.publication_date)
+        except ValueError:
+            pub_date = None
+    body = w.abstract
+    doc = Document(
+        file_path=f"crawl/openalex/{w.openalex_id}",
+        file_hash=oid_hash,
+        file_format="article",
+        file_size=len(body.encode()),
+        file_type="note",
+        title=w.title,
+        extracted_text=f"{w.title}\n\n{body}",
+        extracted_at=datetime.now(timezone.utc),
+        extractor_version="openalex-signal",
+        md_status="skipped",
+        md_extraction_error="OpenAlex abstract: signal-only, markdown 비대상",
+        source_channel="crawl",
+        data_origin="external",
+        edit_url=w.oa_url or f"https://openalex.org/{w.openalex_id}",
+        review_status="approved",
+        material_type="paper",
+        jurisdiction=None,
+        published_date=pub_date,
+        extract_meta=_build_paper_meta(source, w),
+    )
+    session.add(doc)
+    await session.flush()
+    await enqueue_stage(session, doc.id, "embed")
+    await enqueue_stage(session, doc.id, "chunk")
+    return True
+
+
+async def _get_or_create_source(session) -> NewsSource:
+    result = await session.execute(
+        select(NewsSource).where(NewsSource.name == _SOURCE_NAME)
+    )
+    source = result.scalars().first()
+    if source is None:
+        source = NewsSource(
+            name=_SOURCE_NAME, feed_url=_API, feed_type="json",
+            fetch_method="signal-only", fulltext_policy="none",
+            source_channel="crawl", category="Engineering", language="en",
+            country=None, material_type="paper",
+            license_scheme="openalex", license_redistribute=False,
+            enabled=False,
+        )
+        session.add(source)
+        await session.flush()
+    return source
+
+
+def _api_key() -> str:
+    key = os.getenv(_ENV_KEY, "").strip()
+    if not key:
+        raise FeedError(f"{_ENV_KEY} 미설정 — OpenAlex 수집 불가 (scaffold-first explicit-skip)")
+    return key
+
+
+def _watermark(source: NewsSource, keyword: str) -> str | None:
+    return (source.selector_override or {}).get("openalex_watermark", {}).get(keyword)
+
+
+def _set_watermark(source: NewsSource, keyword: str, value: str) -> None:
+    cfg = dict(source.selector_override or {})
+    wm = dict(cfg.get("openalex_watermark") or {})
+    wm[keyword] = value
+    cfg["openalex_watermark"] = wm
+    source.selector_override = cfg
+
+
+async def _fetch(client: httpx.AsyncClient, key: str, filter_str: str, cursor: str) -> str:
+    params = {
+        "filter": filter_str, "per-page": _PER_PAGE, "cursor": cursor,
+        "sort": "publication_date:desc", "api_key": key,
+    }
+    for attempt in range(_MAX_RETRY):
+        resp = await client.get(_API, params=params)
+        if resp.status_code == 429:
+            await asyncio.sleep(_BACKOFF_BASE * (2 ** attempt))
+            continue
+        resp.raise_for_status()
+        return resp.text
+    raise FeedError(f"OpenAlex 429 재시도 초과: {filter_str[:48]}")
+
+
+async def run(bulk: bool = False, limit: int = 0) -> None:
+    """daily 진입점(스케줄러). 키 부재 = explicit-skip(health 실패 기록)."""
+    now = datetime.now(timezone.utc)
+    async with async_session() as session:
+        source = await _get_or_create_source(session)
+        await session.commit()
+        source_id = source.id
+
+    try:
+        key = _api_key()
+    except FeedError as e:
+        logger.warning(f"[openalex] {e}")
+        async with async_session() as session:
+            health = await _get_or_create_health(session, source_id)
+            _record_failure(health, str(e), now)
+            await session.commit()
+        return
+
+    run_cap = (limit or 10**9) if bulk else (min(limit, _RUN_CAP) if limit else _RUN_CAP)
+    inserted = 0
+    seen = 0
+    failures: list[str] = []
+
+    async with httpx.AsyncClient(
+        timeout=30.0, headers={"User-Agent": CRAWL_UA}, follow_redirects=True
+    ) as client:
+        for label, wm_key, kind in _seeds():
+            if inserted >= run_cap:
+                break
+            async with async_session() as session:
+                src = await session.get(NewsSource, source_id)
+                watermark = None if bulk else _watermark(src, wm_key)
+            filter_str = (build_issn_filter(wm_key, watermark) if kind == "issn"
+                          else build_filter(wm_key, watermark))
+            newest: str | None = None
+            cursor = "*"
+            max_pages = (10**6 if bulk else _MAX_PAGES_PER_KW)
+            try:
+                for _page in range(max_pages):
+                    if inserted >= run_cap:
+                        break
+                    text = await _fetch(client, key, filter_str, cursor)
+                    _count, next_cursor, works = parse_openalex_works(text)
+                    if not works:
+                        break
+                    for w in works:
+                        seen += 1
+                        if w.publication_date and (newest is None or w.publication_date > newest):
+                            newest = w.publication_date
+                        async with async_session() as session:
+                            src = await session.get(NewsSource, source_id)
+                            if await _ingest_work(session, src, w):
+                                inserted += 1
+                                await session.commit()
+                            else:
+                                await session.rollback()
+                        if inserted >= run_cap:
+                            break
+                    await asyncio.sleep(_REQ_SLEEP)
+                    if not next_cursor:
+                        break
+                    cursor = next_cursor
+                if newest:
+                    async with async_session() as session:
+                        src = await session.get(NewsSource, source_id)
+                        _set_watermark(src, wm_key, newest)
+                        await session.commit()
+            except (httpx.HTTPError, FeedError, ValueError) as e:
+                msg = f"[{label}] {e or repr(e)}"
+                logger.error(f"[openalex] {msg}")
+                failures.append(msg)
+
+    async with async_session() as session:
+        health = await _get_or_create_health(session, source_id)
+        if failures and inserted == 0:
+            _record_failure(health, "; ".join(failures)[:500], now)
+        else:
+            _record_success(health, inserted, False, now)
+        await session.commit()
+
+    deferred = "" if inserted < run_cap else f" (cap {run_cap} 도달 — 잔여 다음 run 이월)"
+    logger.info(
+        f"[openalex] {len(_seeds())}개 시드(ISSN+키워드) 스캔 {seen}건 → 신규 {inserted}건{deferred}"
+        + (f" / 실패 {len(failures)}건" if failures else "")
+    )
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="OpenAlex 안전·공학 키워드 백본 수집기")
+    parser.add_argument("--bulk", action="store_true", help="cap 해제 + 깊은 cursor 페이징 백필")
+    parser.add_argument("--limit", type=int, default=0, help="신규 적재 상한(0=기본 cap)")
+    args = parser.parse_args()
+    asyncio.run(run(bulk=args.bulk, limit=args.limit))

app/workers/paper_doi_reconcile.py

@@ -0,0 +1,102 @@
+"""paper DOI reconcile — B-3 PR4(레거시 arXiv) + PR5(구매 PDF) (plan safety-library-b3-1).
+
+paper.doi/parent_doi 둘 다 없는 paper 행을 두 갈래로 정리:
+- 레거시 arXiv 초록(holder): arXiv id → arxiv_doi(10.48550/arxiv.{id}) 스탬프 → partial-unique
+  인덱스 편입 → 재유입 차단('동일-DOI 재유입 차단만').
+- 구매 PDF(child, license.restricted=true — Papers_Purchased 드롭): 본문 DOI 파싱 → paper.parent_doi
+  링크(서지 holder 와 DOI 공유로 연결). child 는 doi 미보유(인덱스 밖) → unique 무충돌.
+
+- KEYLESS·결정적(OpenAlex 호출 0)·in-DB·enqueue 0(콘텐츠 무변경). dedup_reconcile(file_hash 캐시)와
+  별 worker(적대리뷰 B·C major). 선재 DOI holder 존재 시 arXiv 행도 parent_doi 마킹(unique 위반 회피).
+"""
+
+import asyncio
+
+from sqlalchemy import select
+
+from core.database import async_session
+from core.utils import setup_logger
+from models.document import Document
+from services.papers.doi import (
+    arxiv_doi,
+    parse_arxiv_id,
+    parse_doi_from_text,
+    with_paper_doi,
+    with_parent_doi,
+)
+from services.papers.holder import find_paper_holder
+
+logger = setup_logger("paper_doi_reconcile")
+
+_DOI_TEXT = Document.extract_meta[("paper", "doi")].astext
+_PARENT_DOI_TEXT = Document.extract_meta[("paper", "parent_doi")].astext
+
+
+def _is_restricted(meta: dict) -> bool:
+    return (meta.get("license") or {}).get("restricted") in (True, "true")
+
+
+async def run(limit: int = 0) -> None:
+    """paper.doi/parent_doi 없는 paper 행 reconcile(멱등). limit=0 = 전건."""
+    stamped = marked_dup = skipped_no_arxiv = 0
+    linked_purchased = skipped_purchased_no_doi = 0
+    async with async_session() as session:
+        q = (
+            select(Document)
+            .where(
+                Document.material_type == "paper",
+                _DOI_TEXT.is_(None),
+                _PARENT_DOI_TEXT.is_(None),
+            )
+            .order_by(Document.id)
+        )
+        if limit:
+            q = q.limit(limit)
+        rows = (await session.execute(q)).scalars().all()
+
+        for row in rows:
+            meta = dict(row.extract_meta or {})
+            paper = dict(meta.get("paper") or {})
+
+            # PR5: 구매 PDF(restricted) = child → 본문 DOI 파싱 → parent_doi 링크
+            if _is_restricted(meta):
+                doi = parse_doi_from_text(row.extracted_text)
+                if not doi:
+                    skipped_purchased_no_doi += 1
+                    continue
+                row.extract_meta = with_parent_doi(meta, doi)
+                linked_purchased += 1
+                continue
+
+            # PR4: 레거시 arXiv 초록(holder) = arXiv DataCite DOI 스탬프
+            arxiv_id = paper.get("arxiv_id") or parse_arxiv_id(row.extracted_text)
+            doi = arxiv_doi(arxiv_id)
+            if not doi:
+                skipped_no_arxiv += 1
+                continue
+            paper["arxiv_id"] = arxiv_id
+            meta["paper"] = paper
+            holder = await find_paper_holder(session, doi)
+            if holder is not None and holder.id != row.id:
+                row.extract_meta = with_parent_doi(meta, doi)  # 선재 중복 → child 마킹
+                marked_dup += 1
+            else:
+                row.extract_meta = with_paper_doi(meta, doi)   # holder 스탬프, 인덱스 진입
+                stamped += 1
+            # 콘텐츠 무변경 → enqueue 없음(summarize/embed/chunk 0)
+        await session.commit()
+
+    logger.info(
+        f"[paper_doi_reconcile] {len(rows)}행 → arXiv 스탬프 {stamped} · 선재중복 {marked_dup} · "
+        f"arXiv id 없음 skip {skipped_no_arxiv} / 구매PDF parent_doi 링크 {linked_purchased} · "
+        f"구매PDF DOI 없음 skip {skipped_purchased_no_doi}"
+    )
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="paper DOI reconcile (arXiv 레거시 + 구매 PDF, keyless)")
+    parser.add_argument("--limit", type=int, default=0, help="처리 상한(0=전건)")
+    args = parser.parse_args()
+    asyncio.run(run(limit=args.limit))

app/workers/paper_fulltext_promote.py

@@ -0,0 +1,123 @@
+"""논문 arXiv 전문 승격 (in-place) — B-3 Phase-2 P2-PR1 (plan safety-library-b3-1).
+
+arXiv 프리프린트 초록 행(file_format='article', signal-only)을 전문 PDF로 **in-place 승격**:
+PDF 다운로드 → file_format/file_type/file_path/md_status 갱신 → 'extract' enqueue → 기존 파이프라인
+(extract → classify[paper skip summarize] → embed/chunk/markdown)이 전문 검색 청크 + md_content(marker 표시)
++ hier 절구조를 생성. 1-Document(2행 분리 회피, 기존 display 스택 재사용).
+
+- arXiv = 공개 프리프린트(arxiv.org/pdf/{id}, friendly host) → 전문 검색/RAG 무난, restricted 불요.
+  (유료 구매 논문은 Papers_Purchased 경로가 restricted=true 로 별개 처리.)
+- per-run cap (marker GPU ~10GB + embed 부하 보호, 4070 16GB 빡빡 → idle-unload·증분). keyless.
+- 요약 0 (classify paper-skip 가드). file_hash·extract_meta.paper 보존(수집기 dedup 무영향).
+- CLI 전용(Phase-2 deliberate 승격, GPU 부하 사용자 통제). 스케줄 잡 미등록.
+"""
+
+import argparse
+import asyncio
+import random
+from pathlib import Path
+
+import httpx
+from sqlalchemy import or_, select
+
+from core.config import settings
+from core.crawl_politeness import CRAWL_UA
+from core.database import async_session
+from core.utils import setup_logger
+from models.document import Document
+from models.queue import enqueue_stage
+
+logger = setup_logger("paper_fulltext_promote")
+
+_ARXIV_PDF = "https://arxiv.org/pdf/{id}"
+_MAX_FILE_BYTES = 50 * 1024 * 1024
+_DOWNLOAD_DELAY = (2.0, 5.0)
+_RUN_CAP = 10  # 1회 승격 상한(marker/embed GPU 보호). bulk 시 해제.
+
+_ARXIV_ID_EXPR = Document.extract_meta[("paper", "arxiv_id")].astext
+_OA_URL_EXPR = Document.extract_meta[("paper", "oa_url")].astext
+_OA_STATUS_EXPR = Document.extract_meta[("paper", "oa_status")].astext
+_REAL_OA = ("gold", "hybrid", "green", "diamond")
+
+
+async def _download(url: str, dest: Path) -> int:
+    """arXiv PDF 다운로드 — 크기 cap + PDF 헤더 검증 + 연속 간격(kosha 패턴)."""
+    await asyncio.sleep(random.uniform(*_DOWNLOAD_DELAY))
+    async with httpx.AsyncClient(timeout=60, follow_redirects=True) as client:
+        resp = await client.get(url, headers={"User-Agent": CRAWL_UA})
+    if resp.status_code != 200:
+        raise RuntimeError(f"arXiv PDF {resp.status_code}: {url}")
+    if len(resp.content) > _MAX_FILE_BYTES:
+        raise RuntimeError(f"크기 초과 {len(resp.content)}b: {url}")
+    if resp.content[:5] != b"%PDF-":
+        raise RuntimeError(f"PDF 아님(헤더 {resp.content[:8]!r}): {url}")
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    dest.write_bytes(resp.content)
+    return len(resp.content)
+
+
+async def run(bulk: bool = False, limit: int = 0) -> None:
+    """미승격 arXiv 논문(file_format='article')을 전문 PDF로 in-place 승격."""
+    cap = (limit or 10**9) if bulk else (min(limit, _RUN_CAP) if limit else _RUN_CAP)
+    async with async_session() as session:
+        q = (
+            select(Document.id)
+            .where(
+                Document.material_type == "paper",
+                Document.file_format == "article",
+                or_(
+                    _ARXIV_ID_EXPR.isnot(None),
+                    Document.extract_meta[("paper", "oa_url")].astext.isnot(None),
+                ),
+            )
+            .order_by(Document.id.desc())
+            .limit(cap)
+        )
+        ids = [r[0] for r in (await session.execute(q)).all()]
+
+    promoted = failed = 0
+    for doc_id in ids:
+        async with async_session() as session:
+            doc = await session.get(Document, doc_id)
+            if doc is None or doc.file_format != "article":
+                continue
+            paper = (doc.extract_meta or {}).get("paper") or {}
+            arxiv_id = paper.get("arxiv_id")
+            oa_status = (paper.get("oa_status") or "").lower()
+            if arxiv_id:
+                url = _ARXIV_PDF.format(id=arxiv_id)
+                key = arxiv_id.replace("/", "_")
+            elif paper.get("oa_url") and oa_status in _REAL_OA:
+                url = paper["oa_url"]  # doi.org/KISTI/PMC (friendly OA). 비-OA·paywall 은 헤더검증서 skip
+                key = (paper.get("openalex_id") or paper.get("doi") or "oa").replace("/", "_")
+            else:
+                continue
+            rel_path = f"crawl_raw/papers/{key}.pdf"
+            dest = Path(settings.nas_mount_path) / rel_path
+            try:
+                size = await _download(url, dest)
+            except Exception as e:  # noqa: BLE001 — 다운로드 실패 격리
+                logger.error(f"[promote] {key} 다운로드 실패: {e}")
+                failed += 1
+                continue
+            # in-place 승격: 초록 행 → 전문 PDF 행 (file_hash·extract_meta.paper 보존)
+            doc.file_path = rel_path
+            doc.file_format = "pdf"
+            doc.file_type = "immutable"
+            doc.file_size = size
+            doc.md_status = "pending"  # marker 재실행(기존 'skipped' 해제)
+            doc.md_extraction_error = None
+            await enqueue_stage(session, doc.id, "extract")
+            await session.commit()
+            promoted += 1
+            logger.info(f"[promote] {key} → 전문 PDF in-place (doc {doc.id}, {size}b)")
+
+    logger.info(f"[paper_fulltext_promote] 승격 {promoted} · 실패 {failed} (cap {cap})")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="논문 arXiv 전문 승격 (in-place, keyless)")
+    parser.add_argument("--bulk", action="store_true", help="cap 해제(전건 백필 — GPU 부하 주의)")
+    parser.add_argument("--limit", type=int, default=0, help="승격 상한(0=기본 cap 10)")
+    args = parser.parse_args()
+    asyncio.run(run(bulk=args.bulk, limit=args.limit))

clients/ds-app/Sources/AppFeature/Files/FileTransfer.swift

@@ -0,0 +1,63 @@
+import AppKit
+import Foundation
+
+/// macOS 파일 패널 + 네이티브 다운로드 헬퍼. AppKit(NSOpenPanel/NSSavePanel) 의존이라 AppFeature
+/// (맥OS UI 계층)에 둔다 — DSKit 은 크로스플랫폼 유지(향후 iOS/watchOS). 모두 @MainActor.
+@MainActor
+enum FilePanels {
+    /// 업로드할 파일 1개 선택. 취소 시 nil.
+    static func pickFileToUpload() -> URL? {
+        let panel = NSOpenPanel()
+        panel.allowsMultipleSelection = false
+        panel.canChooseDirectories = false
+        panel.canChooseFiles = true
+        panel.message = "업로드할 문서를 선택하세요"
+        panel.prompt = "업로드"
+        return panel.runModal() == .OK ? panel.url : nil
+    }
+
+    /// 저장 위치 선택. 취소 시 nil. 사용자가 고른 위치 = 샌드박스 쓰기 권한 부여(files.user-selected).
+    static func pickSaveDestination(suggestedName: String) -> URL? {
+        let panel = NSSavePanel()
+        panel.nameFieldStringValue = suggestedName
+        panel.message = "원본 파일을 저장할 위치"
+        panel.prompt = "저장"
+        return panel.runModal() == .OK ? panel.url : nil
+    }
+}
+
+/// 원본 파일 네이티브 다운로드. 인증은 URL 쿼리의 ?token= 으로만 이뤄지므로(헤더 아님), 토큰이 든
+/// URL 은 절대 로깅/에러 메시지에 노출하지 않는다. 저장 위치는 사용자가 NSSavePanel 로 선택.
+@MainActor
+enum FileDownloader {
+    enum Outcome: Equatable {
+        case saved(URL)
+        case cancelled
+        case failed(String)
+    }
+
+    /// `url` = DSDownload.fileURL 로 만든 ?token= 인증 URL. `suggestedName` = 원본 파일명.
+    static func download(from url: URL, suggestedName: String) async -> Outcome {
+        guard let dest = FilePanels.pickSaveDestination(suggestedName: suggestedName) else {
+            return .cancelled
+        }
+        do {
+            let (temp, response) = try await URLSession.shared.download(from: url)
+            // 다운로드된 임시 파일은 호출자 책임(async download 변형은 자동삭제 안 함) — 모든 종료
+            // 경로에서 정리. 성공 시 move 가 temp 를 옮긴 뒤라 removeItem 은 무해한 no-op.
+            defer { try? FileManager.default.removeItem(at: temp) }
+            if let http = response as? HTTPURLResponse, !(200..<300).contains(http.statusCode) {
+                // 상태 코드만 노출 — URL/토큰은 절대 포함하지 않는다.
+                return .failed("다운로드 실패 (HTTP \(http.statusCode))")
+            }
+            if FileManager.default.fileExists(atPath: dest.path) {
+                try FileManager.default.removeItem(at: dest)
+            }
+            try FileManager.default.moveItem(at: temp, to: dest)
+            return .saved(dest)
+        } catch {
+            // URLError/파일 오류의 localizedDescription 엔 URL 이 포함되지 않는다.
+            return .failed("저장 실패: \((error as NSError).localizedDescription)")
+        }
+    }
+}

clients/ds-app/Sources/AppFeature/Pages/AskView.swift

@@ -1,85 +0,0 @@
-import SwiftUI
-import AIFabric
-
-/// RAG proof page: routes corpusAsk through AIService (-> AIRouter -> MockAIProvider). Explicit backend
-/// pick sets explicitProvider; an explicit-unavailable result renders a visible, non-retrying error.
-struct AskView: View {
-    @Environment(AppModel.self) private var model
-    @State private var backend: BackendChoice = .auto
-
-    var body: some View {
-        @Bindable var model = model
-        ScrollView {
-            VStack(alignment: .leading, spacing: 14) {
-                Picker("백엔드", selection: $backend) {
-                    ForEach(BackendChoice.allCases) { Text($0.label).tag($0) }
-                }
-                .pickerStyle(.segmented)
-
-                HStack(spacing: 8) {
-                    TextField("코퍼스 전체에 질문", text: $model.askQuery)
-                        .textFieldStyle(.roundedBorder)
-                        .onSubmit { Task { await model.runAsk(backend: backend.provider) } }
-                    Button("질문") { Task { await model.runAsk(backend: backend.provider) } }
-                        .buttonStyle(.borderedProminent)
-                }
-
-                if let result = model.askResult {
-                    switch result {
-                    case .success(let response):
-                        AICompletionView(response: response) { docID in
-                            model.section = .documents
-                            Task { await model.openDocument(docID) }
-                        }
-                        if let meta = model.askMeta {
-                            HStack(spacing: 6) {
-                                Chip("완성도 \(meta.completeness)", Sage.muted)
-                                if let aspects = meta.coveredAspects {
-                                    ForEach(aspects, id: \.self) { Chip($0, Sage.brand) }
-                                }
-                            }
-                        }
-                    case .failure(let err):
-                        ErrorBanner(text: message(for: err))
-                    }
-                } else {
-                    EmptyState(text: "질문을 입력하세요").frame(minHeight: 160)
-                }
-            }
-            .padding(16)
-        }
-        .background(Sage.surface)
-    }
-
-    private func message(for error: AIServiceError) -> String {
-        switch error {
-        case .explicitUnavailable(let id):
-            return "\(id.displayName) 백엔드를 쓸 수 없습니다 — 다른 백엔드로 자동 전환하지 않았습니다. 다른 백엔드를 고르세요."
-        case .notConfigured(let id): return "\(id.displayName) 백엔드 미구성"
-        case .noneAvailable: return "응답 가능한 백엔드가 없습니다."
-        case .providerFailed(let s): return "응답 실패: \(s)"
-        case .unknown(let s): return "오류: \(s)"
-        }
-    }
-}
-
-enum BackendChoice: String, CaseIterable, Identifiable {
-    case auto, onDevice, localMLX, remoteDS
-    var id: String { rawValue }
-    var label: String {
-        switch self {
-        case .auto: return "자동"
-        case .onDevice: return "온디바이스"
-        case .localMLX: return "맥미니"
-        case .remoteDS: return "원격 DS"
-        }
-    }
-    var provider: AIProviderID? {
-        switch self {
-        case .auto: return nil
-        case .onDevice: return .onDevice
-        case .localMLX: return .localMLX
-        case .remoteDS: return .remoteDS
-        }
-    }
-}

clients/ds-app/Sources/AppFeature/Pages/DashboardView.swift

@@ -1,51 +1,386 @@
 import SwiftUI
+import DSKit
 
-/// Corpus-health overview (not a dumped table). Stat hero + domain distribution bars; tapping a
-/// domain jumps to Documents (cross-page nav proof).
+/// 홈 = 풀폭 데일리 코크핏 (시안 안1). detail 전폭을 받아 1000pt 캔버스로 좌측 정렬, 내부 2칼럼.
+/// 인사 → 오늘 스트립(검토 큐 + 속보 + 스탯) → 좌(빠른캡처·최근활동)/우(도메인분포·고정).
 struct DashboardView: View {
     @Environment(AppModel.self) private var model
 
     var body: some View {
-        ScrollView {
+        ScrollView(.vertical) {
             VStack(alignment: .leading, spacing: 18) {
-                if let s = model.stats {
-                    LazyVGrid(columns: [GridItem(.adaptive(minimum: 150), spacing: 12)], spacing: 12) {
-                        StatCard(title: "전체", value: s.total, color: Sage.brand)
-                        StatCard(title: "문서", value: s.counts["document"] ?? 0, color: Sage.brand)
-                        StatCard(title: "승인 대기", value: s.libraryPendingSuggestions, color: Sage.amber)
-                    }
-
-                    VStack(alignment: .leading, spacing: 10) {
-                        Text("카테고리 분포").font(.headline).foregroundStyle(Sage.ink)
-                        ForEach(s.counts.sorted { $0.value > $1.value }, id: \.key) { key, value in
-                            DomainBar(name: Self.categoryLabel(key), count: value, max: s.counts.values.max() ?? 1)
-                                .contentShape(Rectangle())
-                                .onTapGesture { model.section = .documents }
-                        }
-                    }
-                    .padding(16)
-                    .background(Sage.card, in: RoundedRectangle(cornerRadius: 14))
-                    .overlay(RoundedRectangle(cornerRadius: 14).stroke(Sage.line))
-                } else {
+                GreetingHeader()
+                if model.stats == nil && model.tree.isEmpty {
                     ProgressView().frame(maxWidth: .infinity, minHeight: 200)
+                } else {
+                    TodayStrip()
+                    HStack(alignment: .top, spacing: 18) {
+                        VStack(alignment: .leading, spacing: 18) {
+                            CaptureCard()
+                            ActivityTimeline()
+                        }
+                        .frame(maxWidth: .infinity)
+                        VStack(alignment: .leading, spacing: 18) {
+                            DomainDistribution()
+                            PinnedItems()
+                        }
+                        .frame(width: 312)
+                    }
                 }
             }
-            .padding(20)
+            .frame(maxWidth: 1000, alignment: .leading)
+            .padding(.horizontal, 30)
+            .padding(.vertical, 26)
         }
+        .frame(maxWidth: .infinity, alignment: .topLeading)
         .background(Sage.surface)
     }
+}
 
-    /// 서버 category enum → 표시명 (미등록 키는 raw 노출 — 신규 카테고리 추가에 안전).
-    static func categoryLabel(_ key: String) -> String {
-        switch key {
-        case "document": return "문서"
-        case "library": return "자료실"
-        case "news": return "뉴스"
-        case "law": return "법령"
-        case "memo": return "메모"
-        case "audio": return "오디오"
-        case "video": return "비디오"
-        default: return key
+// MARK: - Greeting
+
+private struct GreetingHeader: View {
+    @Environment(AppModel.self) private var model
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 3) {
+            HStack(alignment: .firstTextBaseline, spacing: 10) {
+                Text("안녕하세요, \(model.currentUser?.username ?? "사용자")")
+                    .font(.system(size: 22, weight: .bold)).kerning(-0.4).foregroundStyle(Sage.ink)
+                Text("오늘도 지식 쌓는 날.").font(.callout).foregroundStyle(Sage.muted)
+            }
+            Text(Self.today).font(.caption).foregroundStyle(Sage.muted.opacity(0.8))
         }
+        .padding(.bottom, 4)
+    }
+
+    static var today: String {
+        let f = DateFormatter()
+        f.locale = Locale(identifier: "ko_KR")
+        f.dateFormat = "y년 M월 d일 EEEE"
+        return f.string(from: Date())
     }
 }
+
+// MARK: - Today strip (hero)
+
+private struct TodayStrip: View {
+    @Environment(AppModel.self) private var model
+
+    var body: some View {
+        VStack(spacing: 14) {
+            HStack(alignment: .top, spacing: 0) {
+                reviewQueue
+                    .frame(minWidth: 150, alignment: .leading)
+                Rectangle().fill(Sage.line).frame(width: 1).padding(.horizontal, 22)
+                digestTeaser
+                    .frame(maxWidth: .infinity, alignment: .leading)
+            }
+            Divider().overlay(Sage.line)
+            statRow
+        }
+        .dashCard(padding: 20)
+    }
+
+    private var reviewQueue: some View {
+        VStack(alignment: .leading, spacing: 4) {
+            Text(model.reviewPendingCount.map(String.init) ?? "—")
+                .font(.system(size: 38, weight: .bold)).kerning(-1.5).monospacedDigit()
+                .foregroundStyle(Sage.amber)
+            Text("검토 대기 문서").font(.caption).foregroundStyle(Sage.muted)
+            Button { model.section = .documents } label: {
+                Text("검토 시작 →").font(.caption.weight(.semibold)).foregroundStyle(Sage.brand)
+            }
+            .buttonStyle(.plain)
+        }
+    }
+
+    @ViewBuilder private var digestTeaser: some View {
+        if let t = topTopic {
+            Button { model.section = .digest } label: {
+                VStack(alignment: .leading, spacing: 6) {
+                    HStack(spacing: 8) {
+                        Chip("속보", Sage.danger)
+                        Text("\(model.digest?.digestDateDisplay ?? "") 브리핑")
+                            .font(.caption2).foregroundStyle(Sage.muted)
+                    }
+                    Text(t.label).font(.system(size: 15)).foregroundStyle(Sage.ink)
+                        .lineLimit(2).fixedSize(horizontal: false, vertical: true)
+                        .multilineTextAlignment(.leading)
+                    Text(t.meta).font(.caption2).foregroundStyle(Sage.muted)
+                }
+                .frame(maxWidth: .infinity, alignment: .leading)
+            }
+            .buttonStyle(.plain)
+        } else {
+            Text("오늘 브리핑이 아직 없습니다").font(.callout).foregroundStyle(Sage.muted)
+                .frame(maxWidth: .infinity, alignment: .leading)
+        }
+    }
+
+    private var statRow: some View {
+        HStack(spacing: 0) {
+            StatCell(value: model.stats?.total ?? 0, label: "전체", color: Sage.brand)
+            StatCell(value: model.stats?.counts["document"] ?? 0, label: "문서")
+            StatCell(value: domainCount("Industrial_Safety"), label: "산업안전",
+                     color: Sage.domainColor("Industrial_Safety"))
+            StatCell(value: domainCount("Engineering"), label: "엔지니어링",
+                     color: Sage.domainColor("Engineering"))
+            StatCell(value: domainCount("General"), label: "자료실", color: Sage.domainColor("General"))
+            StatCell(value: model.stats?.counts["memo"] ?? model.memoList.count, label: "메모")
+        }
+    }
+
+    private func domainCount(_ name: String) -> Int {
+        model.tree.first { $0.name == name }?.count ?? 0
+    }
+
+    private var topTopic: (label: String, meta: String)? {
+        guard let digest = model.digest else { return nil }
+        var best: (TopicResponse, String)?
+        for c in digest.countries {
+            for t in c.topics where best == nil || (t.importanceScore ?? 0) > (best!.0.importanceScore ?? 0) {
+                best = (t, c.country)
+            }
+        }
+        guard let (t, country) = best else { return nil }
+        let arts = t.articleCount ?? t.articles.count
+        var meta = "관련 기사 \(arts)건"
+        if let imp = t.importanceScore { meta += " · 중요도 \(String(format: "%.0f", imp))" }
+        if !country.isEmpty { meta += " · \(country)" }
+        return (t.topicLabel, meta)
+    }
+}
+
+// MARK: - Left column
+
+private struct CaptureCard: View {
+    @Environment(AppModel.self) private var model
+
+    var body: some View {
+        @Bindable var m = model
+        VStack(alignment: .leading, spacing: 12) {
+            SectionLabel("빠른 캡처")
+            HStack(spacing: 8) {
+                TextField("메모 한 줄 남기기…", text: $m.captureText)
+                    .textFieldStyle(.plain)
+                    .padding(.horizontal, 14).frame(height: 38)
+                    .background(Sage.surface, in: RoundedRectangle(cornerRadius: 8))
+                    .overlay(RoundedRectangle(cornerRadius: 8).stroke(Sage.line))
+                    .onSubmit { Task { await model.saveMemo() } }
+                Button { Task { await model.saveMemo() } } label: {
+                    Text("저장").font(.callout.weight(.semibold)).foregroundStyle(.white)
+                        .padding(.horizontal, 18).frame(height: 38)
+                        .background(Sage.brand, in: RoundedRectangle(cornerRadius: 8))
+                }
+                .buttonStyle(.plain)
+                .disabled(model.captureText.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
+            }
+            Button {
+                guard let url = FilePanels.pickFileToUpload() else { return }
+                Task { await model.uploadPicked(url) }
+            } label: {
+                Text("＋ 파일 업로드").font(.caption.weight(.semibold)).foregroundStyle(Sage.brand)
+                    .padding(.horizontal, 10).padding(.vertical, 5)
+                    .background(Sage.brand.opacity(0.12), in: Capsule())
+            }
+            .buttonStyle(.plain)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .dashCard()
+    }
+}
+
+private struct ActivityTimeline: View {
+    @Environment(AppModel.self) private var model
+
+    private var recent: [DocumentResponse] {
+        model.documentList
+            .sorted { ($0.updatedAt ?? .distantPast) > ($1.updatedAt ?? .distantPast) }
+            .prefix(5).map { $0 }
+    }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            HStack(alignment: .firstTextBaseline) {
+                SectionLabel("최근 활동")
+                Spacer()
+                Button { model.section = .documents } label: {
+                    Text("전체 보기 →").font(.caption.weight(.semibold)).foregroundStyle(Sage.brand)
+                }
+                .buttonStyle(.plain)
+            }
+            if recent.isEmpty {
+                Text("최근 활동이 없습니다").font(.caption).foregroundStyle(Sage.muted)
+            } else {
+                VStack(spacing: 0) {
+                    ForEach(Array(recent.enumerated()), id: \.element.id) { idx, doc in
+                        ActivityRow(doc: doc, isLast: idx == recent.count - 1)
+                        if idx != recent.count - 1 { Divider().overlay(Sage.line) }
+                    }
+                }
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .dashCard()
+    }
+}
+
+private struct ActivityRow: View {
+    @Environment(AppModel.self) private var model
+    let doc: DocumentResponse
+    let isLast: Bool
+
+    var body: some View {
+        HStack(alignment: .top, spacing: 12) {
+            Text(Self.relative(doc.updatedAt))
+                .font(.caption2).foregroundStyle(Sage.muted)
+                .frame(width: 54, alignment: .trailing)
+            VStack(spacing: 0) {
+                Circle().fill(Sage.domainColor(doc.aiDomain)).frame(width: 8, height: 8).padding(.top, 4)
+                if !isLast { Rectangle().fill(Sage.line).frame(width: 1).frame(maxHeight: .infinity) }
+            }
+            .frame(width: 14)
+            VStack(alignment: .leading, spacing: 3) {
+                Text("\(localizedDomain(doc.aiDomain)) · \(doc.displayFormat.uppercased())")
+                    .font(.caption2.weight(.bold)).foregroundStyle(Sage.domainColor(doc.aiDomain))
+                Text(doc.title ?? doc.downloadLabel).font(.callout).foregroundStyle(Sage.ink).lineLimit(2)
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+            .padding(.bottom, isLast ? 0 : 10)
+        }
+        .contentShape(Rectangle())
+        .onTapGesture { model.section = .documents; Task { await model.openDocument(doc.id) } }
+    }
+
+    static func relative(_ date: Date?) -> String {
+        guard let date else { return "" }
+        let f = RelativeDateTimeFormatter()
+        f.locale = Locale(identifier: "ko_KR")
+        f.unitsStyle = .short
+        return f.localizedString(for: date, relativeTo: Date())
+    }
+}
+
+// MARK: - Right column
+
+private struct DomainDistribution: View {
+    @Environment(AppModel.self) private var model
+
+    private var domains: [DomainTreeNode] { model.tree.sorted { $0.count > $1.count } }
+    private var domainTotal: Int { domains.reduce(0) { $0 + $1.count } }
+    private var sum: Int { max(1, domainTotal) }   // 0-나눗셈 가드 (막대 폭 분모 전용)
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            SectionLabel("도메인 분포")
+            // 헤드라인 합계 = 막대/범례와 동일 분모(도메인 트리 합) — 사용자가 범례를 더해 같은 값에 도달.
+            HStack(alignment: .firstTextBaseline, spacing: 3) {
+                Text("분류").font(.caption).foregroundStyle(Sage.muted)
+                Text("\(domainTotal)").font(.system(size: 18, weight: .semibold))
+                    .monospacedDigit().foregroundStyle(Sage.ink)
+                Text("건").font(.caption).foregroundStyle(Sage.muted)
+            }
+            GeometryReader { geo in
+                HStack(spacing: 2) {
+                    ForEach(domains) { d in
+                        Rectangle().fill(Sage.domainColor(d.name))
+                            .frame(width: max(2, geo.size.width * CGFloat(d.count) / CGFloat(sum)))
+                    }
+                }
+            }
+            .frame(height: 8)
+            .clipShape(RoundedRectangle(cornerRadius: 4))
+            VStack(spacing: 7) {
+                ForEach(domains) { d in
+                    Button {
+                        model.section = .documents
+                        Task { await model.loadDocuments(domain: d.path) }
+                    } label: {
+                        HStack(spacing: 8) {
+                            RoundedRectangle(cornerRadius: 2).fill(Sage.domainColor(d.name)).frame(width: 10, height: 10)
+                            Text(localizedDomain(d.name)).font(.caption).foregroundStyle(Sage.ink)
+                                .lineLimit(1).frame(maxWidth: .infinity, alignment: .leading)
+                            Text("\(d.count)").font(.caption.monospacedDigit()).foregroundStyle(Sage.muted)
+                        }
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .dashCard()
+    }
+}
+
+private struct PinnedItems: View {
+    @Environment(AppModel.self) private var model
+
+    private var docs: [DocumentResponse] { model.documentList.filter { $0.pinned == true } }
+    private var memos: [MemoResponse] { model.memoList.filter { $0.isPinned } }
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 12) {
+            HStack {
+                SectionLabel("고정 항목")
+                Spacer()
+                Button { model.section = .documents } label: {
+                    Text("관리 →").font(.caption.weight(.semibold)).foregroundStyle(Sage.brand)
+                }
+                .buttonStyle(.plain)
+            }
+            if docs.isEmpty && memos.isEmpty {
+                Text("고정된 항목이 없습니다").font(.caption).foregroundStyle(Sage.muted)
+            } else {
+                VStack(spacing: 8) {
+                    ForEach(docs) { d in
+                        PinRow(kind: "문서", kindColor: Sage.domainColor("Engineering"),
+                               title: d.title ?? d.downloadLabel, date: d.updatedAtRaw) {
+                            model.section = .documents; Task { await model.openDocument(d.id) }
+                        }
+                    }
+                    ForEach(memos) { m in
+                        PinRow(kind: "메모", kindColor: Sage.brand,
+                               title: m.title ?? (m.content ?? "메모"), date: m.updatedAtRaw ?? "") {
+                            model.section = .memos; Task { await model.openMemo(m.id) }
+                        }
+                    }
+                }
+            }
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .dashCard()
+    }
+}
+
+private struct PinRow: View {
+    let kind: String
+    let kindColor: Color
+    let title: String
+    let date: String
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: action) {
+            HStack(alignment: .top, spacing: 10) {
+                Chip(kind, kindColor)
+                Text(title).font(.caption).foregroundStyle(Sage.ink).lineLimit(2)
+                    .frame(maxWidth: .infinity, alignment: .leading)
+                Text(date.prefix(10)).font(.caption2.monospacedDigit()).foregroundStyle(Sage.muted)
+            }
+            .padding(10)
+            .background(Sage.surface, in: RoundedRectangle(cornerRadius: 8))
+        }
+        .buttonStyle(.plain)
+    }
+}
+
+#if DEBUG
+#Preview("Dashboard") {
+    @Previewable @State var model = AppModel.preview
+    DashboardView()
+        .environment(model)
+        .frame(width: 1100, height: 760)
+        .task { await model.bootstrap() }
+}
+#endif

clients/ds-app/Sources/AppFeature/Pages/DocumentsView.swift

@@ -1,91 +1,367 @@
 import SwiftUI
 import DSKit
 
-struct DocumentListView: View {
+/// 문서 = DEVONthink식 컬럼 브라우저. 소스트리(분류)는 글로벌 사이드바에 있고, 이 페이지는 detail
+/// 전폭 안에서 내부 HSplitView 3-pane = 컬럼 리스트 | MD 리더 | 인스펙터(토글). 도메인 필터는
+/// 사이드바가 model.loadDocuments(domain:) 로 서버 재조회.
+struct DocumentsBrowser: View {
     @Environment(AppModel.self) private var model
+    @State private var showInspector = true
+    @State private var sortOrder = [KeyPathComparator(\DocumentResponse.sortUpdated, order: .reverse)]
+
+    var body: some View {
+        HSplitView {
+            DocumentListTable(sortOrder: $sortOrder)
+                .frame(minWidth: 300, idealWidth: 360, maxWidth: 460)
+            DocumentReader(showInspector: $showInspector)
+                .frame(minWidth: 420, maxWidth: .infinity)
+            if showInspector, let d = model.documentDetail {
+                DocumentInspector(detail: d)
+                    .frame(minWidth: 280, idealWidth: 320, maxWidth: 360)
+            }
+        }
+        .task { await model.ensureDocumentsLoaded() }   // 진입 시 현재 필터 전체 문서 load-all
+    }
+}
+
+// MARK: - Column list (sortable Table)
+
+private extension DocumentResponse {
+    var sortTitle: String { title ?? downloadLabel }
+    var sortFormat: String { (originalFormat ?? fileFormat ?? "").lowercased() }
+    var sortUpdated: String { updatedAtRaw }
+    /// "PDF→MD" / "MD" 식 종류 배지 라벨.
+    var formatBadge: String {
+        if let orig = originalFormat, orig.lowercased() != (fileFormat ?? "").lowercased() {
+            return "\(orig.uppercased())→MD"
+        }
+        return displayFormat.uppercased()
+    }
+}
+
+struct DocumentListTable: View {
+    @Environment(AppModel.self) private var model
+    @Binding var sortOrder: [KeyPathComparator<DocumentResponse>]
+
+    private var documents: [DocumentResponse] { model.documentList.sorted(using: sortOrder) }
 
     var body: some View {
         let selection = Binding<Int?>(
             get: { model.selectedDocumentID },
             set: { if let id = $0 { Task { await model.openDocument(id) } } }
         )
-        List(model.documentList, selection: selection) { doc in
-            DocumentRow(doc: doc)
-        }
-        .listStyle(.inset)
-        .background(Sage.surface)
-    }
-}
-
-struct DocumentRow: View {
-    let doc: DocumentResponse
-    var body: some View {
-        VStack(alignment: .leading, spacing: 4) {
-            HStack(spacing: 6) {
-                Chip(doc.displayFormat.uppercased(), Sage.formatColor(doc.displayFormat))
-                Text(doc.title ?? doc.downloadLabel)
-                    .font(.callout.weight(.medium)).foregroundStyle(Sage.ink).lineLimit(1)
-                Spacer()
-                if doc.pinned == true { Text("고정").font(.caption2).foregroundStyle(Sage.amber) }
-            }
-            HStack(spacing: 6) {
-                if let d = doc.aiDomain { Chip(d, Sage.domainColor(d)) }
-                if let r = doc.reviewStatus {
-                    Text(r).font(.caption2).foregroundStyle(Sage.reviewStatusColor(r))
+        Group {
+            if model.documentList.isEmpty {
+                EmptyState(text: "문서가 없습니다")
+            } else {
+                Table(documents, selection: selection, sortOrder: $sortOrder) {
+                    TableColumn("제목", value: \.sortTitle) { doc in
+                        VStack(alignment: .leading, spacing: 2) {
+                            Text(doc.title ?? doc.downloadLabel)
+                                .font(.system(size: 12.5, weight: .semibold)).foregroundStyle(Sage.ink).lineLimit(1)
+                            Text(localizedDomain(doc.aiDomain))
+                                .font(.system(size: 11)).foregroundStyle(Sage.muted).lineLimit(1)
+                        }
+                        .padding(.vertical, 2)
+                    }
+                    TableColumn("종류", value: \.sortFormat) { doc in
+                        Chip(doc.formatBadge, Sage.formatColor(doc.originalFormat ?? doc.displayFormat))
+                    }
+                    .width(min: 66, ideal: 74, max: 96)
+                    TableColumn("수정", value: \.sortUpdated) { doc in
+                        Text(doc.updatedAtRaw.prefix(10))
+                            .font(.caption2.monospacedDigit()).foregroundStyle(Sage.muted)
+                    }
+                    .width(min: 78, ideal: 86, max: 110)
                 }
-                Spacer()
-                Text(doc.updatedAtRaw.prefix(10)).font(.caption2.monospacedDigit()).foregroundStyle(Sage.muted)
+                .tint(Sage.brand)
             }
         }
-        .padding(.vertical, 4)
+        .background(Sage.card)
     }
 }
 
-/// MD-first detail: render md_content when renderable, else extracted_text fallback + 'MD 변환 대기'
-/// badge + emphasized original-download button. (Download builds a real-shaped ?token= URL.)
-struct DocumentDetailView: View {
+// MARK: - Reader
+
+struct DocumentReader: View {
     @Environment(AppModel.self) private var model
+    @Binding var showInspector: Bool
+
+    var body: some View {
+        Group {
+            if let detail = model.documentDetail {
+                VStack(spacing: 0) {
+                    ReaderHeader(detail: detail, showInspector: $showInspector)
+                    ReaderBody(detail: detail)
+                }
+            } else {
+                EmptyState(text: "문서를 선택하세요")
+            }
+        }
+        .background(Sage.card)
+    }
+}
+
+private struct ReaderHeader: View {
+    let detail: DocumentDetailResponse
+    @Binding var showInspector: Bool
+
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            Text(crumb).font(.system(size: 11)).foregroundStyle(Sage.muted).lineLimit(1)
+            HStack(alignment: .firstTextBaseline, spacing: 10) {
+                Text(detail.base.title ?? detail.base.downloadLabel)
+                    .font(.system(size: 18, weight: .heavy)).foregroundStyle(Sage.ink).lineLimit(2)
+                Spacer()
+                DownloadButton(doc: detail.base, compact: true)
+                inspectorToggle
+            }
+            metaBadges
+            tagRow
+        }
+        .padding(.horizontal, 26).padding(.vertical, 14)
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(Sage.card)
+        .overlay(alignment: .bottom) { Rectangle().fill(Sage.line).frame(height: 1) }
+    }
+
+    private var crumb: String {
+        let dom = localizedDomain(detail.base.aiDomain)
+        if let sub = detail.base.aiSubGroup, !sub.isEmpty { return "\(dom) › \(sub)" }
+        return dom
+    }
+
+    /// 웹 상세 페이지 헤더 배지: 도메인 · 문서유형 · tier DEEP · 신뢰도 · PDF→MD success.
+    @ViewBuilder private var metaBadges: some View {
+        let b = detail.base
+        ScrollView(.horizontal, showsIndicators: false) {
+            HStack(spacing: 6) {
+                if let d = b.aiDomain { Chip(localizedDomain(d), Sage.domainColor(d)) }
+                if let t = b.documentType, !t.isEmpty { Chip(t, Sage.muted) }
+                if b.aiAnalysisTier == "deep" { Chip("tier DEEP", Sage.brand) }
+                if let c = b.aiConfidence { Chip("신뢰도 \(String(format: "%.2f", c))", Sage.brandDark) }
+                if detail.mdIsRenderable { Chip("PDF→MD success", Sage.mdStatusColor("completed")) }
+            }
+        }
+    }
+
+    private var inspectorToggle: some View {
+        Button { withAnimation(.easeInOut(duration: 0.2)) { showInspector.toggle() } } label: {
+            Image(systemName: "info.circle").font(.system(size: 15))
+                .foregroundStyle(showInspector ? Sage.brandDark : Sage.muted)
+                .frame(width: 30, height: 30)
+                .background(showInspector ? Sage.brand.opacity(0.14) : Sage.card, in: RoundedRectangle(cornerRadius: 8))
+                .overlay(RoundedRectangle(cornerRadius: 8).stroke(showInspector ? Sage.brand : Sage.line))
+        }
+        .buttonStyle(.plain)
+        .help("인스펙터")
+    }
+
+    @ViewBuilder private var tagRow: some View {
+        let tags = detail.base.aiTags ?? []
+        if detail.mdStatus != nil || !tags.isEmpty {
+            ScrollView(.horizontal, showsIndicators: false) {
+                HStack(spacing: 6) {
+                    if let st = detail.mdStatus { Chip("MD \(st)", Sage.mdStatusColor(st)) }
+                    ForEach(tags, id: \.self) { Chip($0, Sage.brand) }
+                }
+            }
+        }
+    }
+}
+
+private struct ReaderBody: View {
     let detail: DocumentDetailResponse
 
     var body: some View {
         ScrollView {
-            VStack(alignment: .leading, spacing: 14) {
-                Text(detail.base.title ?? detail.base.downloadLabel)
-                    .font(.title2.weight(.bold)).foregroundStyle(Sage.ink)
-
-                HStack(spacing: 8) {
-                    if let d = detail.base.aiDomain { Chip(d, Sage.domainColor(d)) }
-                    Chip(detail.base.displayFormat.uppercased(), Sage.formatColor(detail.base.displayFormat))
-                    if let conf = detail.base.aiConfidence {
-                        Chip("AI \(String(format: "%.0f%%", conf * 100))", Sage.muted)
-                    }
-                    Spacer()
-                    if let url = model.downloadURL(for: detail.base) {
-                        Link(detail.base.downloadLabel, destination: url).font(.callout.weight(.semibold))
-                    }
-                }
-
-                if let tags = detail.base.aiTags, !tags.isEmpty {
-                    HStack(spacing: 6) { ForEach(tags, id: \.self) { Chip($0, Sage.brand) } }
-                }
-
-                Divider()
-
-                if detail.mdIsRenderable, let md = detail.mdContent {
-                    MarkdownView(md)
-                } else {
-                    HStack { Chip("MD 변환 대기", Sage.amber); Spacer() }
-                    Text(detail.extractedText ?? "본문 없음")
-                        .font(.body).foregroundStyle(Sage.muted)
-                        .frame(maxWidth: .infinity, alignment: .leading)
-                    if let url = model.downloadURL(for: detail.base) {
-                        Link("원본 다운로드 — \(detail.base.downloadLabel)", destination: url)
-                            .font(.callout.weight(.semibold))
+            HStack(spacing: 0) {
+                Spacer(minLength: 0)
+                VStack(alignment: .leading, spacing: 14) {
+                    if detail.mdIsRenderable, let md = detail.mdContent {
+                        MarkdownView(md)
+                    } else {
+                        HStack { Chip("MD 변환 대기", Sage.amber); Spacer() }
+                        Text(detail.extractedText ?? "본문 없음")
+                            .font(.body).foregroundStyle(Sage.muted)
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                        DownloadButton(doc: detail.base, compact: false)
                     }
                 }
+                .frame(maxWidth: 700, alignment: .leading)
+                Spacer(minLength: 0)
+            }
+            .padding(.horizontal, 28).padding(.top, 22).padding(.bottom, 44)
+        }
+        .background(Sage.card)
+    }
+}
+
+// MARK: - Inspector
+
+struct DocumentInspector: View {
+    let detail: DocumentDetailResponse
+
+    private var base: DocumentResponse { detail.base }
+
+    var body: some View {
+        ScrollView {
+            VStack(alignment: .leading, spacing: 18) {
+                // 인사이트 (웹 상세 페이지 양식: TL;DR · 핵심점 · 심층 · 불일치)
+                if let tldr = (base.aiTldr ?? base.aiSummary), !tldr.isEmpty {
+                    InspectorSection("TL;DR") {
+                        Text(tldr).font(.system(size: 12)).foregroundStyle(Sage.ink).lineSpacing(2)
+                            .frame(maxWidth: .infinity, alignment: .leading)
+                    }
+                }
+                if let bullets = base.aiBullets, !bullets.isEmpty {
+                    InspectorSection("핵심점") {
+                        VStack(alignment: .leading, spacing: 6) {
+                            ForEach(bullets, id: \.self) { b in
+                                HStack(alignment: .top, spacing: 6) {
+                                    Text("·").font(.system(size: 12, weight: .bold)).foregroundStyle(Sage.amber)
+                                    Text(b).font(.system(size: 12)).foregroundStyle(Sage.ink)
+                                        .frame(maxWidth: .infinity, alignment: .leading)
+                                }
+                            }
+                        }
+                    }
+                }
+                if let deep = base.aiDetailSummary, !deep.isEmpty {
+                    InspectorSection("심층") {
+                        VStack(alignment: .leading, spacing: 6) {
+                            if base.aiAnalysisTier == "deep" { Chip("DEEP", Sage.brand) }
+                            Text(deep).font(.system(size: 11.5)).foregroundStyle(Sage.ink).lineSpacing(2)
+                                .frame(maxWidth: .infinity, alignment: .leading)
+                        }
+                    }
+                }
+                if let inc = base.aiInconsistencies, !inc.isEmpty {
+                    InspectorSection("불일치 \(inc.count)") {
+                        VStack(alignment: .leading, spacing: 5) {
+                            ForEach(inc, id: \.self) { x in
+                                Text("· \(x)").font(.system(size: 11.5)).foregroundStyle(Sage.ink)
+                                    .frame(maxWidth: .infinity, alignment: .leading)
+                            }
+                        }
+                    }
+                }
+                // 정보
+                InspectorSection("정보") {
+                    VStack(spacing: 0) {
+                        KV("종류", base.formatBadge)
+                        KV("도메인", localizedDomain(base.aiDomain))
+                        KV("하위", base.aiSubGroup ?? "—")
+                        KV("수정", String(base.updatedAtRaw.prefix(10)))
+                        if let size = base.fileSize {
+                            KV("원본", ByteCountFormatter.string(fromByteCount: Int64(size), countStyle: .file))
+                        }
+                        if let st = detail.mdStatus { KV("md 상태", st, color: Sage.mdStatusColor(st)) }
+                        if let tier = base.aiAnalysisTier { KV("tier", tier, color: Sage.brandDark) }
+                        if let c = base.aiConfidence { KV("신뢰도", String(format: "%.2f", c), color: Sage.brand) }
+                        KV("읽음", "\(base.reads)회")
+                    }
+                }
+                if let tags = base.aiTags, !tags.isEmpty {
+                    InspectorSection("태그") { TagWrap(tags: tags) }
+                }
+            }
+            .padding(.horizontal, 16).padding(.vertical, 18)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+        .background(Sage.sidebar)
+        .overlay(alignment: .leading) { Rectangle().fill(Sage.line).frame(width: 1) }
+    }
+}
+
+private struct InspectorSection<Content: View>: View {
+    let title: String
+    @ViewBuilder let content: Content
+    init(_ title: String, @ViewBuilder content: () -> Content) { self.title = title; self.content = content() }
+    var body: some View {
+        VStack(alignment: .leading, spacing: 8) {
+            Text(title).font(.system(size: 10, weight: .heavy)).tracking(0.8)
+                .textCase(.uppercase).foregroundStyle(Sage.muted.opacity(0.8))
+            content
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+}
+
+private struct KV: View {
+    let k: String
+    let v: String
+    var color: Color = Sage.ink
+    init(_ k: String, _ v: String, color: Color = Sage.ink) { self.k = k; self.v = v; self.color = color }
+    var body: some View {
+        HStack {
+            Text(k).font(.system(size: 12)).foregroundStyle(Sage.muted)
+            Spacer()
+            Text(v).font(.system(size: 12, weight: .semibold)).foregroundStyle(color)
+                .multilineTextAlignment(.trailing)
+        }
+        .padding(.vertical, 3)
+    }
+}
+
+/// 좁은 인스펙터용 태그 줄바꿈 (2개씩 한 줄 — 커스텀 Layout 없이 결정적).
+private struct TagWrap: View {
+    let tags: [String]
+    var body: some View {
+        VStack(alignment: .leading, spacing: 6) {
+            ForEach(Array(stride(from: 0, to: tags.count, by: 2)), id: \.self) { i in
+                HStack(spacing: 6) {
+                    Chip(tags[i], Sage.brand)
+                    if i + 1 < tags.count { Chip(tags[i + 1], Sage.brand) }
+                    Spacer(minLength: 0)
+                }
+            }
+        }
+    }
+}
+
+// MARK: - Native download button (preserved)
+
+/// 원본 파일 네이티브 다운로드 버튼. ?token= 인증 URL 을 NSSavePanel 로 고른 위치에 저장(브라우저
+/// 핸드오프 아님). 진행 스피너 + 저장 결과/오류를 인라인 표시. note 문서는 다운로드 대상 없음 → 숨김.
+struct DownloadButton: View {
+    @Environment(AppModel.self) private var model
+    let doc: DocumentResponse
+    /// compact = 헤더용 짧은 라벨(파일명만) / false = 본문 폴백용 긴 라벨.
+    var compact: Bool
+
+    @State private var busy = false
+    @State private var status: String?
+    @State private var isError = false
+
+    var body: some View {
+        if let url = model.downloadURL(for: doc) {
+            HStack(spacing: 8) {
+                Button {
+                    Task {
+                        busy = true; status = nil; isError = false
+                        let outcome = await FileDownloader.download(from: url, suggestedName: doc.downloadLabel)
+                        busy = false
+                        switch outcome {
+                        case .saved(let dest): status = "저장됨: \(dest.lastPathComponent)"; isError = false
+                        case .cancelled: status = nil
+                        case .failed(let msg): status = msg; isError = true
+                        }
+                    }
+                } label: {
+                    Label(compact ? doc.downloadLabel : "원본 다운로드 — \(doc.downloadLabel)",
+                          systemImage: "arrow.down.circle")
+                        .font(.callout.weight(.semibold))
+                }
+                .buttonStyle(.borderless)
+                .disabled(busy)
+                if busy { ProgressView().controlSize(.small) }
+                if let s = status {
+                    Text(s).font(.caption)
+                        .foregroundStyle(isError ? Sage.danger : Sage.muted)
+                        .lineLimit(1)
+                }
             }
-            .padding(20)
         }
-        .background(Sage.surface)
     }
 }

clients/ds-app/Sources/AppFeature/Pages/MemosView.swift

@@ -13,11 +13,10 @@ struct MemoListView: View {
                     .textFieldStyle(.roundedBorder)
                 Button("저장") {
                     let content = draft
-                    draft = ""
-                    Task { _ = try? await model.client.createMemo(MemoCreate(content: content)) }
+                    Task { if await model.saveMemo(content) { draft = "" } }
                 }
                 .buttonStyle(.bordered)
-                .disabled(draft.isEmpty)
+                .disabled(draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty)
             }
             .padding(12)
 

clients/ds-app/Sources/AppFeature/Pages/SearchView.swift

@@ -1,50 +0,0 @@
-import SwiftUI
-import DSKit
-
-/// Distinct from the Documents table: relevance-forward result cards (score bar + match_reason).
-struct SearchView: View {
-    @Environment(AppModel.self) private var model
-
-    var body: some View {
-        @Bindable var model = model
-        VStack(alignment: .leading, spacing: 0) {
-            HStack(spacing: 8) {
-                TextField("검색어를 입력하세요", text: $model.searchQuery)
-                    .textFieldStyle(.roundedBorder)
-                    .onSubmit { Task { await model.runSearch() } }
-                Button("검색") { Task { await model.runSearch() } }
-                    .buttonStyle(.borderedProminent)
-            }
-            .padding(12)
-
-            if let response = model.searchResponse {
-                List(response.results) { result in
-                    VStack(alignment: .leading, spacing: 5) {
-                        HStack(spacing: 6) {
-                            if let d = result.aiDomain { Chip(d, Sage.domainColor(d)) }
-                            Text(result.title ?? "문서 \(result.id)")
-                                .font(.callout.weight(.medium)).foregroundStyle(Sage.ink).lineLimit(1)
-                            Spacer()
-                            if let m = result.matchReason {
-                                Text(m).font(.caption2).foregroundStyle(Sage.muted)
-                            }
-                        }
-                        Text(result.snippet ?? result.aiSummary ?? "")
-                            .font(.caption).foregroundStyle(Sage.muted).lineLimit(2)
-                        if let score = result.score { ScoreBar(score: score) }
-                    }
-                    .padding(.vertical, 4)
-                    .contentShape(Rectangle())
-                    .onTapGesture {
-                        model.section = .documents
-                        Task { await model.openDocument(result.id) }
-                    }
-                }
-                .listStyle(.inset)
-            } else {
-                EmptyState(text: "검색어를 입력하세요")
-            }
-        }
-        .background(Sage.surface)
-    }
-}

clients/ds-app/Sources/AppFeature/Shell/Components.swift

@@ -1,5 +1,58 @@
 import SwiftUI
 
+/// 도메인 raw 값(영문/한자 enum 키) → 한글 표시 라벨. 색은 Sage.domainColor(raw) 가 raw 로 키잉하므로
+/// 색에는 raw, 표시에만 이 라벨을 쓴다. 미매핑은 원본 그대로.
+func localizedDomain(_ raw: String?) -> String {
+    guard let raw, !raw.isEmpty else { return "미분류" }
+    // 경로형(Philosophy/Aesthetics)이면 leaf 만 매핑 시도, 없으면 leaf 원본
+    let leaf = raw.split(separator: "/").last.map(String.init) ?? raw
+    let map: [String: String] = [
+        "Engineering": "엔지니어링", "Industrial_Safety": "산업안전", "General": "자료실",
+        "Programming": "프로그래밍", "법령": "법령", "Philosophy": "철학",
+    ]
+    return map[raw] ?? map[leaf] ?? leaf
+}
+
+/// 카드/섹션 머리말 라벨 (대문자·heavy·muted) — 대시보드/인스펙터 공용.
+struct SectionLabel: View {
+    let text: String
+    init(_ text: String) { self.text = text }
+    var body: some View {
+        Text(text)
+            .font(.caption.weight(.heavy))
+            .textCase(.uppercase)
+            .kerning(0.7)
+            .foregroundStyle(Sage.muted)
+    }
+}
+
+/// 공용 카드 크롬 (Sage.card + corner 12 + Sage.line stroke + 패딩).
+struct DashCard: ViewModifier {
+    var padding: CGFloat = 18
+    func body(content: Content) -> some View {
+        content
+            .padding(padding)
+            .background(Sage.card, in: RoundedRectangle(cornerRadius: 12))
+            .overlay(RoundedRectangle(cornerRadius: 12).stroke(Sage.line))
+    }
+}
+extension View { func dashCard(padding: CGFloat = 18) -> some View { modifier(DashCard(padding: padding)) } }
+
+/// 보더리스 인라인 통계 셀 (대시보드 스탯 스트립). StatCard 와 달리 카드 테두리 없음.
+struct StatCell: View {
+    let value: Int
+    let label: String
+    var color: Color = Sage.ink
+    var body: some View {
+        VStack(alignment: .leading, spacing: 3) {
+            Text("\(value)").font(.system(size: 20, weight: .semibold)).kerning(-0.6)
+                .monospacedDigit().foregroundStyle(color)
+            Text(label).font(.caption2).foregroundStyle(Sage.muted)
+        }
+        .frame(maxWidth: .infinity, alignment: .leading)
+    }
+}
+
 struct StatCard: View {
     let title: String
     let value: Int

clients/ds-app/Sources/AppFeature/Shell/RootView.swift

@@ -1,9 +1,10 @@
 import SwiftUI
 import DSKit
 
-/// DEVONthink-style 3-column shell. RootView only ROUTES; each page owns its own interior treatment
-/// (no shell-level auto-inherit). macOS-only target.
-/// 인증 게이트: checking(부팅 시 refresh 쿠키 복귀 시도) → loggedOut(LoginView) → ready(3-pane 셸).
+/// 2-column 셸 (사이드바 + 단일 detail). 각 섹션이 detail 전폭을 받아 자기 내부 레이아웃을 소유한다
+/// (개요=풀폭 캔버스 / 문서=내부 HSplitView 3-pane / 메모=리스트+상세). 이전 3-column 이 대시보드를
+/// 좁은 가운데칸에 욱여넣어 깨지던 문제를 구조적으로 제거. macOS-only.
+/// 인증 게이트: checking(refresh 쿠키 복귀) → loggedOut(LoginView) → ready(셸).
 public struct RootView: View {
     @Environment(AppModel.self) private var model
     @State private var columnVisibility: NavigationSplitViewVisibility = .all
@@ -29,38 +30,45 @@ public struct RootView: View {
     private var shell: some View {
         NavigationSplitView(columnVisibility: $columnVisibility) {
             Sidebar()
-                .navigationSplitViewColumnWidth(min: 220, ideal: 250)
-        } content: {
-            ContentColumn()
-                .navigationSplitViewColumnWidth(min: 300, ideal: 380)
+                .navigationSplitViewColumnWidth(min: 200, ideal: 215, max: 270)
         } detail: {
-            DetailColumn()
+            SectionDetail()
         }
         .navigationSplitViewStyle(.balanced)
         .tint(Sage.brand)
+        .toolbar {
+            ToolbarItem(placement: .primaryAction) { UploadToolbarButton() }
+            ToolbarItem(placement: .primaryAction) { AccountMenu() }
+        }
         .safeAreaInset(edge: .bottom) {
-            // 라이브 데이터 호출 실패 가시화 (no-silent-fallback) — 닫기 전까지 유지.
-            if let err = model.errorText {
-                HStack(spacing: 10) {
-                    Text(err)
-                        .font(.callout)
-                        .foregroundStyle(.white)
-                        .lineLimit(2)
-                    Spacer()
-                    Button("닫기") { model.errorText = nil }
-                        .buttonStyle(.plain)
-                        .foregroundStyle(.white.opacity(0.85))
+            VStack(spacing: 0) {
+                UploadStatusBar()
+                // 라이브 데이터 호출 실패 가시화 (no-silent-fallback) — 닫기 전까지 유지.
+                if let err = model.errorText {
+                    HStack(spacing: 10) {
+                        Text(err)
+                            .font(.callout)
+                            .foregroundStyle(.white)
+                            .lineLimit(2)
+                        Spacer()
+                        Button("닫기") { model.errorText = nil }
+                            .buttonStyle(.plain)
+                            .foregroundStyle(.white.opacity(0.85))
+                    }
+                    .padding(.horizontal, 14)
+                    .padding(.vertical, 8)
+                    .background(Sage.danger)
                 }
-                .padding(.horizontal, 14)
-                .padding(.vertical, 8)
-                .background(Sage.danger)
             }
         }
     }
 }
 
+// MARK: - Sidebar
+
 struct Sidebar: View {
     @Environment(AppModel.self) private var model
+    private let navSections: [AppModel.Section] = [.dashboard, .documents, .digest, .memos]
 
     var body: some View {
         let selection = Binding<AppModel.Section?>(
@@ -68,73 +76,132 @@ struct Sidebar: View {
             set: { if let v = $0 { model.section = v } }
         )
         List(selection: selection) {
+            BrandRow().selectionDisabled()
             Section {
-                ForEach(AppModel.Section.allCases) { s in
-                    Text(s.title).tag(s)
+                ForEach(navSections) { s in
+                    Label(s.title, systemImage: Self.icon(s)).tag(s)
                 }
             }
-            if model.section == .documents, !model.tree.isEmpty {
-                Section("도메인") {
-                    ForEach(model.tree) { node in
-                        DomainRow(node: node)
-                    }
-                }
+            // 문서 섹션일 때만 분류 소스트리 노출 (다른 섹션은 4-섹션만 보임).
+            if model.section == .documents {
+                DocumentsSourceSidebar()
             }
         }
         .listStyle(.sidebar)
         .background(Sage.sidebar)
     }
-}
 
-struct DomainRow: View {
-    @Environment(AppModel.self) private var model
-    let node: DomainTreeNode
-
-    var body: some View {
-        HStack(spacing: 8) {
-            Circle().fill(Sage.domainColor(node.name)).frame(width: 8, height: 8)
-            Text(node.name).font(.callout).foregroundStyle(Sage.ink)
-            Spacer()
-            Text("\(node.count)").font(.caption).foregroundStyle(Sage.muted)
+    static func icon(_ s: AppModel.Section) -> String {
+        switch s {
+        case .dashboard: return "house"
+        case .documents: return "folder"
+        case .digest: return "newspaper"
+        case .memos: return "note.text"
         }
-        .contentShape(Rectangle())
-        .onTapGesture { model.section = .documents }
     }
 }
 
-struct ContentColumn: View {
+struct BrandRow: View {
+    var body: some View {
+        HStack(spacing: 8) {
+            RoundedRectangle(cornerRadius: 7).fill(Sage.brand).frame(width: 26, height: 26)
+                .overlay(Text("DS").font(.system(size: 10, weight: .heavy)).foregroundStyle(.white))
+            Text("Document Server").font(.system(size: 13.5, weight: .heavy)).foregroundStyle(Sage.ink)
+        }
+        .padding(.vertical, 4)
+    }
+}
+
+/// 문서 전용 소스트리: 분류(도메인 필터 = 실데이터) + 스마트그룹/태그(데이터 미연결 placeholder).
+struct DocumentsSourceSidebar: View {
+    @Environment(AppModel.self) private var model
+
+    var body: some View {
+        Section("분류") {
+            SourceRow(label: "전체 문서", color: nil, count: model.stats?.total,
+                      selected: model.documentDomainFilter == nil) {
+                Task { await model.loadDocuments(domain: nil) }
+            }
+            ForEach(model.tree) { node in
+                SourceRow(label: localizedDomain(node.name), color: Sage.domainColor(node.name),
+                          count: node.count, selected: model.documentDomainFilter == node.path) {
+                    Task { await model.loadDocuments(domain: node.path) }
+                }
+            }
+        }
+        // 데이터 미연결 — IA 만 맞추고 비활성(가짜 카운트 금지).
+        Section("스마트 그룹") {
+            ForEach(["최근 7일", "검토 대기", "법령 알림"], id: \.self) { t in
+                Text(t).font(.callout).foregroundStyle(Sage.muted).opacity(0.5)
+            }
+        }
+        Section("태그") {
+            ForEach(["압력용기", "ASME", "받은편지함"], id: \.self) { t in
+                Text("#\(t)").font(.callout).foregroundStyle(Sage.muted).opacity(0.5)
+            }
+        }
+    }
+}
+
+/// 소스트리 행 (분류). 선택 시 brand-soft 배경 — List 시스템 선택과 분리(수동 하이라이트).
+struct SourceRow: View {
+    let label: String
+    let color: Color?
+    let count: Int?
+    let selected: Bool
+    let action: () -> Void
+
+    var body: some View {
+        HStack(spacing: 8) {
+            if let color { RoundedRectangle(cornerRadius: 3).fill(color).frame(width: 8, height: 8) }
+            Text(label).font(.callout)
+                .foregroundStyle(selected ? Sage.brandDark : Sage.ink)
+                .fontWeight(selected ? .bold : .regular)
+                .lineLimit(1)
+            Spacer()
+            if let count { Text("\(count)").font(.caption.monospacedDigit()).foregroundStyle(Sage.muted) }
+        }
+        .padding(.vertical, 2)
+        .contentShape(Rectangle())
+        .onTapGesture(perform: action)
+        .listRowBackground(selected ? Sage.brand.opacity(0.14) : Color.clear)
+    }
+}
+
+// MARK: - Section router
+
+/// 선택 섹션을 detail 전폭으로 라우팅. 셸 차원 inspector/list 칼럼 없음 — 각 페이지가 내부에서 소유.
+struct SectionDetail: View {
     @Environment(AppModel.self) private var model
 
     var body: some View {
         Group {
             switch model.section {
-            case .dashboard: DashboardView()
-            case .documents: DocumentListView()
-            case .search: SearchView()
-            case .ask: AskView()
-            case .memos: MemoListView()
-            case .digest: DigestView()
+            case .dashboard: DashboardView()       // 풀폭 캔버스
+            case .documents: DocumentsBrowser()    // 내부 HSplitView 3-pane
+            case .digest:    DigestView()          // 풀폭 (뉴스 — 후속 모닝브리핑 재구성)
+            case .memos:     MemosBoard()          // 리스트 + 상세 (후속 버킷 트리아지)
             }
         }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .background(Sage.surface)
         .navigationTitle(model.section.title)
     }
 }
 
-struct DetailColumn: View {
+/// 메모 — v1 리스트+상세 split (확정 버킷 트리아지는 후속 트랙).
+struct MemosBoard: View {
     @Environment(AppModel.self) private var model
 
     var body: some View {
-        Group {
-            switch model.section {
-            case .documents:
-                if let d = model.documentDetail { DocumentDetailView(detail: d) }
-                else { EmptyState(text: "문서를 선택하세요") }
-            case .memos:
+        HSplitView {
+            MemoListView()
+                .frame(minWidth: 300, idealWidth: 360, maxWidth: 460)
+            Group {
                 if let m = model.memoDetail { MemoDetailView(memo: m) }
                 else { EmptyState(text: "메모를 선택하세요") }
-            default:
-                EmptyState(text: model.section.title)
             }
+            .frame(minWidth: 360, maxWidth: .infinity)
         }
     }
 }
@@ -149,11 +216,96 @@ struct EmptyState: View {
     }
 }
 
+// MARK: - Toolbar items
+
+/// 툴바 업로드 버튼 — NSOpenPanel 로 파일 선택 → 멀티파트 업로드. 진행 중 비활성.
+struct UploadToolbarButton: View {
+    @Environment(AppModel.self) private var model
+
+    var body: some View {
+        Button {
+            guard let fileURL = FilePanels.pickFileToUpload() else { return }
+            Task { await model.uploadPicked(fileURL) }
+        } label: {
+            Label("업로드", systemImage: "square.and.arrow.up")
+        }
+        .help("문서 업로드")
+        .disabled(isUploading)
+    }
+
+    private var isUploading: Bool {
+        if case .uploading = model.uploadState { return true }
+        return false
+    }
+}
+
+/// 계정 메뉴 — 사용자명 표시 + 로그아웃(확인 대화상자).
+struct AccountMenu: View {
+    @Environment(AppModel.self) private var model
+    @State private var confirmLogout = false
+
+    var body: some View {
+        Menu {
+            Button("로그아웃", role: .destructive) { confirmLogout = true }
+        } label: {
+            Label(model.currentUser?.username ?? "계정", systemImage: "person.crop.circle")
+        }
+        .help("계정")
+        .confirmationDialog("로그아웃하시겠습니까?", isPresented: $confirmLogout, titleVisibility: .visible) {
+            Button("로그아웃", role: .destructive) { Task { await model.logout() } }
+            Button("취소", role: .cancel) {}
+        }
+    }
+}
+
+/// 업로드 진행/결과 상태바. uploading=스피너(닫기 없음) / done=성공(처리 대기 안내)+닫기 / failed=오류+닫기.
+struct UploadStatusBar: View {
+    @Environment(AppModel.self) private var model
+
+    var body: some View {
+        switch model.uploadState {
+        case .idle:
+            EmptyView()
+        case .uploading(let name):
+            row(bg: Sage.brand) {
+                ProgressView().controlSize(.small).tint(.white)
+                Text("업로드 중 — \(name)").font(.callout).foregroundStyle(.white).lineLimit(1)
+                Spacer()
+            }
+        case .done(let title):
+            row(bg: Sage.brand) {
+                Text("업로드 완료 — \(title) (처리 대기 중)").font(.callout).foregroundStyle(.white).lineLimit(1)
+                Spacer()
+                closeButton
+            }
+        case .failed(let msg):
+            row(bg: Sage.danger) {
+                Text("업로드 실패 — \(msg)").font(.callout).foregroundStyle(.white).lineLimit(2)
+                Spacer()
+                closeButton
+            }
+        }
+    }
+
+    private var closeButton: some View {
+        Button("닫기") { model.dismissUploadStatus() }
+            .buttonStyle(.plain)
+            .foregroundStyle(.white.opacity(0.85))
+    }
+
+    private func row<Content: View>(bg: Color, @ViewBuilder _ content: () -> Content) -> some View {
+        HStack(spacing: 10) { content() }
+            .padding(.horizontal, 14)
+            .padding(.vertical, 8)
+            .background(bg)
+    }
+}
+
 #if DEBUG
 #Preview("DS App — full shell") {
     @Previewable @State var model = AppModel.preview
     RootView()
         .environment(model)
-        .frame(minWidth: 1000, minHeight: 660)
+        .frame(minWidth: 1100, minHeight: 700)
 }
 #endif

clients/ds-app/Sources/AppFeature/State/AppModel.swift

@@ -2,23 +2,24 @@ import SwiftUI
 import Observation
 import DSKit
 import AIFabric
+import UniformTypeIdentifiers
 
 /// The single app-state store driving the 3-pane shell. @MainActor @Observable: mutations are
 /// main-isolated; the DSClient returns Sendable models; AIService is an actor.
 @MainActor
 @Observable
 public final class AppModel {
+    /// 표시 순서 = 홈·문서·뉴스·메모. 질문(ask)·이드(AI chat)는 v1 macOS 표면에서 제거(2026-06-15) —
+    /// AIFabric(S2) 코드는 향후 iPhone/Watch 이드용으로 보존, UI 섹션만 미노출.
     public enum Section: String, CaseIterable, Identifiable, Hashable {
-        case dashboard, documents, search, ask, memos, digest
+        case dashboard, documents, digest, memos
         public var id: String { rawValue }
         public var title: String {
             switch self {
-            case .dashboard: return "대시보드"
+            case .dashboard: return "홈"
             case .documents: return "문서"
-            case .search: return "검색"
-            case .ask: return "질문"
-            case .memos: return "메모"
             case .digest: return "뉴스"
+            case .memos: return "메모"
             }
         }
     }
@@ -27,19 +28,33 @@ public final class AppModel {
     /// → 성공 시 셸(ready). Fixture 클라이언트는 refresh 가 fixture 토큰을 돌려줘 곧장 ready.
     public enum AuthPhase: Equatable { case checking, loggedOut, ready }
 
+    /// 업로드 진행/결과 — 셸 하단 상태바 + 툴바 버튼 스피너용. done/failed 는 닫기 또는 다음 업로드로 소거.
+    public enum UploadState: Equatable, Sendable {
+        case idle
+        case uploading(name: String)
+        case done(title: String)
+        case failed(String)
+    }
+
     public var section: Section = .dashboard
     public var selectedDocumentID: Int?
     public var selectedMemoID: Int?
 
     public var tree: [DomainTreeNode] = []
     public var stats: CategoryCounts?
+    /// 검토 대기 문서 총수 (홈 검토 큐 히어로). loadInitial 에서 count 쿼리로 채움. nil=미로드.
+    public var reviewPendingCount: Int?
+    /// 로그인 사용자 (계정 메뉴 표시용). loadInitial 에서 me() 로 채움.
+    public var currentUser: UserResponse?
+    public private(set) var uploadState: UploadState = .idle
+    /// 홈 빠른 캡처 입력 (CaptureCard 바인딩, saveMemo 후 비움).
+    public var captureText: String = ""
     public var documentList: [DocumentResponse] = []
     public var documentDetail: DocumentDetailResponse?
-    public var searchQuery: String = ""
-    public var searchResponse: SearchResponse?
-    public var askQuery: String = ""
-    public var askResult: AIResult?
-    public var askMeta: DSKit.AskResponse? // qualified: AIFabric also defines an AskResponse
+    /// 문서 사이드바 분류 필터 (선택된 도메인 path, nil = 전체 문서).
+    public var documentDomainFilter: String?
+    /// 현재 필터의 전체 문서를 다 불러왔는지 (페이지네이션 load-all 완료). 섹션 재진입 중복로드 방지.
+    public private(set) var documentsFullyLoaded = false
     public var memoList: [MemoResponse] = []
     public var memoDetail: MemoResponse?
     public var digest: DigestResponse?
@@ -129,11 +144,16 @@ public final class AppModel {
     }
 
     public func loadInitial() async {
+        await guarded { self.currentUser = try await self.client.me() }
         await guarded { self.tree = try await self.client.documentTree() }
         await guarded { self.stats = try await self.client.categoryCounts() }
         await guarded { self.documentList = try await self.client.documents(DocumentListQuery()).items }
         await guarded { self.memoList = try await self.client.memos(MemoListQuery()).items }
         await guarded { self.digest = try await self.client.digest(date: nil, country: nil) }
+        await guarded {
+            var q = DocumentListQuery(); q.reviewStatus = "pending"; q.pageSize = 1
+            self.reviewPendingCount = try await self.client.documents(q).total
+        }
     }
 
     public func openDocument(_ id: Int) async {
@@ -141,15 +161,60 @@ public final class AppModel {
         await guarded { self.documentDetail = try await self.client.document(id: id) }
     }
 
-    public func runSearch() async {
-        guard !searchQuery.isEmpty else { return }
-        await guarded { self.searchResponse = try await self.client.search(q: self.searchQuery, mode: .hybrid, page: 1, debug: false) }
+    /// 문서 섹션 진입 시 현재 필터의 전체 문서 확보 (중복로드 방지). 미로드 상태일 때만 load-all.
+    public func ensureDocumentsLoaded() async {
+        if !documentsFullyLoaded { await loadDocuments(domain: documentDomainFilter) }
     }
 
-    public func runAsk(backend: AIProviderID?) async {
-        guard !askQuery.isEmpty else { return }
-        askResult = await ai.corpusAsk(question: askQuery, explicit: backend)
-        await guarded { self.askMeta = try await self.client.ask(q: self.askQuery, limit: nil, backend: nil, debug: false) }
+    /// 사이드바 분류 선택 → 도메인 필터로 **전체** 문서 load-all (서버 page_size 상한 100을 페이지네이션으로
+    /// 모두 수집 — 1582건도 전부 노출). 페이지마다 append 라 목록이 점진적으로 채워진다. 재조회 후
+    /// 선택 문서가 새 목록에 없으면 선택/상세를 비워 3-pane 정합 유지.
+    public func loadDocuments(domain: String?) async {
+        documentDomainFilter = domain
+        documentsFullyLoaded = false
+        documentList = []
+        let pageSize = 100
+        var page = 1
+        do {
+            while page <= 80 {   // 안전 상한 ~8000건
+                var q = DocumentListQuery(); q.domain = domain; q.page = page; q.pageSize = pageSize
+                let resp = try await client.documents(q)
+                documentList.append(contentsOf: resp.items)
+                if resp.items.count < pageSize || documentList.count >= resp.total { break }
+                page += 1
+            }
+            documentsFullyLoaded = true
+        } catch let e as DSError where e.isAuthExpired {
+            authPhase = .loggedOut
+            loginError = "세션이 만료되었습니다. 다시 로그인하세요."
+        } catch {
+            errorText = (error as? LocalizedError)?.errorDescription ?? "\(error)"
+        }
+        await syncAccessToken()
+        if let sel = selectedDocumentID, !documentList.contains(where: { $0.id == sel }) {
+            selectedDocumentID = nil
+            documentDetail = nil
+        }
+    }
+
+    /// 텍스트로 메모 생성 후 목록 맨 앞 반영. 성공 시 true. 빈/공백 입력은 무시(false). 에러는
+    /// guarded 깔때기로 errorText 노출(삼키지 않음).
+    @discardableResult
+    public func saveMemo(_ text: String) async -> Bool {
+        let t = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !t.isEmpty else { return false }
+        var ok = false
+        await guarded {
+            let memo = try await self.client.createMemo(MemoCreate(content: t))
+            self.memoList.insert(memo, at: 0)
+            ok = true
+        }
+        return ok
+    }
+
+    /// 홈 빠른 캡처 — captureText 사용, 성공 시 입력 비움.
+    public func saveMemo() async {
+        if await saveMemo(captureText) { captureText = "" }
     }
 
     public func openMemo(_ id: Int) async {
@@ -162,6 +227,67 @@ public final class AppModel {
         return DSDownload.fileURL(base: base, documentID: doc.id, accessToken: accessToken)
     }
 
+    /// 로그아웃: 서버 쿠키/토큰 폐기(best-effort) 후 세션 상태 전체 초기화 → loggedOut. 다음 로그인이
+    /// stale 데이터 없이 깨끗하게 시작하도록 로드 상태를 비운다. 실패해도 로컬은 무조건 로그아웃 처리.
+    public func logout() async {
+        try? await client.logout()
+        accessToken = ""
+        currentUser = nil
+        tree = []
+        stats = nil
+        reviewPendingCount = nil
+        captureText = ""
+        documentList = []
+        documentDetail = nil
+        documentDomainFilter = nil
+        documentsFullyLoaded = false
+        memoList = []
+        memoDetail = nil
+        digest = nil
+        selectedDocumentID = nil
+        selectedMemoID = nil
+        section = .dashboard      // 다음 로그인은 홈에서 시작 (리뷰 LOW: 이전 사용자 마지막 페이지 잔류 방지)
+        errorText = nil
+        uploadState = .idle
+        authPhase = .loggedOut
+    }
+
+    /// 사용자가 고른 파일(NSOpenPanel 보안 스코프 URL)을 읽어 업로드. 파일 IO 실패는 uploadState 로 노출.
+    public func uploadPicked(_ fileURL: URL) async {
+        let accessed = fileURL.startAccessingSecurityScopedResource()
+        defer { if accessed { fileURL.stopAccessingSecurityScopedResource() } }
+        let filename = fileURL.lastPathComponent
+        let data: Data
+        do {
+            data = try Data(contentsOf: fileURL)
+        } catch {
+            uploadState = .failed("파일을 읽을 수 없습니다: \((error as NSError).localizedDescription)")
+            return
+        }
+        let mime = UTType(filenameExtension: fileURL.pathExtension)?.preferredMIMEType
+        await upload(DocumentUpload(filename: filename, data: data, mimeType: mime))
+    }
+
+    /// 멀티파트 업로드 실행 + 결과 반영. 성공 시 목록 재로드(신규 문서 = 처리 대기 상태로 노출).
+    public func upload(_ payload: DocumentUpload) async {
+        uploadState = .uploading(name: payload.filename)
+        do {
+            let doc = try await client.uploadDocument(payload)
+            uploadState = .done(title: doc.title ?? doc.downloadLabel)
+            await guarded { self.documentList = try await self.client.documents(DocumentListQuery()).items }
+        } catch let e as DSError where e.isAuthExpired {
+            authPhase = .loggedOut
+            loginError = "세션이 만료되었습니다. 다시 로그인하세요."
+            uploadState = .failed("세션이 만료되었습니다.")
+        } catch {
+            uploadState = .failed((error as? LocalizedError)?.errorDescription ?? "\(error)")
+        }
+        await syncAccessToken()
+    }
+
+    /// 업로드 상태바 닫기 (done/failed 소거).
+    public func dismissUploadStatus() { uploadState = .idle }
+
     private func guarded(_ work: () async throws -> Void) async {
         do {
             try await work()

clients/ds-app/Sources/DSKit/DSClient.swift

@@ -23,6 +23,8 @@ public protocol DSClient: Sendable {
     func patchDocument(id: Int, _ update: DocumentUpdate) async throws -> DocumentResponse
     func putContent(id: Int, content: String) async throws
     func deleteDocument(id: Int) async throws
+    /// 멀티파트 업로드 (POST /documents/) → Inbox 저장 + 처리 큐 등록. 201 DocumentResponse.
+    func uploadDocument(_ upload: DocumentUpload) async throws -> DocumentResponse
 
     // Search / Ask
     func search(q: String, mode: SearchMode?, page: Int?, debug: Bool?) async throws -> SearchResponse

clients/ds-app/Sources/DSKit/FixtureDSClient.swift

@@ -53,6 +53,9 @@ public struct FixtureDSClient: DSClient {
     }
     public func putContent(id: Int, content: String) async throws {}
     public func deleteDocument(id: Int) async throws {}
+    public func uploadDocument(_ upload: DocumentUpload) async throws -> DocumentResponse {
+        try load("document_detail", as: DocumentDetailResponse.self).base
+    }
 
     // Search / Ask
     public func search(q: String, mode: SearchMode?, page: Int?, debug: Bool?) async throws -> SearchResponse {

clients/ds-app/Sources/DSKit/LiveDSClient.swift

@@ -64,15 +64,26 @@ public final class LiveDSClient: DSClient, @unchecked Sendable {
     }
 
     private func perform(_ endpoint: DSEndpoint) async throws -> Data {
-        let request = try makeRequest(endpoint, token: await tokens.current())
+        try await performWithRetry(requiresBearer: endpoint.requiresBearer) { token in
+            try self.makeRequest(endpoint, token: token)
+        }
+    }
+
+    /// 401 단일-비행 refresh + 1회 재시도의 공용 경로. `build` 가 (현 토큰)→URLRequest 를 만들고,
+    /// 401 이면 새 토큰으로 한 번 더 빌드해 재전송한다. JSON 경로(perform)와 멀티파트 업로드가 공유.
+    private func performWithRetry(
+        requiresBearer: Bool,
+        _ build: (_ token: String?) throws -> URLRequest
+    ) async throws -> Data {
+        let request = try build(await tokens.current())
         let (data, response) = try await dataOrTransport(request)
         guard let http = response as? HTTPURLResponse else {
             throw DSError.transport(underlying: "no HTTP response")
         }
-        if http.statusCode == 401, endpoint.requiresBearer {
+        if http.statusCode == 401, requiresBearer {
             // Single-flight refresh + one retry.
             let newToken = try await tokens.refreshOnce()
-            let retry = try makeRequest(endpoint, token: newToken)
+            let retry = try build(newToken)
             let (data2, response2) = try await dataOrTransport(retry)
             guard let http2 = response2 as? HTTPURLResponse else {
                 throw DSError.transport(underlying: "no HTTP response")
@@ -122,6 +133,44 @@ public final class LiveDSClient: DSClient, @unchecked Sendable {
     public func putContent(id: Int, content: String) async throws { try await sendVoid(.putContent(id, content)) }
     public func deleteDocument(id: Int) async throws { try await sendVoid(.deleteDocument(id)) }
 
+    public func uploadDocument(_ upload: DocumentUpload) async throws -> DocumentResponse {
+        let boundary = "DSBoundary-\(UUID().uuidString)"
+        let body = LiveDSClient.multipartBody(for: upload, boundary: boundary)
+        // 트레일링 슬래시 유지(POST /documents/) — base 문자열 결합 (appendingPathComponent 는 슬래시 strip).
+        let raw = base.url.absoluteString + "/documents/"
+        guard let url = URL(string: raw) else { throw DSError.transport(underlying: "bad URL \(raw)") }
+        let data = try await performWithRetry(requiresBearer: true) { token in
+            var request = URLRequest(url: url)
+            request.httpMethod = "POST"
+            if let token { request.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization") }
+            request.setValue("multipart/form-data; boundary=\(boundary)", forHTTPHeaderField: "Content-Type")
+            request.httpBody = body
+            return request
+        }
+        do { return try decoder.decode(DocumentResponse.self, from: data) }
+        catch { throw DSError.decoding("documents/ upload: \(error)") }
+    }
+
+    /// multipart/form-data 본문 생성. file 파트 + 선택 form 필드(doc_purpose/library_path).
+    /// internal(테스트 가시) — 한글 파일명은 UTF-8 바이트 그대로(Starlette 가 디코드).
+    static func multipartBody(for upload: DocumentUpload, boundary: String) -> Data {
+        var body = Data()
+        func appendField(_ name: String, _ value: String) {
+            body.append(Data("--\(boundary)\r\n".utf8))
+            body.append(Data("Content-Disposition: form-data; name=\"\(name)\"\r\n\r\n".utf8))
+            body.append(Data("\(value)\r\n".utf8))
+        }
+        if let p = upload.docPurpose { appendField("doc_purpose", p) }
+        if let lp = upload.libraryPath { appendField("library_path", lp) }
+        body.append(Data("--\(boundary)\r\n".utf8))
+        body.append(Data("Content-Disposition: form-data; name=\"file\"; filename=\"\(upload.filename)\"\r\n".utf8))
+        body.append(Data("Content-Type: \(upload.mimeType ?? "application/octet-stream")\r\n\r\n".utf8))
+        body.append(upload.data)
+        body.append(Data("\r\n".utf8))
+        body.append(Data("--\(boundary)--\r\n".utf8))
+        return body
+    }
+
     public func search(q: String, mode: SearchMode?, page: Int?, debug: Bool?) async throws -> SearchResponse { try await send(.search(q, mode, page, debug), as: SearchResponse.self) }
     public func ask(q: String, limit: Int?, backend: String?, debug: Bool?) async throws -> AskResponse { try await send(.ask(q, limit, backend, debug), as: AskResponse.self) }
 

clients/ds-app/Sources/DSKit/Models/Requests.swift

@@ -24,6 +24,25 @@ public struct MemoListQuery: Sendable {
     public init() {}
 }
 
+/// 멀티파트 업로드 페이로드 (POST /documents/). `file` 파트 + 선택 form 필드.
+/// `data` 는 메모리 적재(개인 문서 규모 가정) — 대용량 디스크 스트리밍은 후속.
+public struct DocumentUpload: Sendable {
+    public var filename: String
+    public var data: Data
+    public var mimeType: String?
+    /// "business" | "knowledge" | nil. business 는 서버가 @library 로 자동 태깅.
+    public var docPurpose: String?
+    public var libraryPath: String?
+    public init(filename: String, data: Data, mimeType: String? = nil,
+                docPurpose: String? = nil, libraryPath: String? = nil) {
+        self.filename = filename
+        self.data = data
+        self.mimeType = mimeType
+        self.docPurpose = docPurpose
+        self.libraryPath = libraryPath
+    }
+}
+
 public struct DocumentUpdate: Codable, Sendable {
     public var title: String?
     public var userNote: String?

clients/ds-app/Tests/AppFeatureTests/AppModelActionsTests.swift

@@ -0,0 +1,50 @@
+import XCTest
+@testable import AppFeature
+import DSKit
+
+/// 로그아웃 상태 초기화 + 업로드 결과 반영 — 네트워크 0 (Fixture).
+final class AppModelActionsTests: XCTestCase {
+
+    // ready 세션에서 로그아웃 → loggedOut + 토큰/사용자/로드상태 전부 초기화
+    @MainActor
+    func testLogoutResetsStateAndLogsOut() async {
+        let model = AppModel.preview
+        await model.bootstrap()
+        XCTAssertEqual(model.authPhase, .ready)
+        XCTAssertFalse(model.documentList.isEmpty)
+        XCTAssertNotNil(model.currentUser, "loadInitial 이 me() 로 사용자 채움")
+
+        await model.logout()
+
+        XCTAssertEqual(model.authPhase, .loggedOut)
+        XCTAssertTrue(model.accessToken.isEmpty)
+        XCTAssertNil(model.currentUser)
+        XCTAssertTrue(model.documentList.isEmpty)
+        XCTAssertNil(model.documentDetail)
+        XCTAssertTrue(model.tree.isEmpty)
+        XCTAssertEqual(model.uploadState, .idle)
+    }
+
+    // 업로드 성공 → uploadState=.done + 목록 재로드
+    @MainActor
+    func testUploadSuccessSetsDoneAndReloads() async {
+        let model = AppModel.preview
+        await model.bootstrap()
+        await model.upload(DocumentUpload(filename: "x.pdf", data: Data("x".utf8), mimeType: "application/pdf"))
+
+        if case .done = model.uploadState {} else {
+            XCTFail("기대 .done, 실제 \(model.uploadState)")
+        }
+        XCTAssertFalse(model.documentList.isEmpty)
+    }
+
+    // 업로드 진행 상태 전이 표현 (Equatable 동작 확인 — 상태바 분기 근거)
+    @MainActor
+    func testDismissUploadStatusReturnsToIdle() async {
+        let model = AppModel.preview
+        await model.bootstrap()
+        await model.upload(DocumentUpload(filename: "x.pdf", data: Data("x".utf8)))
+        model.dismissUploadStatus()
+        XCTAssertEqual(model.uploadState, .idle)
+    }
+}

clients/ds-app/Tests/AppFeatureTests/AppModelAuthTests.swift

@@ -168,6 +168,7 @@ final class AuthStubClient: DSClient, @unchecked Sendable {
     func patchDocument(id: Int, _ update: DocumentUpdate) async throws -> DocumentResponse { try await inner.patchDocument(id: id, update) }
     func putContent(id: Int, content: String) async throws { try await inner.putContent(id: id, content: content) }
     func deleteDocument(id: Int) async throws { try await inner.deleteDocument(id: id) }
+    func uploadDocument(_ upload: DocumentUpload) async throws -> DocumentResponse { try await inner.uploadDocument(upload) }
     func search(q: String, mode: SearchMode?, page: Int?, debug: Bool?) async throws -> SearchResponse { try await inner.search(q: q, mode: mode, page: page, debug: debug) }
     func ask(q: String, limit: Int?, backend: String?, debug: Bool?) async throws -> AskResponse { try await inner.ask(q: q, limit: limit, backend: backend, debug: debug) }
     func memos(_ query: MemoListQuery) async throws -> MemoListResponse { try await inner.memos(query) }

clients/ds-app/Tests/DSKitTests/UploadTests.swift

@@ -0,0 +1,42 @@
+import XCTest
+@testable import DSKit
+
+/// 멀티파트 업로드 — Fixture 에코 + multipart 본문 형태(경계/디스포지션/한글 파일명/필드/파일 데이터).
+final class UploadTests: XCTestCase {
+
+    func testFixtureUploadReturnsDocument() async throws {
+        let doc = try await FixtureDSClient().uploadDocument(
+            DocumentUpload(filename: "a.pdf", data: Data("x".utf8), mimeType: "application/pdf"))
+        XCTAssertGreaterThan(doc.id, 0)
+    }
+
+    func testMultipartBodyShape() throws {
+        let upload = DocumentUpload(
+            filename: "보고서.pdf",
+            data: Data("PDFDATA".utf8),
+            mimeType: "application/pdf",
+            docPurpose: "knowledge"
+        )
+        let boundary = "TESTBOUNDARY"
+        let body = LiveDSClient.multipartBody(for: upload, boundary: boundary)
+        let s = try XCTUnwrap(String(data: body, encoding: .utf8))
+
+        XCTAssertTrue(s.contains("--TESTBOUNDARY\r\n"), "경계 마커")
+        XCTAssertTrue(s.contains(#"Content-Disposition: form-data; name="file"; filename="보고서.pdf""#),
+                      "file 파트 + 한글 파일명")
+        XCTAssertTrue(s.contains("Content-Type: application/pdf"), "파일 mime")
+        XCTAssertTrue(s.contains(#"Content-Disposition: form-data; name="doc_purpose""#), "선택 form 필드")
+        XCTAssertTrue(s.contains("knowledge"))
+        XCTAssertTrue(s.contains("PDFDATA"), "파일 데이터")
+        XCTAssertTrue(s.hasSuffix("--TESTBOUNDARY--\r\n"), "종료 경계")
+    }
+
+    func testMultipartOmitsAbsentOptionalFields() throws {
+        let upload = DocumentUpload(filename: "x.txt", data: Data("a".utf8))
+        let body = LiveDSClient.multipartBody(for: upload, boundary: "B")
+        let s = try XCTUnwrap(String(data: body, encoding: .utf8))
+        XCTAssertFalse(s.contains("doc_purpose"), "미지정 doc_purpose 는 본문에 없어야 함")
+        XCTAssertFalse(s.contains("library_path"), "미지정 library_path 는 본문에 없어야 함")
+        XCTAssertTrue(s.contains("Content-Type: application/octet-stream"), "mime 미지정 = octet-stream 폴백")
+    }
+}

clients/ds-app/contract/CONTRACT.md

@@ -54,7 +54,7 @@ UserResponse { id: Int, username: String, is_active: Bool, totp_enabled: Bool, l
 | GET | `/documents/{id}/content` | — | 경량 텍스트(`content` 15k cap) | `document_content.json` |
 | GET | `/documents/tree` | — | 도메인 트리(사이드바) | `documents_tree.json` |
 | GET | `/documents/stats/category-counts` | — | `{counts: {category: n}, library_pending_suggestions}` — **raw dict 반환(Pydantic 모델 없음), 2026-06-07 라이브 재캡처로 정정**(초기 추출이 shape 합성 오류) | `documents_stats.json` |
-| POST | `/documents/` (multipart) | 파일 업로드 | `DocumentResponse` (201) | `document_detail.json` |
+| POST | `/documents/` (multipart/form-data) | `file`(필수) + `doc_purpose?`(business\|knowledge) `library_path?` `facet_*?` | `DocumentResponse` (201) | `document_detail.json` |
 | PATCH | `/documents/{id}` | `DocumentUpdate` | `DocumentResponse` | — |
 | PUT | `/documents/{id}/content` | `{content}` (md 편집 저장) | `{}` | — |
 | POST | `/documents/{id}/accept-suggestion` | `{expected_source_updated_at}` | `DocumentResponse` | — |

clients/ds-shell/.gitignore

@@ -0,0 +1,4 @@
+DSShell.xcodeproj/
+Support/
+.build/
+*.xcuserstate

clients/ds-shell/Sources/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,74 @@
+{
+  "info" : {
+    "version" : 1,
+    "author" : "xcode"
+  },
+  "images" : [
+    {
+      "scale" : "1x",
+      "filename" : "mac_16.png",
+      "idiom" : "mac",
+      "size" : "16x16"
+    },
+    {
+      "idiom" : "mac",
+      "size" : "16x16",
+      "scale" : "2x",
+      "filename" : "mac_32.png"
+    },
+    {
+      "filename" : "mac_32.png",
+      "size" : "32x32",
+      "scale" : "1x",
+      "idiom" : "mac"
+    },
+    {
+      "scale" : "2x",
+      "idiom" : "mac",
+      "size" : "32x32",
+      "filename" : "mac_64.png"
+    },
+    {
+      "idiom" : "mac",
+      "size" : "128x128",
+      "filename" : "mac_128.png",
+      "scale" : "1x"
+    },
+    {
+      "size" : "128x128",
+      "idiom" : "mac",
+      "scale" : "2x",
+      "filename" : "mac_256.png"
+    },
+    {
+      "filename" : "mac_256.png",
+      "scale" : "1x",
+      "idiom" : "mac",
+      "size" : "256x256"
+    },
+    {
+      "filename" : "mac_512.png",
+      "scale" : "2x",
+      "size" : "256x256",
+      "idiom" : "mac"
+    },
+    {
+      "filename" : "mac_512.png",
+      "size" : "512x512",
+      "idiom" : "mac",
+      "scale" : "1x"
+    },
+    {
+      "filename" : "mac_1024.png",
+      "size" : "512x512",
+      "scale" : "2x",
+      "idiom" : "mac"
+    },
+    {
+      "idiom" : "universal",
+      "filename" : "ios_1024.png",
+      "size" : "1024x1024",
+      "platform" : "ios"
+    }
+  ]
+}

clients/ds-shell/Sources/Assets.xcassets/Contents.json

@@ -0,0 +1,3 @@
+{
+  "info" : { "author" : "xcode", "version" : 1 }
+}

clients/ds-shell/Sources/DSShellApp.swift

@@ -0,0 +1,29 @@
+import SwiftUI
+
+/// DS 웹 래퍼 — document.hyungi.net 을 네이티브 창에 로드. 로그인은 WKWebsiteDataStore.default()
+/// 영속 쿠키로 유지(브라우저처럼). 맥·iOS 공용 @main.
+@main
+struct DSShellApp: App {
+    private let url = URL(string: "https://document.hyungi.net")!
+
+    var body: some Scene {
+        WindowGroup {
+            RootWeb(url: url)
+        }
+        #if os(macOS)
+        .windowStyle(.automatic)
+        #endif
+    }
+}
+
+struct RootWeb: View {
+    let url: URL
+    var body: some View {
+        WebView(url: url)
+            .ignoresSafeArea()
+        #if os(macOS)
+            .frame(minWidth: 900, minHeight: 600)
+            .background(WindowOnScreenGuard())   // 분리된 모니터 좌표 저장 시 화면 밖 방지
+        #endif
+    }
+}

clients/ds-shell/Sources/WebView.swift

@@ -0,0 +1,96 @@
+import SwiftUI
+import WebKit
+
+#if os(macOS)
+import AppKit
+#else
+import UIKit
+#endif
+
+/// document.hyungi.net 을 로드하는 WKWebView 래퍼 (맥=NSViewRepresentable / iOS=UIViewRepresentable).
+/// 영속 데이터스토어 = 로그인 쿠키 유지. 첨부(Content-Disposition: attachment) 응답은 다운로드 처리.
+/// 파일 업로드(file input)는 WKWebView 가 네이티브 피커로 자동 처리.
+struct WebView {
+    let url: URL
+
+    func makeCoordinator() -> Coordinator { Coordinator() }
+
+    @MainActor
+    fileprivate func makeWebView(coordinator: Coordinator) -> WKWebView {
+        let cfg = WKWebViewConfiguration()
+        cfg.websiteDataStore = .default()   // 영속 쿠키 → 로그인 유지(브라우저처럼)
+        let wv = WKWebView(frame: .zero, configuration: cfg)
+        wv.navigationDelegate = coordinator
+        wv.allowsBackForwardNavigationGestures = true
+        wv.load(URLRequest(url: url))
+        return wv
+    }
+
+    final class Coordinator: NSObject, WKNavigationDelegate, WKDownloadDelegate {
+        // 첨부 응답이면 다운로드, 아니면 일반 표시(PDF 등 인라인).
+        func webView(_ webView: WKWebView,
+                     decidePolicyFor navigationResponse: WKNavigationResponse,
+                     decisionHandler: @escaping (WKNavigationResponsePolicy) -> Void) {
+            if let http = navigationResponse.response as? HTTPURLResponse,
+               let cd = http.value(forHTTPHeaderField: "Content-Disposition"),
+               cd.lowercased().contains("attachment") {
+                decisionHandler(.download)
+            } else {
+                decisionHandler(.allow)
+            }
+        }
+
+        func webView(_ webView: WKWebView, navigationResponse: WKNavigationResponse, didBecome download: WKDownload) {
+            download.delegate = self
+        }
+        func webView(_ webView: WKWebView, navigationAction: WKNavigationAction, didBecome download: WKDownload) {
+            download.delegate = self
+        }
+
+        func download(_ download: WKDownload,
+                      decideDestinationUsing response: URLResponse,
+                      suggestedFilename: String) async -> URL? {
+            #if os(macOS)
+            let folder = FileManager.default.urls(for: .downloadsDirectory, in: .userDomainMask).first
+            #else
+            let folder = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first
+            #endif
+            let dir = folder ?? FileManager.default.temporaryDirectory
+            var dest = dir.appendingPathComponent(suggestedFilename.isEmpty ? "download" : suggestedFilename)
+            // 충돌 회피 (name_1.ext …)
+            let base = dest.deletingPathExtension().lastPathComponent
+            let ext = dest.pathExtension
+            var n = 1
+            while FileManager.default.fileExists(atPath: dest.path) {
+                let name = ext.isEmpty ? "\(base)_\(n)" : "\(base)_\(n).\(ext)"
+                dest = dir.appendingPathComponent(name); n += 1
+            }
+            return dest
+        }
+    }
+}
+
+#if os(macOS)
+extension WebView: NSViewRepresentable {
+    func makeNSView(context: Context) -> WKWebView { makeWebView(coordinator: context.coordinator) }
+    func updateNSView(_ nsView: WKWebView, context: Context) {}
+}
+
+/// 창이 어느 화면과도 안 겹치면(분리된 외부모니터 좌표 저장 등) 메인 화면 중앙으로 복귀 — "창 안 뜸" 방지.
+struct WindowOnScreenGuard: NSViewRepresentable {
+    func makeNSView(context: Context) -> NSView { OnScreenView() }
+    func updateNSView(_ nsView: NSView, context: Context) {}
+    final class OnScreenView: NSView {
+        override func viewDidMoveToWindow() {
+            super.viewDidMoveToWindow()
+            guard let win = window else { return }
+            if !NSScreen.screens.contains(where: { $0.visibleFrame.intersects(win.frame) }) { win.center() }
+        }
+    }
+}
+#else
+extension WebView: UIViewRepresentable {
+    func makeUIView(context: Context) -> WKWebView { makeWebView(coordinator: context.coordinator) }
+    func updateUIView(_ uiView: WKWebView, context: Context) {}
+}
+#endif

clients/ds-shell/project.yml

@@ -0,0 +1,88 @@
+# DS 웹 래퍼 — document.hyungi.net 을 WKWebView 로 감싼 네이티브 앱(맥 + iOS).
+# 웹 UI 100% 재사용·항상 최신·코드 1벌(2026-06-15 결정). 순수 네이티브는 워치(clients/ds-watch)만.
+# project.yml = source of truth, *.xcodeproj/Support = 생성물(gitignore).
+name: DSShell
+options:
+  bundleIdPrefix: net.hyungi
+  deploymentTarget:
+    macOS: "14.0"
+    iOS: "17.0"
+  createIntermediateGroups: true
+  minimumXcodeGenVersion: "2.40.0"
+
+settings:
+  base:
+    SWIFT_VERSION: "6.0"
+    CODE_SIGN_STYLE: Automatic
+    CODE_SIGNING_ALLOWED: "NO"
+    CODE_SIGNING_REQUIRED: "NO"
+    GENERATE_INFOPLIST_FILE: "NO"
+
+targets:
+  DSShellMac:
+    type: application
+    platform: macOS
+    deploymentTarget: "14.0"
+    sources:
+      - path: Sources
+    settings:
+      base:
+        PRODUCT_BUNDLE_IDENTIFIER: net.hyungi.dsshell
+        PRODUCT_NAME: DS
+        MARKETING_VERSION: "0.1"
+        CURRENT_PROJECT_VERSION: "1"
+        ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
+    info:
+      path: Support/Mac-Info.plist
+      properties:
+        CFBundleName: DS
+        CFBundleDisplayName: DS
+        CFBundleShortVersionString: "0.1"
+        CFBundleVersion: "1"
+        CFBundlePackageType: APPL
+        LSMinimumSystemVersion: "14.0"
+        LSApplicationCategoryType: public.app-category.productivity
+    entitlements:
+      path: Support/Mac.entitlements
+      properties:
+        com.apple.security.app-sandbox: true
+        com.apple.security.network.client: true
+        com.apple.security.files.downloads.read-write: true     # 원본 다운로드 저장
+        com.apple.security.files.user-selected.read-write: true # 업로드 파일 선택
+
+  DSShelliOS:
+    type: application
+    platform: iOS
+    deploymentTarget: "17.0"
+    sources:
+      - path: Sources
+    settings:
+      base:
+        PRODUCT_BUNDLE_IDENTIFIER: net.hyungi.dsshell
+        PRODUCT_NAME: DS
+        MARKETING_VERSION: "0.1"
+        CURRENT_PROJECT_VERSION: "1"
+        TARGETED_DEVICE_FAMILY: "1,2"
+        ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
+    info:
+      path: Support/iOS-Info.plist
+      properties:
+        CFBundleName: DS
+        CFBundleDisplayName: DS
+        CFBundleShortVersionString: "0.1"
+        CFBundleVersion: "1"
+        UILaunchScreen: {}
+        UISupportedInterfaceOrientations:
+          - UIInterfaceOrientationPortrait
+          - UIInterfaceOrientationLandscapeLeft
+          - UIInterfaceOrientationLandscapeRight
+
+schemes:
+  DSShellMac:
+    build:
+      targets: { DSShellMac: all }
+    run: { config: Debug }
+  DSShelliOS:
+    build:
+      targets: { DSShelliOS: all }
+    run: { config: Debug }

clients/ds-watch/.gitignore

@@ -0,0 +1,5 @@
+# xcodegen 생성물 (project.yml 이 source of truth)
+DSWatch.xcodeproj/
+Support/
+.build/
+*.xcuserstate

clients/ds-watch/Sources/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,6 @@
+{
+  "images" : [
+    { "idiom" : "universal", "platform" : "watchos", "size" : "1024x1024", "filename" : "watch_1024.png" }
+  ],
+  "info" : { "author" : "xcode", "version" : 1 }
+}

clients/ds-watch/Sources/Assets.xcassets/Contents.json

@@ -0,0 +1,3 @@
+{
+  "info" : { "author" : "xcode", "version" : 1 }
+}

clients/ds-watch/Sources/DSWatchApp.swift

@@ -0,0 +1,28 @@
+import SwiftUI
+
+/// DS 애플워치 앱 (standalone). 4기능 = 이드(AI채팅)·공부(암기카드)·할 일·브리핑.
+/// 공부 = 라이브 결선(/study-cards/due·rate) / 나머지 = 스캐폴드. 다크 OLED.
+@main
+struct DSWatchApp: App {
+    @State private var model = WatchModel()
+
+    var body: some Scene {
+        WindowGroup {
+            RootGate()
+                .environment(model)
+                .task { await model.bootstrap() }
+        }
+    }
+}
+
+/// 인증 게이트: checking(쿠키 복귀) → loggedOut(로그인) → ready(메뉴).
+struct RootGate: View {
+    @Environment(WatchModel.self) private var model
+    var body: some View {
+        switch model.phase {
+        case .checking: ProgressView()
+        case .loggedOut: LoginView()
+        case .ready: RootMenu()
+        }
+    }
+}

clients/ds-watch/Sources/Haptics.swift

@@ -0,0 +1,9 @@
+import WatchKit
+
+/// 워치 햅틱 — 평정/완료의 손목 탭 피드백(워치 고유 감각).
+@MainActor
+enum Haptics {
+    static func success() { WKInterfaceDevice.current().play(.success) }
+    static func retry() { WKInterfaceDevice.current().play(.retry) }
+    static func click() { WKInterfaceDevice.current().play(.click) }
+}

clients/ds-watch/Sources/Net.swift

@@ -0,0 +1,262 @@
+import Foundation
+
+/// 워치 전용 경량 API 클라이언트. DS 공개 TLS(document.hyungi.net) 직접 도달 — 워치는 Tailscale 불가.
+/// access 토큰=메모리 / refresh 쿠키=HTTPCookieStorage(7일 영속) 라 1회 로그인 후 자동 유지.
+/// 계약은 백엔드 Pydantic 모델에서 추출(study_cards.py CardItem/RateBody) — 지어내지 않음.
+enum WatchAPI {
+    static let baseString = "https://document.hyungi.net/api"
+}
+
+/// GET /study-cards/due 의 CardItem (워치가 쓰는 필드만).
+struct WCard: Decodable, Identifiable, Sendable {
+    let id: Int
+    let format: String
+    let cue: String
+    let fact: String
+    let clozeText: String?
+    let needsReview: Bool
+    let reviewStage: Int?
+
+    enum CodingKeys: String, CodingKey {
+        case id, format, cue, fact
+        case clozeText = "cloze_text"
+        case needsReview = "needs_review"
+        case reviewStage = "review_stage"
+    }
+}
+
+/// GET /events/today 의 EventResponse (워치 할일이 쓰는 필드만).
+struct WEvent: Decodable, Identifiable, Sendable {
+    let id: Int
+    let title: String
+    let status: String
+    let dueAt: String?
+    let completedAt: String?
+    enum CodingKeys: String, CodingKey {
+        case id, title, status
+        case dueAt = "due_at"
+        case completedAt = "completed_at"
+    }
+    var isDone: Bool { status == "completed" || completedAt != nil }
+}
+private struct WEventList: Decodable { let items: [WEvent] }
+
+/// GET /briefing/latest 의 토픽/국가관점 (워치 글랜스용 부분집합).
+struct WPerspective: Decodable, Identifiable, Sendable {
+    let country: String
+    let summary: String
+    var id: String { country }
+}
+struct WTopic: Decodable, Identifiable, Sendable {
+    let id: Int
+    let topicLabel: String
+    let headline: String
+    let countryPerspectives: [WPerspective]
+    enum CodingKeys: String, CodingKey {
+        case id, headline
+        case topicLabel = "topic_label"
+        case countryPerspectives = "country_perspectives"
+    }
+}
+struct WBriefing: Decodable, Sendable {
+    let status: String
+    let headlineOneliner: String?
+    let topics: [WTopic]
+    enum CodingKeys: String, CodingKey {
+        case status, topics
+        case headlineOneliner = "headline_oneliner"
+    }
+}
+
+/// 이드 채팅 결과 — SSE 누적 답변 또는 unavailable(맥미니 대기/고장).
+struct ChatResult: Sendable {
+    let answer: String
+    let unavailable: Bool
+    let reason: String?
+}
+
+private struct AccessTokenBody: Decodable { let accessToken: String
+    enum CodingKeys: String, CodingKey { case accessToken = "access_token" } }
+
+enum WCError: Error, LocalizedError {
+    case transport(String)
+    case http(Int, String?)
+    case decoding(String)
+    var errorDescription: String? {
+        switch self {
+        case .transport(let m): return "네트워크 오류: \(m)"
+        case .http(let s, let m): return m ?? "서버 오류 (\(s))"
+        case .decoding(let m): return "응답 해석 실패: \(m)"
+        }
+    }
+    var isUnauthorized: Bool { if case .http(401, _) = self { return true }; return false }
+}
+
+actor WatchClient {
+    private let session: URLSession
+    private var accessToken: String?
+
+    init() {
+        let cfg = URLSessionConfiguration.default
+        cfg.httpCookieStorage = .shared
+        cfg.httpShouldSetCookies = true
+        cfg.waitsForConnectivity = true
+        session = URLSession(configuration: cfg)
+    }
+
+    private func url(_ path: String) -> URL { URL(string: WatchAPI.baseString + "/" + path)! }
+
+    private func send(_ req: URLRequest) async throws -> (Data, HTTPURLResponse) {
+        do {
+            let (d, r) = try await session.data(for: req)
+            guard let h = r as? HTTPURLResponse else { throw WCError.transport("no HTTP response") }
+            return (d, h)
+        } catch let e as WCError { throw e }
+        catch { throw WCError.transport("\(error.localizedDescription)") }
+    }
+
+    private static func decodeMessage(_ data: Data) -> String? {
+        guard let o = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else { return nil }
+        if let s = o["detail"] as? String { return s }
+        if let d = o["detail"] as? [String: Any] { return d["message"] as? String }
+        return nil
+    }
+
+    // MARK: auth
+
+    func login(username: String, password: String, totp: String?) async throws {
+        var req = URLRequest(url: url("auth/login"))
+        req.httpMethod = "POST"
+        req.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        var body: [String: Any] = ["username": username, "password": password]
+        if let totp, !totp.isEmpty { body["totp_code"] = totp }
+        req.httpBody = try JSONSerialization.data(withJSONObject: body)
+        let (data, http) = try await send(req)
+        guard (200..<300).contains(http.statusCode) else { throw WCError.http(http.statusCode, Self.decodeMessage(data)) }
+        accessToken = try decodeToken(data)
+    }
+
+    @discardableResult
+    func refresh() async throws -> String {
+        var req = URLRequest(url: url("auth/refresh"))
+        req.httpMethod = "POST"
+        let (data, http) = try await send(req)
+        guard (200..<300).contains(http.statusCode) else { throw WCError.http(http.statusCode, Self.decodeMessage(data)) }
+        let t = try decodeToken(data)
+        accessToken = t
+        return t
+    }
+
+    func logout() async {
+        accessToken = nil
+        var req = URLRequest(url: url("auth/logout")); req.httpMethod = "POST"
+        _ = try? await send(req)
+    }
+
+    private func decodeToken(_ data: Data) throws -> String {
+        do { return try JSONDecoder().decode(AccessTokenBody.self, from: data).accessToken }
+        catch { throw WCError.decoding("token: \(error)") }
+    }
+
+    // MARK: authed request (401 → single refresh + retry)
+
+    private func authed(_ path: String, method: String = "GET", json: [String: Any]? = nil) async throws -> Data {
+        func make(_ token: String?) throws -> URLRequest {
+            var r = URLRequest(url: url(path))
+            r.httpMethod = method
+            if let token { r.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization") }
+            if let json { r.httpBody = try JSONSerialization.data(withJSONObject: json); r.setValue("application/json", forHTTPHeaderField: "Content-Type") }
+            return r
+        }
+        let (data, http) = try await send(make(accessToken))
+        if http.statusCode == 401 {
+            let newToken = try await refresh()
+            let (d2, h2) = try await send(make(newToken))
+            guard (200..<300).contains(h2.statusCode) else { throw WCError.http(h2.statusCode, Self.decodeMessage(d2)) }
+            return d2
+        }
+        guard (200..<300).contains(http.statusCode) else { throw WCError.http(http.statusCode, Self.decodeMessage(data)) }
+        return data
+    }
+
+    // MARK: study cards
+
+    func dueCards() async throws -> [WCard] {
+        let data = try await authed("study-cards/due")
+        do { return try JSONDecoder().decode([WCard].self, from: data) }
+        catch { throw WCError.decoding("due: \(error)") }
+    }
+
+    func rate(cardId: Int, outcome: String) async throws {
+        _ = try await authed("study-cards/\(cardId)/rate", method: "POST", json: ["outcome": outcome])
+    }
+
+    func flag(cardId: Int) async throws {
+        _ = try await authed("study-cards/\(cardId)", method: "PATCH", json: ["needs_review": true])
+    }
+
+    // MARK: events (할일)
+
+    func events() async throws -> [WEvent] {
+        let data = try await authed("events/today")
+        do { return try JSONDecoder().decode(WEventList.self, from: data).items }
+        catch { throw WCError.decoding("events: \(error)") }
+    }
+
+    func completeEvent(id: Int) async throws {
+        _ = try await authed("events/\(id)/complete", method: "POST")
+    }
+
+    // MARK: briefing (모닝 브리핑)
+
+    func briefing() async throws -> WBriefing {
+        let data = try await authed("briefing/latest")
+        do { return try JSONDecoder().decode(WBriefing.self, from: data) }
+        catch { throw WCError.decoding("briefing: \(error)") }
+    }
+
+    // MARK: eid chat (SSE 누적 — 맥미니 26B via DS 프록시)
+
+    func chat(_ text: String) async throws -> ChatResult {
+        let payload: [String: Any] = ["mode": "daily", "messages": [["role": "user", "content": text]]]
+        func make(_ token: String?) throws -> URLRequest {
+            var r = URLRequest(url: url("eid/chat"))
+            r.httpMethod = "POST"
+            r.timeoutInterval = 120
+            if let token { r.setValue("Bearer \(token)", forHTTPHeaderField: "Authorization") }
+            r.setValue("application/json", forHTTPHeaderField: "Content-Type")
+            r.setValue("text/event-stream", forHTTPHeaderField: "Accept")
+            r.httpBody = try JSONSerialization.data(withJSONObject: payload)
+            return r
+        }
+        var (stream, resp) = try await session.bytes(for: make(accessToken))
+        if (resp as? HTTPURLResponse)?.statusCode == 401 {
+            let t = try await refresh()
+            (stream, resp) = try await session.bytes(for: make(t))
+        }
+        guard let http = resp as? HTTPURLResponse else { throw WCError.transport("no HTTP response") }
+        let ctype = http.value(forHTTPHeaderField: "Content-Type") ?? ""
+
+        if ctype.contains("text/event-stream") {
+            var answer = ""
+            for try await line in stream.lines {
+                guard line.hasPrefix("data:") else { continue }
+                let body = line.dropFirst(5).trimmingCharacters(in: .whitespaces)
+                if body == "[DONE]" || body.isEmpty { continue }
+                if let d = body.data(using: .utf8),
+                   let obj = try? JSONSerialization.jsonObject(with: d) as? [String: Any],
+                   let choices = obj["choices"] as? [[String: Any]],
+                   let delta = choices.first?["delta"] as? [String: Any],
+                   let content = delta["content"] as? String {
+                    answer += content
+                }
+            }
+            return ChatResult(answer: answer, unavailable: answer.isEmpty,
+                              reason: answer.isEmpty ? "빈 응답" : nil)
+        }
+        // 비-스트림 = unavailable JSONResponse (맥미니 대기/고장) — 사유 추출.
+        var raw = Data()
+        for try await b in stream { raw.append(b) }
+        return ChatResult(answer: "", unavailable: true, reason: Self.decodeMessage(raw) ?? "이드 연결 불가")
+    }
+}

clients/ds-watch/Sources/RootMenu.swift

@@ -0,0 +1,46 @@
+import SwiftUI
+
+/// 워치 홈 = 4기능 메뉴. 작은 화면이라 큰 탭타깃 리스트.
+struct RootMenu: View {
+    var body: some View {
+        NavigationStack {
+            List {
+                NavigationLink { EidView() } label: {
+                    MenuRow(symbol: "bubble.left.and.bubble.right.fill", title: "이드", sub: "AI 채팅")
+                }
+                NavigationLink { StudyView() } label: {
+                    MenuRow(symbol: "rectangle.on.rectangle.angled.fill", title: "공부", sub: "암기 카드")
+                }
+                NavigationLink { TodoView() } label: {
+                    MenuRow(symbol: "checklist", title: "할 일", sub: "오늘")
+                }
+                NavigationLink { BriefingView() } label: {
+                    MenuRow(symbol: "newspaper.fill", title: "브리핑", sub: "모닝")
+                }
+            }
+            .navigationTitle("DS")
+        }
+        .tint(WT.accent)
+    }
+}
+
+struct MenuRow: View {
+    let symbol: String
+    let title: String
+    let sub: String
+    var body: some View {
+        HStack(spacing: 10) {
+            Image(systemName: symbol)
+                .font(.system(size: 16))
+                .foregroundStyle(WT.accent)
+                .frame(width: 24)
+            VStack(alignment: .leading, spacing: 1) {
+                Text(title).font(.system(size: 16, weight: .semibold)).foregroundStyle(WT.ink)
+                Text(sub).font(.system(size: 11)).foregroundStyle(WT.muted)
+            }
+        }
+        .padding(.vertical, 3)
+    }
+}
+
+#Preview { RootMenu() }

clients/ds-watch/Sources/Scaffolds.swift

@@ -0,0 +1,160 @@
+import SwiftUI
+
+// MARK: - 할 일 (Todo) — GET /events/today + 탭하면 POST /complete
+
+struct TodoView: View {
+    @Environment(WatchModel.self) private var model
+    @State private var loaded = false
+
+    var body: some View {
+        Group {
+            if model.eventsLoading && model.events.isEmpty {
+                ProgressView()
+            } else if let e = model.eventsError, model.events.isEmpty {
+                retry("불러오기 실패\n\(e)") { await model.loadEvents() }
+            } else if model.events.isEmpty {
+                retry("오늘 할 일이 없어요", color: WT.muted) { await model.loadEvents() }
+            } else {
+                List(model.events) { ev in
+                    Button {
+                        if !ev.isDone { Haptics.success() }
+                        Task { await model.completeEvent(ev.id) }
+                    } label: {
+                        HStack(spacing: 10) {
+                            Image(systemName: ev.isDone ? "checkmark.circle.fill" : "circle")
+                                .font(.system(size: 17))
+                                .foregroundStyle(ev.isDone ? WT.accent : WT.muted)
+                            Text(ev.title)
+                                .font(.system(size: 14))
+                                .foregroundStyle(ev.isDone ? WT.muted : WT.ink)
+                                .strikethrough(ev.isDone, color: WT.muted)
+                            Spacer()
+                        }
+                        .padding(.vertical, 2)
+                    }
+                    .buttonStyle(.plain)
+                }
+            }
+        }
+        .navigationTitle("할 일")
+        .task { if !loaded { loaded = true; await model.loadEvents() } }
+    }
+}
+
+// MARK: - 브리핑 (모닝) — GET /briefing/latest, 글랜스→정독 스크롤
+
+struct BriefingView: View {
+    @Environment(WatchModel.self) private var model
+    @State private var loaded = false
+
+    var body: some View {
+        ScrollView {
+            if model.briefingLoading && model.briefing == nil {
+                ProgressView().padding(.top, 20)
+            } else if let e = model.briefingError, model.briefing == nil {
+                retry("불러오기 실패\n\(e)") { await model.loadBriefing() }
+            } else if let b = model.briefing, !b.topics.isEmpty {
+                VStack(alignment: .leading, spacing: 10) {
+                    if let one = b.headlineOneliner, !one.isEmpty {
+                        Text(one).font(.system(size: 15, weight: .semibold)).foregroundStyle(WT.ink)
+                    }
+                    ForEach(b.topics) { t in
+                        VStack(alignment: .leading, spacing: 5) {
+                            Text(t.headline).font(.system(size: 13, weight: .semibold)).foregroundStyle(WT.ink)
+                            ForEach(t.countryPerspectives) { p in
+                                HStack(alignment: .top, spacing: 5) {
+                                    Text(p.country.uppercased())
+                                        .font(.system(size: 9, weight: .bold)).foregroundStyle(WT.accent)
+                                        .frame(minWidth: 22, alignment: .leading)
+                                    Text(p.summary).font(.system(size: 11)).foregroundStyle(WT.muted).lineLimit(4)
+                                }
+                            }
+                        }
+                        .frame(maxWidth: .infinity, alignment: .leading)
+                        .padding(8)
+                        .background(WT.card, in: RoundedRectangle(cornerRadius: 12))
+                    }
+                }
+            } else {
+                retry("오늘 브리핑이 아직 없어요", color: WT.muted) { await model.loadBriefing() }
+            }
+        }
+        .navigationTitle("브리핑")
+        .task { if !loaded { loaded = true; await model.loadBriefing() } }
+    }
+}
+
+// MARK: - 이드 (AI 채팅) — POST /eid/chat (맥미니 26B via DS 프록시)
+
+struct EidView: View {
+    @Environment(WatchModel.self) private var model
+    @State private var draft = ""
+
+    var body: some View {
+        ScrollView {
+            VStack(spacing: 8) {
+                HStack(spacing: 6) {
+                    TextField("물어보기…", text: $draft)
+                        .textFieldStyle(.plain)
+                        .padding(8)
+                        .background(WT.card, in: RoundedRectangle(cornerRadius: 10))
+                    Button {
+                        let t = draft; draft = ""
+                        Task { await model.sendChat(t) }
+                    } label: {
+                        Image(systemName: "arrow.up.circle.fill").font(.system(size: 22))
+                    }
+                    .buttonStyle(.plain)
+                    .foregroundStyle(WT.accent)
+                    .disabled(draft.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty || model.chatSending)
+                }
+                if model.chatSending {
+                    HStack(spacing: 6) {
+                        ProgressView().controlSize(.small)
+                        Text("이드 생각 중…").font(.system(size: 11)).foregroundStyle(WT.muted)
+                    }
+                }
+                ForEach(model.chatTurns.reversed()) { turn in
+                    ChatBubble(turn: turn)
+                }
+                if model.chatTurns.isEmpty && !model.chatSending {
+                    Text("음성·키보드로 묻고\n맥미니 26B 가 답합니다")
+                        .font(.system(size: 11)).foregroundStyle(WT.muted)
+                        .multilineTextAlignment(.center).padding(.top, 8)
+                }
+            }
+        }
+        .navigationTitle("이드")
+    }
+}
+
+private struct ChatBubble: View {
+    let turn: WatchModel.ChatTurn
+    var body: some View {
+        let isUser = turn.role == "user"
+        let isError = turn.role == "error"
+        HStack {
+            if isUser { Spacer(minLength: 24) }
+            Text(turn.text)
+                .font(.system(size: 12))
+                .foregroundStyle(isUser ? .black : (isError ? WT.danger : WT.ink))
+                .frame(maxWidth: .infinity, alignment: isUser ? .trailing : .leading)
+                .padding(8)
+                .background(isUser ? WT.accent : (isError ? WT.danger.opacity(0.15) : WT.card),
+                            in: RoundedRectangle(cornerRadius: 10))
+            if !isUser { Spacer(minLength: 24) }
+        }
+    }
+}
+
+// MARK: - 공용 상태/재시도
+
+@MainActor
+private func retry(_ text: String, color: Color = WT.danger, _ action: @escaping () async -> Void) -> some View {
+    VStack(spacing: 10) {
+        Text(text).font(.system(size: 13)).foregroundStyle(color).multilineTextAlignment(.center)
+        Button("다시 불러오기") { Task { await action() } }.tint(WT.accent)
+    }
+    .frame(maxWidth: .infinity)
+    .padding(.horizontal, 6).padding(.top, 16)
+}

clients/ds-watch/Sources/StudyView.swift

@@ -0,0 +1,132 @@
+import SwiftUI
+
+/// 암기 카드 학습 (라이브) — 능동 회상(앞면 cue → 답 보기 → 뒷면 fact) + 2단 평정(다시/알아요).
+/// 확정 워치 설계(B5): 2단 평정만(애매는 웹), '이 카드 이상해요' 플래그(교정은 웹/폰), 다크 OLED.
+/// 데이터 = GET /study-cards/due, 평정 = POST /{id}/rate (correct/wrong), 플래그 = PATCH needs_review.
+struct StudyView: View {
+    @Environment(WatchModel.self) private var model
+    @State private var index = 0
+    @State private var revealed = false
+    @State private var correctCount = 0
+    @State private var flagged = false
+    @State private var loaded = false
+
+    var body: some View {
+        Group {
+            if model.studyLoading && model.cards.isEmpty {
+                ProgressView()
+            } else if let err = model.studyError, model.cards.isEmpty {
+                stateText("불러오기 실패\n\(err)", color: WT.danger, retry: true)
+            } else if model.cards.isEmpty {
+                stateText("복습할 카드가 없어요", color: WT.muted, retry: true)
+            } else if index >= model.cards.count {
+                ResultView(total: model.cards.count, correct: correctCount) { Task { await reload() } }
+            } else {
+                cardScreen(model.cards[index])
+            }
+        }
+        .navigationTitle("공부")
+        .task { if !loaded { loaded = true; await model.loadDue(); reset() } }
+    }
+
+    private func cardScreen(_ c: WCard) -> some View {
+        VStack(spacing: 8) {
+            HStack {
+                Text("\(index + 1) / \(model.cards.count)").font(.system(size: 11)).foregroundStyle(WT.muted)
+                Spacer()
+                Button {
+                    flagged = true
+                    Haptics.click()
+                    Task { await model.flag(cardId: c.id) }
+                } label: {
+                    Image(systemName: flagged ? "flag.fill" : "flag")
+                        .font(.system(size: 11)).foregroundStyle(flagged ? WT.amber : WT.muted)
+                }
+                .buttonStyle(.plain)
+            }
+
+            ScrollView {
+                VStack(spacing: 10) {
+                    Text(c.cue)
+                        .font(.system(size: 17, weight: .semibold)).foregroundStyle(WT.ink)
+                        .multilineTextAlignment(.center)
+                    if revealed {
+                        Divider().overlay(WT.muted.opacity(0.4))
+                        Text(c.fact)
+                            .font(.system(size: 15)).foregroundStyle(WT.accent)
+                            .multilineTextAlignment(.center)
+                    }
+                }
+                .frame(maxWidth: .infinity)
+                .padding(12)
+                .background(WT.card, in: RoundedRectangle(cornerRadius: 14))
+            }
+
+            if revealed {
+                HStack(spacing: 8) {
+                    rateButton("다시", sub: "내일", color: WT.danger) { advance(c, correct: false) }
+                    rateButton("알아요", sub: nil, color: WT.accent) { advance(c, correct: true) }
+                }
+            } else {
+                Button { withAnimation(.easeOut(duration: 0.15)) { revealed = true } } label: {
+                    Text("답 보기").frame(maxWidth: .infinity)
+                }
+                .tint(WT.accent)
+            }
+        }
+        .padding(.horizontal, 4)
+    }
+
+    private func rateButton(_ title: String, sub: String?, color: Color, _ action: @escaping () -> Void) -> some View {
+        Button(action: action) {
+            VStack(spacing: 1) {
+                Text(title).font(.system(size: 14, weight: .semibold))
+                if let sub { Text(sub).font(.system(size: 9)).opacity(0.8) }
+            }
+            .frame(maxWidth: .infinity).padding(.vertical, 2)
+        }
+        .tint(color)
+    }
+
+    private func stateText(_ text: String, color: Color, retry: Bool) -> some View {
+        VStack(spacing: 10) {
+            Text(text).font(.system(size: 13)).foregroundStyle(color).multilineTextAlignment(.center)
+            if retry { Button("다시 불러오기") { Task { await reload() } }.tint(WT.accent) }
+        }
+        .padding(.horizontal, 6)
+    }
+
+    private func advance(_ c: WCard, correct: Bool) {
+        if correct { correctCount += 1 }
+        Haptics.success() // 평정 손목 탭 (다시/알아요 동일 확정 피드백)
+        Task { await model.rate(cardId: c.id, outcome: correct ? "correct" : "wrong") }
+        flagged = false
+        revealed = false
+        index += 1
+    }
+
+    private func reload() async { await model.loadDue(); reset() }
+    private func reset() { index = 0; revealed = false; correctCount = 0; flagged = false }
+}
+
+/// 세션 결과 — 정직한 tally만(서버 미제공 streak 등 날조 X).
+struct ResultView: View {
+    let total: Int
+    let correct: Int
+    let onRestart: () -> Void
+
+    var body: some View {
+        ScrollView {
+            VStack(spacing: 10) {
+                Image(systemName: "checkmark.seal.fill").font(.system(size: 30)).foregroundStyle(WT.accent)
+                Text("오늘 복습 완료").font(.system(size: 16, weight: .semibold)).foregroundStyle(WT.ink)
+                Text("\(correct) / \(total) 알아요").font(.system(size: 13)).foregroundStyle(WT.muted)
+                Text("애매하거나 몰랐던 카드는 내일 다시 만나요")
+                    .font(.system(size: 11)).foregroundStyle(WT.muted).multilineTextAlignment(.center)
+                Button("다시 불러오기", action: onRestart).tint(WT.accent).padding(.top, 4)
+            }
+            .frame(maxWidth: .infinity).padding(.vertical, 6)
+        }
+        .navigationTitle("결과")
+    }
+}

clients/ds-watch/Sources/WatchModel.swift

@@ -0,0 +1,162 @@
+import SwiftUI
+import Observation
+
+/// 워치 앱 상태. 부팅 시 refresh 쿠키로 무로그인 복귀 시도 → 실패 시 로그인. 공부 카드 라이브 결선.
+@MainActor
+@Observable
+final class WatchModel {
+    enum Phase: Equatable { case checking, loggedOut, ready }
+
+    var phase: Phase = .checking
+    var loginError: String?
+
+    // 공부(study)
+    var cards: [WCard] = []
+    var studyLoading = false
+    var studyError: String?
+
+    // 할일(events)
+    var events: [WEvent] = []
+    var eventsLoading = false
+    var eventsError: String?
+
+    // 브리핑
+    var briefing: WBriefing?
+    var briefingLoading = false
+    var briefingError: String?
+
+    // 이드(chat)
+    struct ChatTurn: Identifiable, Sendable { let id: Int; let role: String; let text: String }
+    var chatTurns: [ChatTurn] = []
+    var chatSending = false
+    private var chatSeq = 0
+
+    private let client = WatchClient()
+
+    func bootstrap() async {
+        do { _ = try await client.refresh(); phase = .ready }
+        catch { phase = .loggedOut }   // 쿠키 없음/만료 = 정상 로그인 흐름
+    }
+
+    func login(username: String, password: String, totp: String?) async {
+        loginError = nil
+        let code = totp?.trimmingCharacters(in: .whitespacesAndNewlines)
+        do {
+            try await client.login(username: username, password: password,
+                                   totp: (code?.isEmpty ?? true) ? nil : code)
+            phase = .ready
+        } catch {
+            loginError = (error as? LocalizedError)?.errorDescription ?? "\(error)"
+        }
+    }
+
+    func logout() async {
+        await client.logout()
+        cards = []; studyError = nil
+        phase = .loggedOut
+    }
+
+    func loadDue() async {
+        studyLoading = true; studyError = nil
+        do { cards = try await client.dueCards() }
+        catch let e as WCError where e.isUnauthorized { phase = .loggedOut }
+        catch { studyError = (error as? LocalizedError)?.errorDescription ?? "\(error)" }
+        studyLoading = false
+    }
+
+    /// 평정 전송 (correct/wrong). 실패해도 학습 흐름은 진행(다음 카드) — 오류만 표시.
+    func rate(cardId: Int, outcome: String) async {
+        do { try await client.rate(cardId: cardId, outcome: outcome) }
+        catch let e as WCError where e.isUnauthorized { phase = .loggedOut }
+        catch { studyError = (error as? LocalizedError)?.errorDescription ?? "\(error)" }
+    }
+
+    func flag(cardId: Int) async {
+        do { try await client.flag(cardId: cardId) }
+        catch { studyError = (error as? LocalizedError)?.errorDescription ?? "\(error)" }
+    }
+
+    // MARK: 할일(events)
+
+    func loadEvents() async {
+        eventsLoading = true; eventsError = nil
+        do { events = try await client.events() }
+        catch let e as WCError where e.isUnauthorized { phase = .loggedOut }
+        catch { eventsError = (error as? LocalizedError)?.errorDescription ?? "\(error)" }
+        eventsLoading = false
+    }
+
+    func completeEvent(_ id: Int) async {
+        do { try await client.completeEvent(id: id); await loadEvents() }
+        catch let e as WCError where e.isUnauthorized { phase = .loggedOut }
+        catch { eventsError = (error as? LocalizedError)?.errorDescription ?? "\(error)" }
+    }
+
+    // MARK: 브리핑
+
+    func loadBriefing() async {
+        briefingLoading = true; briefingError = nil
+        do { briefing = try await client.briefing() }
+        catch let e as WCError where e.isUnauthorized { phase = .loggedOut }
+        catch { briefingError = (error as? LocalizedError)?.errorDescription ?? "\(error)" }
+        briefingLoading = false
+    }
+
+    // MARK: 이드(chat)
+
+    func sendChat(_ text: String) async {
+        let t = text.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard !t.isEmpty, !chatSending else { return }
+        chatSeq += 1; chatTurns.append(.init(id: chatSeq, role: "user", text: t))
+        chatSending = true
+        do {
+            let result = try await client.chat(t)
+            chatSeq += 1
+            if result.unavailable {
+                chatTurns.append(.init(id: chatSeq, role: "error", text: result.reason ?? "이드 연결 불가"))
+            } else {
+                chatTurns.append(.init(id: chatSeq, role: "assistant", text: result.answer))
+            }
+        } catch let e as WCError where e.isUnauthorized {
+            phase = .loggedOut
+        } catch {
+            chatSeq += 1
+            chatTurns.append(.init(id: chatSeq, role: "error",
+                                   text: (error as? LocalizedError)?.errorDescription ?? "\(error)"))
+        }
+        chatSending = false
+    }
+}
+
+/// 워치 1회 로그인 (refresh 쿠키 7일 → 사실상 주1회). TOTP 사용 계정이라 6자리 코드 입력란 포함.
+struct LoginView: View {
+    @Environment(WatchModel.self) private var model
+    @State private var username = ""
+    @State private var password = ""
+    @State private var totp = ""
+    @State private var busy = false
+
+    var body: some View {
+        ScrollView {
+            VStack(spacing: 8) {
+                Text("DS 로그인").font(.system(size: 16, weight: .semibold)).foregroundStyle(WT.ink)
+                TextField("아이디", text: $username)
+                    .textContentType(.username)
+                SecureField("비밀번호", text: $password)
+                TextField("OTP 6자리", text: $totp)
+                if let err = model.loginError {
+                    Text(err).font(.system(size: 11)).foregroundStyle(WT.danger).multilineTextAlignment(.center)
+                }
+                Button {
+                    busy = true
+                    Task { await model.login(username: username, password: password, totp: totp); busy = false }
+                } label: {
+                    if busy { ProgressView() } else { Text("로그인").frame(maxWidth: .infinity) }
+                }
+                .tint(WT.accent)
+                .disabled(busy || username.isEmpty || password.isEmpty)
+            }
+            .padding(.horizontal, 4)
+        }
+    }
+}

clients/ds-watch/Sources/WatchTheme.swift

@@ -0,0 +1,12 @@
+import SwiftUI
+
+/// 워치 다크 OLED 토큰 (시안 watch-app: --wgreen #37d67a). 검정 배경 = OLED 절전·대비.
+enum WT {
+    static let bg = Color.black
+    static let card = Color(white: 0.12)
+    static let accent = Color(red: 0x37 / 255, green: 0xd6 / 255, blue: 0x7a / 255)  // #37d67a
+    static let ink = Color.white
+    static let muted = Color(white: 0.62)
+    static let amber = Color(red: 0xf2 / 255, green: 0xb6 / 255, blue: 0x3c / 255)
+    static let danger = Color(red: 0xe5 / 255, green: 0x6a / 255, blue: 0x5a / 255)
+}

clients/ds-watch/project.yml

@@ -0,0 +1,55 @@
+# DS Apple Watch 앱 (단일 타깃 standalone watchOS, WKApplication). 맥/아이폰은 웹 래퍼로 가고
+# 순수 네이티브는 워치 전용(2026-06-15 사용자 결정). 시뮬레이터 빌드·스크린샷으로 검증, 실기기
+# 설치는 사용자 Xcode 서명. project.yml = source of truth, *.xcodeproj/Support 는 생성물(gitignore).
+name: DSWatch
+options:
+  bundleIdPrefix: net.hyungi
+  deploymentTarget:
+    watchOS: "11.0"
+  createIntermediateGroups: true
+  minimumXcodeGenVersion: "2.40.0"
+
+settings:
+  base:
+    SWIFT_VERSION: "6.0"
+    SWIFT_STRICT_CONCURRENCY: complete
+    WATCHOS_DEPLOYMENT_TARGET: "11.0"
+    CODE_SIGN_STYLE: Automatic
+    # 실기기 설치 시 Xcode 에서 Signing → 본인 Apple ID 팀 선택하면 자동 서명.
+    # (헤드리스 시뮬 빌드는 xcodebuild 에 CODE_SIGNING_ALLOWED=NO 를 CLI 로 전달)
+
+targets:
+  DSWatch:
+    type: application
+    platform: watchOS
+    deploymentTarget: "11.0"
+    sources:
+      - path: Sources
+    settings:
+      base:
+        PRODUCT_BUNDLE_IDENTIFIER: net.hyungi.dswatch
+        PRODUCT_NAME: DS
+        GENERATE_INFOPLIST_FILE: "NO"
+        MARKETING_VERSION: "0.1"
+        CURRENT_PROJECT_VERSION: "1"
+        TARGETED_DEVICE_FAMILY: "4"   # Apple Watch
+        ASSETCATALOG_COMPILER_APPICON_NAME: AppIcon
+    info:
+      path: Support/Info.plist
+      properties:
+        CFBundleDisplayName: DS
+        CFBundleName: DS
+        CFBundleVersion: "1"
+        CFBundleShortVersionString: "0.1"
+        WKApplication: true            # 단일 타깃 standalone 워치 앱 (컴패니언 불요)
+        WKWatchOnly: true              # 컴패니언 iOS 앱 없는 watch-only (설치 필수 키)
+        UISupportedInterfaceOrientations:
+          - UIInterfaceOrientationPortrait
+
+schemes:
+  DSWatch:
+    build:
+      targets:
+        DSWatch: all
+    run:
+      config: Debug

frontend/src/lib/components/ProcessingFlowBoard.svelte

@@ -210,6 +210,19 @@
   // 맥북이 요약을 실제로 가져가는 중인가 (합류 표식 게이트)
   const offloadActive = $derived(split.macbook.done_1h > 0);
 
+  // ─── 백그라운드 작업 (큐 밖 스크립트 backfill) — processing_queue 사각지대 노출 ───
+  const bgJobs = $derived(overview.background_jobs ?? []);
+  function fmtElapsed(s: number): string {
+    if (s < 60) return `${s}s`;
+    if (s < 3600) return `${Math.floor(s / 60)}m`;
+    return `${Math.floor(s / 3600)}h${Math.floor((s % 3600) / 60)}m`;
+  }
+  function bgDot(j: { state: string; stale: boolean }): string {
+    if (j.state === 'running') return j.stale ? 'bg-warning' : 'bg-success';
+    if (j.state === 'failed') return 'bg-error';
+    return 'bg-faint';
+  }
+
   // ─── 지배 백로그 = 요약. 정직 ETA(유입 차감) — summarize_eta ───
   const eta = $derived(overview.summarize_eta);
   // 정직 ETA 라벨: eta_minutes null = 유입이 소화를 앞섬(소진 불가)
@@ -466,6 +479,32 @@
     </div>
   {/if}
 
+  <!-- 백그라운드 작업 (큐 밖 스크립트 backfill 등 — processing_queue 가 못 보는 사각지대) -->
+  {#if bgJobs.length > 0}
+    <div class="mt-3">
+      <div class="text-[11px] font-bold text-dim uppercase tracking-wider mb-2">백그라운드 작업</div>
+      <div class="grid gap-2">
+        {#each bgJobs as j (j.id)}
+          <div class="bg-surface border rounded-card px-3.5 py-2.5 {j.stale ? 'border-warning' : j.state === 'failed' ? 'border-error' : 'border-default'}">
+            <div class="flex items-center gap-2 flex-wrap">
+              <span class="w-2 h-2 rounded-full shrink-0 {bgDot(j)}"></span>
+              <span class="text-[9px] font-bold rounded px-1.5 py-px bg-default text-dim font-mono">{j.kind}</span>
+              <span class="text-xs font-semibold text-text truncate">{j.label ?? '작업'}</span>
+              <span class="text-[11px] text-dim tabular-nums ml-auto">
+                {#if j.total}{j.processed.toLocaleString()}/{j.total.toLocaleString()}{:else}{j.processed.toLocaleString()}건{/if} · {fmtElapsed(j.elapsed_sec)}
+              </span>
+            </div>
+            {#if j.stale}
+              <div class="text-[10px] text-warning mt-1.5">heartbeat 끊김 — 프로세스 중단 추정 (재개 필요할 수 있음)</div>
+            {:else if j.state === 'failed'}
+              <div class="text-[10px] text-error mt-1.5 truncate">실패{#if j.error} · {j.error}{/if}</div>
+            {/if}
+          </div>
+        {/each}
+      </div>
+    </div>
+  {/if}
+
   <!-- 실패 처리 드로어 -->
   {#if failOpen}
     <div class="border border-error/40 rounded-card mt-3 overflow-hidden bg-surface">

frontend/src/lib/types/queue.ts

@@ -75,6 +75,20 @@ export interface QueueStageRow {
   oldest_pending_age_sec: number | null;
 }
 
+/** 큐 밖 관리 스크립트(백필 등) 작업 — processing_queue 가 못 보는 사각지대.
+ *  stale = running 인데 heartbeat 끊김(프로세스 사망 추정). */
+export interface BackgroundJob {
+  id: number;
+  kind: string;
+  label: string | null;
+  state: 'running' | 'done' | 'failed';
+  processed: number;
+  total: number | null;
+  elapsed_sec: number;
+  stale: boolean;
+  error: string | null;
+}
+
 export interface QueueOverview {
   machines: MachineOverview[];
   summarize_eta: SummarizeEta;
@@ -82,6 +96,7 @@ export interface QueueOverview {
   trend_24h: TrendPoint[];
   stages: QueueStageRow[];
   totals: QueueTotals;
+  background_jobs?: BackgroundJob[];
 }
 
 /** ─── 실패 처리 (ds-board-engines-1) — GET /api/queue/failed · POST /retry|/skip ─── */

frontend/src/lib/utils/headingPath.test.ts

@@ -83,6 +83,74 @@ test('[C2] collapseWindows: split-parent + window 들 → rail 1행, 대표=spli
   assert.equal(out[0].fragmentCount, 2, 'window 조각 수 = 2 (split-parent 자신 제외)');
 });
 
+test('collapseWindows: bodyText — 정상 leaf 는 자기 본문, split-parent 는 window 본문만 이어붙임', () => {
+  // 정상 leaf → 자기 text 가 본문
+  const leaf = collapseWindows([sec({ heading_path: 'Intro', node_type: null, text: '서론 본문' })]);
+  assert.equal(leaf[0].bodyText, '서론 본문');
+
+  // split-parent(heading 줄뿐) + window 2개 → window 본문만 순서대로 합침(헤딩 제외)
+  const split = collapseWindows([
+    sec({ heading_path: 'Article 5', node_type: 'chapter_split', is_leaf: false, char_start: 120, text: '# Article 5' }),
+    sec({ heading_path: 'Article 5', node_type: 'window', is_leaf: true, text: '본문 조각1' }),
+    sec({ heading_path: 'Article 5', node_type: 'window', is_leaf: true, text: '본문 조각2' }),
+  ]);
+  assert.equal(split.length, 1);
+  assert.equal(split[0].bodyText, '본문 조각1\n\n본문 조각2', 'split-parent heading 제외, window 본문만 합침');
+
+  // legacy window 런(선행 split-parent 없음) → 첫 window 자기 본문 + 흡수 조각
+  const legacy = collapseWindows([
+    sec({ heading_path: 'Pearson', node_type: 'window', text: 'p1' }),
+    sec({ heading_path: 'Pearson', node_type: 'window', text: 'p2' }),
+  ]);
+  assert.equal(legacy.length, 1);
+  assert.equal(legacy[0].bodyText, 'p1\n\np2');
+});
+
+test('collapseWindows: 절-레벨 분석 집계 — windowed 절은 window 멤버에서 type 다수결/conf 평균/summaries 합본', () => {
+  // split-parent(분석 없음) + window 3개(요약·유형·신뢰도 보유) → 대표에 집계
+  const out = collapseWindows([
+    sec({ heading_path: 'Sec A', node_type: 'section_split', is_leaf: false, char_start: 10, text: '# Sec A', section_type: null, summary: null, confidence: null }),
+    sec({ heading_path: 'Sec A', node_type: 'window', text: 'b1', section_type: 'requirement', summary: '요약1', confidence: 0.9 }),
+    sec({ heading_path: 'Sec A', node_type: 'window', text: 'b2', section_type: 'requirement', summary: '요약2', confidence: 0.8 }),
+    sec({ heading_path: 'Sec A', node_type: 'window', text: 'b3', section_type: 'overview', summary: '', confidence: 1.0 }),
+  ]);
+  assert.equal(out.length, 1);
+  assert.equal(out[0].sectionType, 'requirement', '다수결 = requirement(2) > overview(1)');
+  assert.ok(Math.abs(out[0].confidence! - 0.9) < 1e-9, '평균 (0.9+0.8+1.0)/3 = 0.9');
+  assert.deepEqual(out[0].summaries, ['요약1', '요약2'], '빈 요약 제외, 순서 유지');
+
+  // 단일 leaf 는 대표 자신의 분석
+  const single = collapseWindows([sec({ heading_path: 'X', node_type: null, text: 'body', section_type: 'definition', summary: '정의 요약', confidence: 0.7 })]);
+  assert.equal(single[0].sectionType, 'definition');
+  assert.equal(single[0].confidence, 0.7);
+  assert.deepEqual(single[0].summaries, ['정의 요약']);
+
+  // 분석 전혀 없는 절 → null/빈
+  const none = collapseWindows([sec({ heading_path: 'Y', node_type: null, text: 'body' })]);
+  assert.equal(none[0].sectionType, null);
+  assert.equal(none[0].confidence, null);
+  assert.deepEqual(none[0].summaries, []);
+});
+
+test('collapseWindows: 비인접 window 도 parent_id 로 split-parent 에 흡수 (빈 split 행 방지)', () => {
+  // 실데이터 버그: split-parent(chunk_index 1143)와 그 window(1233~)가 비인접 → 인접 흡수 실패로
+  // 빈 split 행 + 별도 window-그룹 행 2개로 쪼개짐. parent_id 링크로 정확히 합친다.
+  const out = collapseWindows([
+    sec({ chunk_id: 10, heading_path: 'FOREWORD', node_type: 'section_split', is_leaf: false, char_start: 5, text: '# FOREWORD' }),
+    sec({ chunk_id: 11, heading_path: 'POLICY', node_type: null, text: '정책 본문' }), // 사이에 낀 다른 절
+    sec({ chunk_id: 12, heading_path: 'FOREWORD', node_type: 'window', parent_id: 10, text: '서문 조각1', section_type: 'overview', summary: '요약A', confidence: 0.9 }),
+    sec({ chunk_id: 13, heading_path: 'FOREWORD', node_type: 'window', parent_id: 10, text: '서문 조각2', section_type: 'overview', summary: '요약B', confidence: 0.8 }),
+  ]);
+  assert.equal(out.length, 2, 'FOREWORD(split, window 흡수) + POLICY = 2행 (빈 split 행 없음)');
+  assert.equal(out[0].section.chunk_id, 10, '대표 = split-parent(char_start 보유)');
+  assert.equal(out[0].bodyText, '서문 조각1\n\n서문 조각2', '비인접 window 본문을 split-parent 에 흡수');
+  assert.equal(out[0].fragmentCount, 2);
+  assert.equal(out[0].sectionType, 'overview');
+  assert.deepEqual(out[0].summaries, ['요약A', '요약B']);
+  assert.equal(out[1].section.chunk_id, 11, '사이 낀 절은 별도 행 유지');
+  assert.equal(out[1].bodyText, '정책 본문');
+});
+
 test('groupOrFlat: 적은 그룹 + 낮은 기타% → group (5140-류)', () => {
   // 3 top segment × 4 = 12절, window 없음 → group_count 3, 기타 0%
   const sections: DocumentSection[] = [];

frontend/src/lib/utils/headingPath.ts

@@ -14,8 +14,12 @@ export interface DocumentSection {
   level: number | null;
   node_type: string | null; // 'window' | 'chapter_split' | 'clause_split' | 'section_split' | null
   is_leaf: boolean;
+  /** 트리 부모 chunk_id. window child 의 parent_id = 그 split-parent (비인접 흡수에 사용). */
+  parent_id?: number | null;
   /** md_content 내 heading offset(UTF-16). jump-target 만 값, window-child/preamble/Path A = null (Path B). */
   char_start?: number | null;
+  /** 절 본문 = 청크 원문. split-parent 는 heading 줄뿐, window child 가 실 본문 보유. */
+  text?: string | null;
   section_type: string | null;
   summary: string | null;
   confidence: number | null;
@@ -25,6 +29,17 @@ export interface DocumentSection {
 export interface OutlineItem {
   section: DocumentSection;
   fragmentCount: number; // >1 이면 "(n조각)" 배지
+  /** 대표 + 흡수된 window child 들의 본문을 순서대로 이어붙인 논리 절 전체 본문.
+   *  split-parent 는 heading 줄(text)을 본문에서 제외(제목과 중복) — window 본문만 합친다. */
+  bodyText: string;
+  /** 집계된 절-레벨 분석. windowed 절은 분석이 window child(chunk_section_analysis)에 붙고
+   *  대표=split-parent 엔 없으므로 멤버에서 집계한다. 단일 절은 대표 자신의 값.
+   *  - sectionType: 멤버 section_type 다수결(동률=첫 등장)
+   *  - confidence: 멤버 confidence 평균
+   *  - summaries: 멤버 요약(빈 것 제외, chunk_index 순) — 단일=1개, windowed=N개(부분별 요약) */
+  sectionType: string | null;
+  confidence: number | null;
+  summaries: string[];
 }
 
 export interface OutlineGroup {
@@ -107,22 +122,78 @@ function topSegment(s: DocumentSection): string {
  *   fragmentCount: split-parent 대표는 0 에서 시작(자신은 조각 아님) + 흡수 child 수 = 실제 조각 수;
  *   legacy window 대표는 1 에서 시작(자신이 첫 조각).
  */
+/** 멤버 section_type 다수결(동률은 첫 등장 우선). 비어있으면 null. */
+function majorityType(types: (string | null)[]): string | null {
+  const vals = types.filter((t): t is string => !!t);
+  if (!vals.length) return null;
+  const count = new Map<string, number>();
+  for (const t of vals) count.set(t, (count.get(t) ?? 0) + 1);
+  let best: string | null = null;
+  let bestN = -1;
+  for (const t of vals) {
+    const n = count.get(t)!;
+    if (n > bestN) { bestN = n; best = t; } // 첫 등장 우선 tie-break
+  }
+  return best;
+}
+
 export function collapseWindows(sections: DocumentSection[]): OutlineItem[] {
   const out: OutlineItem[] = [];
+  const members: DocumentSection[][] = []; // out[i] 의 멤버(대표 + 흡수된 window child)
+  const repByChunkId = new Map<number, number>(); // split-parent chunk_id → out index (window 가 parent_id 로 흡수)
+
+  // window child 본문/멤버를 out[idx] 대표에 흡수.
+  const absorb = (idx: number, s: DocumentSection) => {
+    out[idx].fragmentCount += 1;
+    const t = (s.text ?? '').trim();
+    if (t) out[idx].bodyText = out[idx].bodyText ? `${out[idx].bodyText}\n\n${t}` : t;
+    members[idx].push(s);
+  };
+
   for (const s of sections) {
-    const prev = out[out.length - 1];
-    const h = cleanHeading(s.heading_path);
-    const prevAbsorbs =
-      prev &&
-      (prev.section.node_type === 'window' || !!prev.section.node_type?.endsWith('_split')) &&
-      h !== '' &&
-      cleanHeading(prev.section.heading_path) === h;
-    if (s.node_type === 'window' && prevAbsorbs) {
-      prev!.fragmentCount += 1; // window child 흡수 — 대표(split-parent 우선)는 그대로 유지
+    if (s.node_type === 'window') {
+      // 1) parent_id 로 split-parent 대표에 흡수 — split-parent 와 window 가 chunk_index 상 비인접일 수
+      //    있으므로(예: 헤딩 1143, window 1233) 인접 가정 대신 트리 부모 링크로 정확히 연결한다.
+      let idx = s.parent_id != null ? repByChunkId.get(s.parent_id) ?? -1 : -1;
+      // 2) fallback: 인접 대표(legacy window run / 같은 heading split)면 흡수
+      if (idx < 0) {
+        const prev = out[out.length - 1];
+        const h = cleanHeading(s.heading_path);
+        if (
+          prev &&
+          (prev.section.node_type === 'window' || !!prev.section.node_type?.endsWith('_split')) &&
+          h !== '' &&
+          cleanHeading(prev.section.heading_path) === h
+        ) {
+          idx = out.length - 1;
+        }
+      }
+      if (idx >= 0) {
+        absorb(idx, s);
+        continue;
+      }
+      // 3) legacy: 부모 없는 window → 자기 대표(자기 본문으로 시작)
+      out.push({ section: s, fragmentCount: 1, bodyText: s.text ?? '', sectionType: null, confidence: null, summaries: [] });
+      members.push([s]);
     } else {
-      out.push({ section: s, fragmentCount: s.node_type?.endsWith('_split') ? 0 : 1 });
+      const isSplit = !!s.node_type?.endsWith('_split');
+      // split-parent 의 text 는 heading 줄뿐 → 본문에서 제외(window 가 본문 보유). 그 외엔 자기 본문으로 시작.
+      out.push({
+        section: s, fragmentCount: isSplit ? 0 : 1, bodyText: isSplit ? '' : (s.text ?? ''),
+        sectionType: null, confidence: null, summaries: [],
+      });
+      members.push([s]);
+      if (isSplit) repByChunkId.set(s.chunk_id, out.length - 1); // window 가 parent_id 로 찾아 흡수
     }
   }
+  // 멤버에서 절-레벨 분석 집계 (windowed 절: 대표 split-parent 엔 분석 없고 window 들이 보유).
+  for (let i = 0; i < out.length; i++) {
+    const mem = members[i];
+    out[i].sectionType = majorityType(mem.map((m) => m.section_type));
+    const confs = mem.map((m) => m.confidence).filter((c): c is number => c != null);
+    out[i].confidence = confs.length ? confs.reduce((a, b) => a + b, 0) / confs.length : null;
+    out[i].summaries = mem.map((m) => (m.summary ?? '').trim()).filter((x) => x !== '');
+  }
   return out;
 }
 

frontend/src/routes/documents/+page.svelte

@@ -8,8 +8,7 @@
   import { goto } from '$app/navigation';
   import { api } from '$lib/api';
   import { addToast } from '$lib/stores/toast';
-  import { Info, X, Plus, Trash2, Tag, FolderTree, Sparkles, ChevronLeft, ArrowUpDown } from 'lucide-svelte';
-  import DocumentViewer from '$lib/components/DocumentViewer.svelte';
+  import { X, Plus, Trash2, Tag, FolderTree, Sparkles, ArrowUpDown } from 'lucide-svelte';
   import MarkdownStatusBadge from '$lib/components/MarkdownStatusBadge.svelte';
   import { isMdStatusVisible } from '$lib/utils/mdStatus';
   import UploadDropzone from '$lib/components/UploadDropzone.svelte';
@@ -233,15 +232,12 @@
     goto(`/documents${qs ? '?' + qs : ''}`, { noScroll: true });
   }
 
-  async function selectDoc(doc) {
-    if (selectedDoc?.id === doc.id) { selectedDoc = null; return; }
-    selectedDoc = doc; // 즉시 표시(리더 + 기본 인스펙터)
-    // 인스펙터 풀 메타 하이드레이션 — 검색 결과(SearchResult)는 메타가 빈약(태그/크기/하위/md상태/읽음 없음).
-    // 풀 문서를 조회해 채운다(기존 GET /documents/{id}, 백엔드 무변). 리스트 모드도 md상태 등 보강.
-    try {
-      const full = await api(`/documents/${doc.id}`);
-      if (selectedDoc?.id === doc.id) selectedDoc = { ...doc, ...full };
-    } catch { /* 실패 시 기본 정보 유지 */ }
+  // 문서 열기 = 개선된 상세 페이지(D3 절 구조 탐색기)로 이동.
+  // 사용자 결정: "개선된 페이지가 앞으로 표시되야지" — 인라인 미리보기 폐기.
+  // /documents = 브라우즈/검색/필터/일괄 목록, 문서 열기 = /documents/[id] D3 리더.
+  function selectDoc(doc) {
+    if (!doc) return;
+    goto(`/documents/${doc.id}`);
   }
 
   // bulk 선택
@@ -386,8 +382,8 @@
 
 <div class="flex h-full min-h-0">
 
-  <!-- ═══ 좌: 리스트 컬럼 ═══ -->
-  <div class="{selectedDoc ? 'hidden lg:flex' : 'flex'} flex-col w-full lg:w-[340px] lg:shrink-0 lg:border-r border-default min-h-0">
+  <!-- ═══ 문서 목록 (풀폭 중앙) — 클릭 시 D3 상세로 이동 ═══ -->
+  <div class="flex flex-col w-full max-w-5xl mx-auto min-h-0">
     <UploadDropzone onupload={loadDocuments} />
 
     <!-- 검색바 -->
@@ -487,6 +483,19 @@
       {/if}
     </div>
 
+    <!-- AI 답변 (질문형 검색) — 목록 상단 고정, 아래로 목록 스크롤 -->
+    {#if showAskCard}
+      <div class="px-3 py-2 shrink-0 border-b border-default max-h-[55vh] overflow-y-auto">
+        <AskAnswerCard
+          data={askData}
+          loading={askLoading}
+          error={askError}
+          onCitationClick={(docId) => goto(`/documents/${docId}`)}
+          onDismiss={() => { askDismissed = true; }}
+        />
+      </div>
+    {/if}
+
     <!-- 선택 toolbar -->
     {#if selectionCount > 0}
       <div class="flex flex-wrap items-center gap-2 px-3 py-2 shrink-0 bg-accent/10 border-y border-accent/30">
@@ -587,47 +596,6 @@
     </div>
   </div>
 
-  <!-- ═══ 중앙: 리더 ═══ -->
-  <div class="{selectedDoc ? 'flex' : 'hidden lg:flex'} flex-1 min-w-0 flex-col min-h-0">
-    {#if selectedDoc}
-      <!-- 리더 상단 바: (모바일) 뒤로 / (lg) 인스펙터 토글 -->
-      <div class="flex items-center gap-2 px-3 py-1.5 shrink-0 border-b border-default bg-sidebar">
-        <button type="button" onclick={() => { selectedDoc = null; if (ui.isDrawerOpen('meta')) ui.closeDrawer(); }}
-          class="lg:hidden flex items-center gap-1 text-xs text-accent-hover font-medium" aria-label="목록으로">
-          <ChevronLeft size={15} /> 문서
-        </button>
-        <div class="flex-1"></div>
-        <button type="button" onclick={toggleInfoPanel} aria-pressed={isPanelActive} title="문서 정보"
-          class="p-1.5 rounded-lg border transition-colors {isPanelActive ? 'border-accent text-accent bg-accent/10' : 'border-default text-dim hover:text-accent hover:border-accent'}">
-          <Info size={16} />
-        </button>
-      </div>
-      <div class="flex-1 min-h-0">
-        <DocumentViewer doc={selectedDoc} />
-      </div>
-    {:else if showAskCard}
-      <div class="p-4 lg:p-6 overflow-y-auto">
-        <AskAnswerCard
-          data={askData}
-          loading={askLoading}
-          error={askError}
-          onCitationClick={(docId) => goto(`/documents/${docId}`)}
-          onDismiss={() => { askDismissed = true; }}
-        />
-      </div>
-    {:else}
-      <div class="hidden lg:flex flex-1 items-center justify-center text-dim text-sm">
-        왼쪽에서 문서를 선택하세요
-      </div>
-    {/if}
-  </div>
-
-  <!-- ═══ 우: 인스펙터 (xl+ inline) ═══ -->
-  {#if selectedDoc && inspectorOpen}
-    <aside class="hidden xl:flex flex-col w-[300px] shrink-0 border-l border-default bg-sidebar overflow-y-auto" aria-label="문서 정보">
-      {@render inspector(selectedDoc)}
-    </aside>
-  {/if}
 </div>
 
 <!-- < xl 폴백: Drawer (정보 하단/측면 시트) -->

frontend/src/routes/documents/[id]/+page.svelte

@@ -1,19 +1,17 @@
 <script>
-  // Phase E.2 — detail 페이지 inline 편집.
-  // 기존 read-only 메타 패널(L138–201)을 editors/* 스택으로 교체.
-  // + E.3 관련 문서 stub, + 헤더 affordance row.
+  // 문서 상세 /documents/[id] — 확정 시안(d3-deepened) 스타일을 그대로 포팅, 데이터만 바인딩.
+  // 데스크탑: 상단 헤더 띠 + [좌 절 트리(색바+연결선)][중 절 집중 뷰][우 슬림 레일]. 절 없으면 fallback.
+  // 모바일: 헤더 + 나란한 토글 pill(절구조|인사이트) + 본문 절 카드 연속(+탭 이동). 편집/필기/네비 보존.
   import { onMount } from 'svelte';
   import { page } from '$app/stores';
   import { goto } from '$app/navigation';
   import { api, getAccessToken } from '$lib/api';
   import { isMdSuccess } from '$lib/utils/mdStatus';
-  import { resolveAnchorMap } from '$lib/utils/resolveAnchorMap';
   import { addToast } from '$lib/stores/toast';
   import { marked } from 'marked';
   import DOMPurify from 'dompurify';
-  import { ExternalLink, Download, Link2, FileText, PenLine, X, ChevronLeft, ChevronRight, Check } from 'lucide-svelte';
+  import { ChevronRight, FileText } from 'lucide-svelte';
   import Button from '$lib/components/ui/Button.svelte';
-  import Card from '$lib/components/ui/Card.svelte';
   import EmptyState from '$lib/components/ui/EmptyState.svelte';
   import Skeleton from '$lib/components/ui/Skeleton.svelte';
   import HandwriteCanvas from '$lib/components/HandwriteCanvas.svelte';
@@ -23,96 +21,57 @@
   import EditUrlEditor from '$lib/components/editors/EditUrlEditor.svelte';
   import TagsEditor from '$lib/components/editors/TagsEditor.svelte';
   import AIClassificationEditor from '$lib/components/editors/AIClassificationEditor.svelte';
-  import FileInfoView from '$lib/components/editors/FileInfoView.svelte';
-  import ProcessingStatusView from '$lib/components/editors/ProcessingStatusView.svelte';
   import LibraryPathEditor from '$lib/components/editors/LibraryPathEditor.svelte';
   import DocumentDangerZone from '$lib/components/editors/DocumentDangerZone.svelte';
-  import AnalysisPanel from '$lib/components/AnalysisPanel.svelte';
-  import ReadCounter from '$lib/components/ReadCounter.svelte';
-  import SectionOutline from '$lib/components/SectionOutline.svelte';
+  import { cleanHeading, pathSegments, sectionTypeLabel, collapseWindows } from '$lib/utils/headingPath';
+  import { domainLabel } from '$lib/utils/domainSlug';
 
   marked.use({ mangle: false, headerIds: false });
   function renderMd(text) {
-    return DOMPurify.sanitize(marked(text), {
-      USE_PROFILES: { html: true },
-      FORBID_TAGS: ['style', 'script'],
-      FORBID_ATTR: ['onerror', 'onclick'],
-      ALLOW_UNKNOWN_PROTOCOLS: false,
+    return DOMPurify.sanitize(marked(text || ''), {
+      USE_PROFILES: { html: true }, FORBID_TAGS: ['style', 'script'], FORBID_ATTR: ['onerror', 'onclick'], ALLOW_UNKNOWN_PROTOCOLS: false,
     });
   }
 
   let doc = $state(null);
   let loading = $state(true);
-  let error = $state(null); // 'not_found' | 'network' | null
-  let rawMarkdown = $state(''); // fallback: extracted_text 없을 때 원본 .md
-
+  let error = $state(null);
+  let rawMarkdown = $state('');
   let docId = $derived($page.params.id);
 
-  // 손글씨 노트 (자료별 1:1) — "필기" 토글 시 사이드 캔버스 띄움.
+  // 필기
   let noteOpen = $state(false);
-  let noteStrokes = $state(null); // { version, strokes }
+  let noteStrokes = $state(null);
   let noteLoaded = $state(false);
   async function ensureNoteLoaded() {
     if (noteLoaded) return;
-    try {
-      const r = await api(`/documents/${docId}/note`);
-      noteStrokes = r.strokes_json && r.strokes_json.strokes ? r.strokes_json : { version: 1, strokes: [] };
-    } catch {
-      noteStrokes = { version: 1, strokes: [] };
-    }
+    try { const r = await api(`/documents/${docId}/note`); noteStrokes = r.strokes_json && r.strokes_json.strokes ? r.strokes_json : { version: 1, strokes: [] }; }
+    catch { noteStrokes = { version: 1, strokes: [] }; }
     noteLoaded = true;
   }
-  async function saveNote(strokesJson) {
-    try {
-      await api(`/documents/${docId}/note`, {
-        method: 'PUT',
-        body: JSON.stringify({ strokes_json: strokesJson }),
-      });
-    } catch (err) {
-      console.warn('필기 저장 실패', err);
-    }
-  }
-  async function toggleNote() {
-    if (!noteOpen) await ensureNoteLoaded();
-    noteOpen = !noteOpen;
-  }
+  async function saveNote(s) { try { await api(`/documents/${docId}/note`, { method: 'PUT', body: JSON.stringify({ strokes_json: s }) }); } catch (e) { console.warn(e); } }
+  async function toggleNote() { if (!noteOpen) await ensureNoteLoaded(); noteOpen = !noteOpen; }
 
-  // 인접 자료 (같은 library_path 내 이전/다음) — 학습 흐름 네비게이션
+  // 인접 자료
   let neighbors = $state({ prev: null, next: null });
-  async function loadNeighbors() {
-    try {
-      neighbors = await api(`/documents/${docId}/library-neighbors`);
-    } catch {
-      neighbors = { prev: null, next: null };
-    }
+  async function loadNeighbors() { try { neighbors = await api(`/documents/${docId}/library-neighbors`); } catch { neighbors = { prev: null, next: null }; } }
+  async function readAndGoNext() {
+    try { await api(`/documents/${docId}/read`, { method: 'POST' }); addToast('success', '1회독 완료'); }
+    catch (err) { addToast('error', err?.detail || '회독 기록 실패'); return; }
+    if (neighbors.next) goto(`/documents/${neighbors.next.id}`);
   }
 
-  // 절(hier section) 목차 — 본문 로드와 독립, 실패(404 포함) 무해.
-  // reqId guard: 문서 전환 race 시 stale 결과가 새 문서에 붙지 않게.
+  // 절 목차
   let sections = $state([]);
   let hasSections = $derived(sections.length > 0);
+  // 과대 절은 builder 가 window 조각(같은 제목·is_leaf)으로 분해하고 부모를 heading 만 남긴 split-parent 로
+  // 강등한다(예: 5180 = 27개 논리 절 → 562 window). raw sections 를 그대로 그리면 동일 제목 수백 행으로
+  // 파편화되므로, collapseWindows 로 논리 절 1개(대표=split-parent, bodyText=window 본문 합본)로 합친다.
+  let outline = $derived(collapseWindows(sections));
   async function loadSections() {
     const reqId = docId;
-    try {
-      const r = await api(`/documents/${reqId}/sections`);
-      if (reqId === docId) sections = r?.sections ?? [];
-    } catch {
-      if (reqId === docId) sections = []; // Phase 1 미배포 시 404 → 목차 숨김(graceful)
-    }
-  }
-
-  // "1회독 완료 + 다음 자료로" 한 번에
-  async function readAndGoNext() {
-    try {
-      await api(`/documents/${docId}/read`, { method: 'POST' });
-      addToast('success', '1회독 완료');
-    } catch (err) {
-      addToast('error', err?.detail || '회독 기록 실패');
-      return;
-    }
-    if (neighbors.next) {
-      goto(`/documents/${neighbors.next.id}`);
-    }
+    try { const r = await api(`/documents/${reqId}/sections`); if (reqId === docId) sections = r?.sections ?? []; }
+    catch { if (reqId === docId) sections = []; }
   }
 
   onMount(async () => {
@@ -120,87 +79,26 @@
       doc = await api(`/documents/${docId}`);
       const vt = doc.source_channel === 'news' ? 'article' : getViewerType(doc.file_format);
       if ((vt === 'markdown' || vt === 'hwp-markdown') && !doc.extracted_text) {
-        try {
-          const resp = await fetch(`/api/documents/${docId}/file?token=${getAccessToken()}`);
-          if (resp.ok) rawMarkdown = await resp.text();
-        } catch (e) {
-          rawMarkdown = '';
-        }
+        try { const resp = await fetch(`/api/documents/${docId}/file?token=${getAccessToken()}`); if (resp.ok) rawMarkdown = await resp.text(); } catch { rawMarkdown = ''; }
       }
-    } catch (err) {
-      error = err?.status === 404 ? 'not_found' : 'network';
-    } finally {
-      loading = false;
-    }
-    // 자료실 자료면 인접 자료 미리 fetch (학습 흐름 네비)
+    } catch (err) { error = err?.status === 404 ? 'not_found' : 'network'; }
+    finally { loading = false; }
     if (doc && doc.category === 'library') loadNeighbors();
     if (doc) loadSections();
   });
 
-  let viewerType = $derived(
-    doc ? (doc.source_channel === 'news' ? 'article' : getViewerType(doc.file_format)) : 'none'
-  );
+  let viewerType = $derived(doc ? (doc.source_channel === 'news' ? 'article' : getViewerType(doc.file_format)) : 'none');
+  let canShowMarkdown = $derived(!!(isMdSuccess(doc?.md_status) && doc?.md_content?.trim()));
+  // 절 본문은 청크 text(절별 원문)에서 오므로 md_content 성공/존재와 무관.
+  // hasSections 만으로 절뷰 사용 → partial / 대형 split(md_content 5만 자 절단) 문서도 절뷰 표시.
+  let useSectionView = $derived(hasSections);
 
-  // PDF 분기 전용: marker_worker 가 만든 canonical markdown 이 있으면 기본으로 그것을 보여줌.
-  // Phase 1B 산출물의 95% 가 PDF 라 1D pilot 평가가 실사용 화면 기반이 되도록 markdown-first.
-  // 사용자가 "PDF 원본" 토글하면 iframe. lastDocId 로 문서 전환만 감지해서 사용자 토글이
-  // reactive cycle 에 덮이지 않도록 보호.
-  let pdfViewMode = $state('markdown'); // 'markdown' | 'pdf'
+  let pdfViewMode = $state('markdown');
   let lastDocId = $state(null);
-  let canShowMarkdown = $derived(
-    !!(isMdSuccess(doc?.md_status) && doc?.md_content?.trim())
-  );
-
   $effect(() => {
     if (!doc) return;
-    if (doc.id !== lastDocId) {
-      lastDocId = doc.id;
-      pdfViewMode = canShowMarkdown ? 'markdown' : 'pdf';
-    }
-    // 같은 문서 안에서 markdown 이 사라지면 (success → failed 재처리 등) PDF 로 보호.
-    if (!canShowMarkdown && pdfViewMode === 'markdown') {
-      pdfViewMode = 'pdf';
-    }
-  });
-
-  // ── 개요 점프 (경로 B: BE char_start primary + string-match 폴백) ──
-  // 이 사이트는 항상 md_content basis(canShowMarkdown && doc.md_content) → trustBE=true.
-  // BE char_start 가 있으면 채택, 비면(non-PASS/미백필) resolveAnchorMap 내부에서 buildAnchorMap 로 폴백.
-  let anchorMap = $derived(
-    hasSections && canShowMarkdown && doc?.md_content
-      ? resolveAnchorMap(doc.md_content, sections, { trustBE: true }).anchors
-      : {}
-  );
-  let activeKey = $state(null);
-  function jumpToSection(chunkId) {
-    const el = document.getElementById(`sec-${chunkId}`);
-    if (el) el.scrollIntoView({ behavior: 'smooth', block: 'start' });
-  }
-  // scroll-spy: 화면 상단(120px)을 지난 마지막 .md-anchor = 현재 절. [id] 는 window 스크롤.
-  $effect(() => {
-    void anchorMap; // 문서/섹션 변화 시 재바인딩
-    if (typeof window === 'undefined') return;
-    let raf = 0;
-    const onScroll = () => {
-      if (raf) return;
-      raf = requestAnimationFrame(() => {
-        raf = 0;
-        let cur = null;
-        document.querySelectorAll('.md-anchor').forEach((a) => {
-          if (a.getBoundingClientRect().top <= 120) cur = a;
-        });
-        if (cur) {
-          const m = cur.id.match(/^sec-(\d+)$/);
-          if (m) activeKey = Number(m[1]);
-        }
-      });
-    };
-    window.addEventListener('scroll', onScroll, { passive: true });
-    onScroll();
-    return () => {
-      window.removeEventListener('scroll', onScroll);
-      if (raf) cancelAnimationFrame(raf);
-    };
+    if (doc.id !== lastDocId) { lastDocId = doc.id; pdfViewMode = canShowMarkdown ? 'markdown' : 'pdf'; }
+    if (!canShowMarkdown && pdfViewMode === 'markdown') pdfViewMode = 'pdf';
   });
 
   function getViewerType(format) {
@@ -212,353 +110,373 @@
     return 'unsupported';
   }
 
-  // E.2 affordance row 핸들러
+  // 절 집중/모바일 상태
+  let selectedSectionId = $state(null);
+  let mTree = $state(false);
+  let mIns = $state(false);
+  let manageOpen = $state(false);
+  $effect(() => { if (outline.length && !outline.some((it) => it.section.chunk_id === selectedSectionId)) selectedSectionId = outline[0].section.chunk_id; });
+  let selectedItem = $derived(outline.find((it) => it.section.chunk_id === selectedSectionId) ?? outline[0] ?? null);
+  let selectedSection = $derived(selectedItem?.section ?? null);
+  let selIdx = $derived(outline.findIndex((it) => it.section.chunk_id === selectedItem?.section?.chunk_id));
+  // 절 본문 = 청크 원문(it.bodyText, window 조각 합본) 직접 렌더. 과거 char_start 로 md_content 를
+  // 슬라이스했으나, 대형 split 문서는 md_content 가 앞 5만 자만 보존되고 char_start 도 NULL 이라 본문이
+  // 비었다. 청크 text 는 절 전체를 담으므로(절 보유 문서 344개, 본문 합 평균 68KB·max 1.6MB) 그대로 렌더.
+  function bodyHtml(it) { return it?.bodyText ? renderMd(it.bodyText) : ''; }
+  let selectedBodyHtml = $derived(bodyHtml(selectedItem));
+  // 모바일 연속 카드: 본문은 '본문 보기' 펼칠 때만 파싱(논리 절 수백 개 × marked 즉시 파싱 회피).
+  let mBodyOpen = $state({});
+
+  // 절 유형 색 (시안: 정의 청 / 절차 올리브 / 요건 황)
+  const TYPE_META = {
+    definition: { label: '정의', en: 'definition', color: '#2f7d8f' },
+    procedure: { label: '절차', en: 'procedure', color: '#7a8b3f' },
+    requirement: { label: '요건', en: 'requirement', color: '#b5840a' },
+  };
+  function typeMeta(t) { return TYPE_META[t] ?? { label: sectionTypeLabel(t) || '', en: t || '', color: '#9aa090' }; }
+  function isLowConf(c) { return c != null && c < 0.5; }
+  function isMidLow(c) { return c != null && c < 0.6; }
+  function confColor(c) { return c == null ? '#9aa090' : c < 0.6 ? '#b5840a' : '#1f9d6b'; }
+  function secTitle(s) { return cleanHeading(s.section_title) || pathSegments(s.heading_path).at(-1) || '(제목 없음)'; }
+  function secDepth(s) { return Math.max(0, (s.level ?? 1) - 1); }
+  function confPct(c) { return c == null ? 0 : Math.round(c * 100); }
+
+  // 도메인 색 (시안 도메인 팔레트)
+  const DOMAIN_COLOR = { Industrial_Safety: '#b5840a', Engineering: '#2f7d8f', Programming: '#3d7256', General: '#7a8b3f', Reference: '#8a6a3f', Philosophy: '#7a6a9b' };
+  function domainColor(d) { return DOMAIN_COLOR[(d || '').split('/')[0]] ?? '#697061'; }
+  function fmtColor(f) { return f === 'pdf' ? '#c0564a' : f === 'md' ? '#5a8f7a' : ['m4a', 'mp3', 'wav'].includes(f) ? '#8a6aa5' : f === 'html' ? '#c2911f' : '#697061'; }
+
+  let quality = $derived(doc?.md_extraction_quality?.metrics ?? doc?.md_extraction_quality ?? null);
+
   function copyLink() {
-    const url = `${window.location.origin}/documents/${docId}`;
-    navigator.clipboard
-      .writeText(url)
-      .then(() => addToast('success', '링크 복사됨'))
-      .catch(() => addToast('error', '복사 실패'));
-  }
-
-  function downloadOriginal() {
-    window.open(`/api/documents/${docId}/file?token=${getAccessToken()}&download=true`);
-  }
-
-  function downloadPdf() {
-    window.open(`/api/documents/${docId}/preview?token=${getAccessToken()}&download=true`);
-  }
-
-  function handleDocDelete() {
-    addToast('success', '문서가 삭제되어 목록으로 이동합니다.');
-    goto('/documents');
+    navigator.clipboard.writeText(`${window.location.origin}/documents/${docId}`).then(() => addToast('success', '링크 복사됨')).catch(() => addToast('error', '복사 실패'));
   }
+  function downloadOriginal() { window.open(`/api/documents/${docId}/file?token=${getAccessToken()}&download=true`); }
+  function handleDocDelete() { addToast('success', '문서가 삭제되어 목록으로 이동합니다.'); goto('/documents'); }
 </script>
 
-<div class="p-4 lg:p-6">
+<!-- ════ 좌 트리 (시안: 색바 + 연결선 + 활성 + 저신뢰 경고) ════ -->
+{#snippet treeNav(jumpMode)}
+  <div class="d3tree" style="font-size:14px;">
+    <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:9px;">
+      <div style="font-size:12px;font-weight:700;color:#697061;letter-spacing:.4px;">절 구조</div>
+      <span style="font-size:10.5px;color:#9aa090;font-variant-numeric:tabular-nums;">{outline.length}절</span>
+    </div>
+    <div style="display:flex;flex-wrap:wrap;gap:6px 8px;margin-bottom:11px;padding-bottom:10px;border-bottom:1px solid #dde3d6;">
+      <span style="display:inline-flex;align-items:center;gap:4px;font-size:10px;color:#697061;"><span style="width:8px;height:8px;border-radius:2px;background:#2f7d8f;"></span>정의</span>
+      <span style="display:inline-flex;align-items:center;gap:4px;font-size:10px;color:#697061;"><span style="width:8px;height:8px;border-radius:2px;background:#7a8b3f;"></span>절차</span>
+      <span style="display:inline-flex;align-items:center;gap:4px;font-size:10px;color:#697061;"><span style="width:8px;height:8px;border-radius:2px;background:#b5840a;"></span>요건</span>
+    </div>
+    {#each outline as it (it.section.chunk_id)}
+      {@const s = it.section}
+      {@const tm = typeMeta(it.sectionType)}
+      {@const active = !jumpMode && s.chunk_id === selectedSection?.chunk_id}
+      {@const child = secDepth(s) > 0}
+      {@const low = isMidLow(it.confidence)}
+      <svelte:element this={jumpMode ? 'a' : 'div'} href={jumpMode ? `#m-sec-${s.chunk_id}` : undefined} role="button" tabindex="0"
+        onclick={() => !jumpMode && (selectedSectionId = s.chunk_id)}
+        onkeydown={(e) => { if (!jumpMode && (e.key === 'Enter' || e.key === ' ')) { e.preventDefault(); selectedSectionId = s.chunk_id; } }}
+        class="d3node {child ? 'd3child' : ''} {active ? 'd3active' : ''}"
+        style="display:block;border:1px solid {active ? '#4f8a6b' : low ? '#e7d49a' : 'transparent'};border-radius:9px;padding:{child ? '6px 8px' : '7px 8px'};margin-bottom:2px;{low ? 'background:#fbf6e6;' : ''}text-decoration:none;cursor:pointer;">
+        <div style="display:flex;align-items:center;gap:7px;">
+          <span style="width:3px;height:{child ? '13px' : '16px'};border-radius:2px;background:{tm.color};flex-shrink:0;"></span>
+          <span class="d3title" style="font-size:{child ? '11.5px' : '12.5px'};flex:1;min-width:0;{child ? 'color:#697061;' : ''}{active ? 'color:#3d7256;font-weight:600;' : ''}overflow:hidden;text-overflow:ellipsis;white-space:nowrap;">{secTitle(s)}</span>
+          {#if low}
+            <span class="d3warn" title="저신뢰 절" style="display:inline-flex;width:14px;height:14px;border-radius:50%;background:#b5840a;color:#fff;align-items:center;justify-content:center;font-size:9px;font-weight:700;flex-shrink:0;">!</span>
+          {:else if !child}
+            <span title="신뢰도 {it.confidence != null ? it.confidence.toFixed(2) : '—'}" style="width:7px;height:7px;border-radius:50%;background:{confColor(it.confidence)};flex-shrink:0;"></span>
+          {/if}
+        </div>
+      </svelte:element>
+    {/each}
+    {#if quality}
+      <div style="margin-top:12px;padding-top:10px;border-top:1px solid #dde3d6;">
+        <div style="font-size:10.5px;font-weight:700;color:#697061;margin-bottom:7px;letter-spacing:.3px;">추출 품질</div>
+        <div style="display:grid;grid-template-columns:1fr 1fr;gap:5px;font-size:10.5px;color:#697061;font-variant-numeric:tabular-nums;">
+          {#if quality.headings != null}<span>headings <b style="color:#23291f;">{quality.headings}</b></span>{/if}
+          {#if quality.tables != null}<span>tables <b style="color:#23291f;">{quality.tables}</b></span>{/if}
+          {#if quality.images != null}<span>images <b style="color:#23291f;">{quality.images}</b></span>{/if}
+        </div>
+      </div>
+    {/if}
+  </div>
+{/snippet}
+
+<!-- ════ 절 집중 뷰 (데스크탑 중앙) ════ -->
+{#snippet focusView()}
+  {#if selectedSection}
+    {@const tm = typeMeta(selectedItem?.sectionType)}
+    {@const conf = selectedItem?.confidence ?? null}
+    {@const summaries = selectedItem?.summaries ?? []}
+    <div style="display:flex;align-items:center;gap:6px;font-size:12px;color:#9aa090;margin-bottom:12px;flex-wrap:wrap;">
+      <span class="truncate" style="max-width:200px;">{doc.title}</span>
+      {#each pathSegments(selectedSection.heading_path) as seg}<span style="color:#c8d6c0;">/</span><span style="color:#697061;font-weight:600;">{seg}</span>{/each}
+    </div>
+    <div style="display:flex;align-items:center;gap:9px;flex-wrap:wrap;margin-bottom:13px;">
+      <h2 style="margin:0;font-size:22px;font-weight:700;color:#23291f;line-height:1.3;flex:1;min-width:180px;">{secTitle(selectedSection)}</h2>
+      {#if tm.label}<span style="display:inline-flex;align-items:center;gap:5px;padding:4px 11px;border-radius:999px;background:{tm.color}1a;border:1px solid {tm.color}55;font-size:12px;color:{tm.color};font-weight:600;"><span style="width:8px;height:8px;border-radius:2px;background:{tm.color};"></span>{tm.label} {tm.en}</span>{/if}
+    </div>
+    {#if conf != null}
+      <div style="display:flex;align-items:center;gap:9px;margin-bottom:18px;">
+        <span style="font-size:11px;color:#697061;font-weight:600;flex-shrink:0;">신뢰도</span>
+        <div style="flex:1;max-width:300px;height:7px;border-radius:999px;background:#e3ebdf;overflow:hidden;"><div style="width:{confPct(conf)}%;height:100%;background:{confColor(conf)};border-radius:999px;"></div></div>
+        <span style="font-size:13px;font-weight:700;color:{confColor(conf)};font-variant-numeric:tabular-nums;flex-shrink:0;">{conf.toFixed(2)}</span>
+      </div>
+    {/if}
+    {#if isLowConf(conf)}
+      <div style="display:flex;align-items:flex-start;gap:8px;background:#faf3e2;border:1px solid #ecdca3;border-radius:10px;padding:10px 12px;margin-bottom:16px;font-size:12.5px;color:#8a6306;"><span style="flex-shrink:0;width:16px;height:16px;border-radius:50%;border:1.5px solid #b5840a;color:#b5840a;font-size:10px;font-weight:800;display:inline-flex;align-items:center;justify-content:center;margin-top:1px;">!</span><span>저신뢰 절 — 표·수식 추출이 불완전할 수 있습니다. 정확한 내용은 원본을 확인하세요.</span></div>
+    {/if}
+    {#if summaries.length}
+      <div style="background:#ecf0e8;border-left:3px solid #4f8a6b;border-radius:0 10px 10px 0;padding:14px 16px;margin-bottom:20px;">
+        <div style="font-size:10.5px;font-weight:700;color:#3d7256;letter-spacing:.6px;margin-bottom:6px;">절 요약{#if summaries.length > 1} · {summaries.length}개 부분{/if}</div>
+        {#if summaries.length === 1}
+          <div style="font-size:15.5px;line-height:1.6;color:#23291f;white-space:pre-line;">{summaries[0]}</div>
+        {:else}
+          <ul style="margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:8px;">
+            {#each summaries as sm, i}<li style="font-size:13.5px;line-height:1.55;color:#23291f;display:flex;gap:8px;"><span style="flex-shrink:0;color:#7a8b3f;font-weight:700;font-variant-numeric:tabular-nums;">{i + 1}</span><span style="white-space:pre-line;">{sm}</span></li>{/each}
+          </ul>
+        {/if}
+      </div>
+    {/if}
+    {#if selectedBodyHtml}
+      <div class="prose prose-base max-w-none text-text">{@html selectedBodyHtml}</div>
+    {:else}
+      <p style="color:#9aa090;font-size:14px;font-style:italic;">이 절의 본문은 추출되지 않았습니다. 헤더의 '원본'에서 확인하세요.</p>
+    {/if}
+    <div style="display:flex;justify-content:space-between;gap:10px;margin-top:20px;padding-top:14px;border-top:1px solid #dde3d6;">
+      {#if selIdx > 0}
+        {@const pv = outline[selIdx - 1].section}
+        <button type="button" onclick={() => (selectedSectionId = pv.chunk_id)} style="font-size:12px;color:#697061;border:1px solid #dde3d6;border-radius:9px;padding:8px 12px;background:#fff;cursor:pointer;">← {secTitle(pv)}</button>
+      {:else}<span></span>{/if}
+      {#if selIdx >= 0 && selIdx < outline.length - 1}
+        {@const nxIt = outline[selIdx + 1]}
+        {@const nx = nxIt.section}
+        <button type="button" onclick={() => (selectedSectionId = nx.chunk_id)} style="font-size:12px;color:{isMidLow(nxIt.confidence) ? '#8a6306' : '#697061'};border:1px solid {isMidLow(nxIt.confidence) ? '#e7d49a' : '#dde3d6'};border-radius:9px;padding:8px 12px;background:#fff;cursor:pointer;display:inline-flex;align-items:center;gap:6px;">{#if isMidLow(nxIt.confidence)}<span style="display:inline-flex;width:13px;height:13px;border-radius:50%;background:#b5840a;color:#fff;align-items:center;justify-content:center;font-size:8px;font-weight:700;">!</span>{/if}{secTitle(nx)} →</button>
+      {:else}<span></span>{/if}
+    </div>
+  {/if}
+{/snippet}
+
+<!-- ════ 우 슬림 레일 (시안 카드 스타일) ════ -->
+{#snippet rail()}
+  <div style="display:flex;flex-direction:column;gap:11px;font-size:14px;">
+    {#if doc.ai_tldr || doc.ai_summary}
+      <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:13px;">
+        <div style="font-size:10.5px;font-weight:700;color:#697061;letter-spacing:.4px;margin-bottom:7px;">TL;DR</div>
+        <div style="font-size:12px;line-height:1.5;color:#23291f;">{doc.ai_tldr || doc.ai_summary}</div>
+      </div>
+    {/if}
+    {#if doc.ai_bullets && doc.ai_bullets.length}
+      <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:13px;">
+        <div style="font-size:10.5px;font-weight:700;color:#697061;letter-spacing:.4px;margin-bottom:8px;">핵심점</div>
+        <ul style="margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:7px;">
+          {#each doc.ai_bullets as b}<li style="font-size:12px;line-height:1.4;display:flex;gap:6px;"><span style="color:#b5840a;font-weight:700;flex-shrink:0;">·</span><span style="flex:1;min-width:0;color:#23291f;">{b}</span></li>{/each}
+        </ul>
+      </div>
+    {/if}
+    {#if doc.ai_detail_summary}
+      <div style="background:#f4f7f1;border:1px solid #c8d6c0;border-radius:14px;padding:13px;">
+        <div style="display:flex;align-items:center;gap:6px;margin-bottom:7px;">
+          <span style="font-size:10.5px;font-weight:700;color:#3d7256;letter-spacing:.4px;">심층</span>
+          {#if doc.ai_analysis_tier === 'deep'}<span style="font-size:9px;color:#fff;background:#4f8a6b;border-radius:999px;padding:1px 7px;font-weight:600;">DEEP</span>{/if}
+        </div>
+        <div style="font-size:11.5px;line-height:1.5;color:#23291f;white-space:pre-line;">{doc.ai_detail_summary}</div>
+      </div>
+    {/if}
+    {#if doc.ai_inconsistencies && doc.ai_inconsistencies.length}
+      <div style="background:#fbf6e6;border:1px solid #e7d49a;border-radius:14px;padding:13px;">
+        <div style="font-size:10.5px;font-weight:700;color:#8a6306;letter-spacing:.4px;margin-bottom:7px;">불일치 {doc.ai_inconsistencies.length}</div>
+        <ul style="margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:5px;">{#each doc.ai_inconsistencies as inc}<li style="font-size:11.5px;line-height:1.45;color:#23291f;">· {typeof inc === 'string' ? inc : inc.desc || inc.kind}</li>{/each}</ul>
+      </div>
+    {/if}
+    {#if doc.ai_domain}
+      <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:13px;">
+        <div style="font-size:10.5px;font-weight:700;color:#697061;letter-spacing:.4px;margin-bottom:8px;">분류</div>
+        <div style="display:flex;flex-direction:column;gap:6px;font-size:11.5px;">
+          <div style="display:flex;justify-content:space-between;gap:8px;"><span style="color:#697061;">도메인</span><span style="display:inline-flex;align-items:center;gap:5px;color:#23291f;font-weight:600;text-align:right;"><span style="width:7px;height:7px;border-radius:50%;background:{domainColor(doc.ai_domain)};"></span>{domainLabel(doc.ai_domain)}</span></div>
+          {#if doc.ai_sub_group}<div style="display:flex;justify-content:space-between;gap:8px;"><span style="color:#697061;">하위</span><span style="color:#23291f;font-weight:600;">{doc.ai_sub_group}</span></div>{/if}
+          {#if doc.ai_analysis_tier}<div style="display:flex;justify-content:space-between;gap:8px;"><span style="color:#697061;">tier</span><span style="color:#3d7256;font-weight:600;">{doc.ai_analysis_tier}</span></div>{/if}
+          {#if doc.ai_confidence != null}<div style="display:flex;justify-content:space-between;gap:8px;"><span style="color:#697061;">신뢰도</span><span style="color:#1f9d6b;font-weight:700;font-variant-numeric:tabular-nums;">{doc.ai_confidence.toFixed(2)}</span></div>{/if}
+        </div>
+      </div>
+    {/if}
+    {#if doc.ai_tags && doc.ai_tags.length}
+      <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:13px;">
+        <div style="font-size:10.5px;font-weight:700;color:#697061;letter-spacing:.4px;margin-bottom:8px;">태그</div>
+        <div style="display:flex;flex-wrap:wrap;gap:5px;">{#each doc.ai_tags as t}<span style="font-size:11px;padding:3px 8px;border-radius:999px;background:#fff;border:1px solid #dde3d6;color:#697061;">{t}</span>{/each}</div>
+      </div>
+    {/if}
+    <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:13px;">
+      <div style="font-size:10.5px;font-weight:700;color:#697061;letter-spacing:.4px;margin-bottom:6px;">관련 문서</div>
+      <div style="font-size:11px;color:#9aa090;line-height:1.5;">벡터 유사도 기반 — 준비 중</div>
+    </div>
+  </div>
+{/snippet}
+
+<!-- ════ 절 카드 (모바일 연속 본문) ════ -->
+{#snippet sectionCard(it)}
+  {@const s = it.section}
+  {@const tm = typeMeta(it.sectionType)}
+  <div id="m-sec-{s.chunk_id}" style="scroll-margin-top:12px;background:#f4f7f1;border:1px solid {isLowConf(it.confidence) ? '#e7d49a' : '#dde3d6'};border-radius:14px;padding:14px 15px;">
+    <div style="display:flex;align-items:center;gap:7px;margin-bottom:7px;">
+      <h2 style="margin:0;font-size:16px;font-weight:700;color:#23291f;flex:1;min-width:0;line-height:1.3;">{secTitle(s)}</h2>
+      {#if tm.label}<span style="flex-shrink:0;font-size:10.5px;font-weight:650;padding:2px 8px;border-radius:999px;background:{tm.color}1a;color:{tm.color};white-space:nowrap;">{tm.label}</span>{/if}
+    </div>
+    {#if isLowConf(it.confidence)}
+      <div style="display:flex;align-items:flex-start;gap:7px;background:#faf3e2;border:1px solid #ecdca3;border-radius:9px;padding:8px 10px;margin-bottom:10px;font-size:12px;color:#8a6306;"><span style="flex-shrink:0;width:15px;height:15px;border-radius:50%;border:1.5px solid #b5840a;color:#b5840a;font-size:10px;font-weight:800;display:inline-flex;align-items:center;justify-content:center;margin-top:1px;">!</span><span>저신뢰 — 표·수식 추출 불완전, 원본 확인 권장</span></div>
+    {/if}
+    {#if it.summaries.length}
+      <div style="border-left:3px solid #4f8a6b;background:#ecf0e8;border-radius:0 8px 8px 0;padding:9px 12px;margin-bottom:12px;">
+        <div style="font-size:9.5px;font-weight:700;color:#3d7256;letter-spacing:.5px;margin-bottom:3px;">절 요약{#if it.summaries.length > 1} · {it.summaries.length}개 부분{/if}</div>
+        {#if it.summaries.length === 1}
+          <div style="font-size:13.5px;line-height:1.55;color:#23291f;white-space:pre-line;">{it.summaries[0]}</div>
+        {:else}
+          <ul style="margin:0;padding:0;list-style:none;display:flex;flex-direction:column;gap:6px;">{#each it.summaries as sm, i}<li style="font-size:12.5px;line-height:1.5;color:#23291f;display:flex;gap:6px;"><span style="flex-shrink:0;color:#7a8b3f;font-weight:700;font-variant-numeric:tabular-nums;">{i + 1}</span><span style="white-space:pre-line;">{sm}</span></li>{/each}</ul>
+        {/if}
+      </div>
+    {/if}
+    {#if it.bodyText}
+      <details class="m-secbody" ontoggle={(e) => { if (e.currentTarget.open) mBodyOpen[s.chunk_id] = true; }}>
+        <summary style="cursor:pointer;list-style:none;font-size:12px;color:#697061;padding:5px 0;user-select:none;display:flex;align-items:center;gap:5px;">본문 보기 <span class="m-chev" style="transition:transform .16s;color:#9aa090;">›</span></summary>
+        {#if mBodyOpen[s.chunk_id]}<div class="prose prose-sm max-w-none text-text" style="margin-top:6px;">{@html bodyHtml(it)}</div>{/if}
+      </details>
+    {/if}
+  </div>
+{/snippet}
+
+<div style="background:#e7ebe4;min-height:100%;" class="p-4 lg:p-6">
+ <div style="max-width:1360px;margin:0 auto;">
   <!-- breadcrumb -->
-  <div class="flex items-center gap-2 text-sm mb-4 text-dim">
-    <a href="/documents" class="hover:text-text">문서</a>
-    <span class="text-faint">/</span>
+  <div class="flex items-center gap-2 text-sm mb-3 text-dim">
+    <a href="/documents" class="hover:text-text">문서</a><span class="text-faint">/</span>
     <span class="truncate max-w-md text-text">{doc?.title || '로딩...'}</span>
   </div>
 
   {#if loading}
-    <div class="max-w-6xl mx-auto">
-      <Skeleton h="h-96" rounded="card" />
-    </div>
+    <Skeleton h="h-96" rounded="card" />
   {:else if error === 'not_found'}
-    <EmptyState
-      icon={FileText}
-      title="문서를 찾을 수 없습니다"
-      description="삭제되었거나 접근 권한이 없을 수 있습니다."
-    >
-      <Button variant="ghost" size="sm" href="/documents">목록으로 돌아가기</Button>
-    </EmptyState>
+    <EmptyState icon={FileText} title="문서를 찾을 수 없습니다" description="삭제되었거나 접근 권한이 없을 수 있습니다."><Button variant="ghost" size="sm" href="/documents">목록으로</Button></EmptyState>
   {:else if error === 'network'}
-    <EmptyState
-      icon={FileText}
-      title="문서를 불러올 수 없습니다"
-      description="네트워크 오류가 발생했습니다."
-    >
-      <Button variant="secondary" size="sm" onclick={() => location.reload()}>다시 시도</Button>
-    </EmptyState>
+    <EmptyState icon={FileText} title="문서를 불러올 수 없습니다" description="네트워크 오류"><Button variant="secondary" size="sm" onclick={() => location.reload()}>다시 시도</Button></EmptyState>
   {:else if doc}
-    <div class="mx-auto grid grid-cols-1 gap-6 {hasSections ? 'max-w-7xl xl:grid-cols-[18rem_minmax(0,1fr)_20rem]' : 'max-w-6xl lg:grid-cols-3'}">
-      {#if hasSections}
-        <!-- 좌측 절 목차 — xl+ sticky rail (그 아래 viewport 는 본문 상단 collapsible) -->
-        <aside class="hidden xl:block xl:sticky xl:top-6 xl:self-start xl:max-h-[calc(100vh-3rem)] xl:overflow-y-auto">
-          <Card>
-            <SectionOutline {sections} onJump={jumpToSection} {activeKey} />
-          </Card>
-        </aside>
-      {/if}
-
-      <!-- 본문 (좌측 목차 없을 때 lg 2/3) -->
-      <div class="{hasSections ? '' : 'lg:col-span-2'} space-y-4">
-        {#if hasSections}
-          <!-- xl 미만: 절 목차 접이식 -->
-          <details class="xl:hidden">
-            <summary class="cursor-pointer text-sm text-dim px-1 py-2 select-none">절 목차 ({sections.length})</summary>
-            <Card class="mt-2"><SectionOutline {sections} onJump={jumpToSection} {activeKey} /></Card>
-          </details>
-        {/if}
-        <!-- Affordance row -->
-        <div class="flex flex-wrap items-center gap-2">
-          {#if doc.edit_url}
-            <Button
-              variant="secondary"
-              size="sm"
-              icon={ExternalLink}
-              href={doc.edit_url}
-              target="_blank"
-            >
-              Synology 편집
-            </Button>
-          {/if}
-          <Button variant="secondary" size="sm" icon={Download} onclick={downloadOriginal}>
-            원본 다운로드
-          </Button>
-          {#if doc.preview_status === 'ready'}
-            <Button variant="secondary" size="sm" icon={FileText} onclick={downloadPdf}>
-              PDF 다운로드
-            </Button>
-          {/if}
-          <Button variant="secondary" size="sm" icon={Link2} onclick={copyLink}>
-            링크 복사
-          </Button>
-          {#if doc.category === 'library'}
-            <Button
-              variant={noteOpen ? 'primary' : 'secondary'}
-              size="sm"
-              icon={noteOpen ? X : PenLine}
-              onclick={toggleNote}
-            >
-              {noteOpen ? '필기 닫기' : '필기'}
-            </Button>
-          {/if}
+    <!-- ════ 상단 띠: 문서 헤더 (시안) ════ -->
+    <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:16px 18px;margin-bottom:14px;">
+      <div style="display:flex;align-items:flex-start;gap:13px;flex-wrap:wrap;">
+        <div style="width:40px;height:40px;border-radius:10px;background:{fmtColor(doc.file_format)};color:#fff;display:flex;align-items:center;justify-content:center;font-weight:700;font-size:10.5px;letter-spacing:.5px;flex-shrink:0;text-transform:uppercase;">{doc.file_format}</div>
+        <div style="flex:1;min-width:0;">
+          <div style="font-size:17px;font-weight:700;line-height:1.35;color:#23291f;">{doc.title}</div>
+          <div style="display:flex;flex-wrap:wrap;gap:6px;margin-top:8px;align-items:center;">
+            {#if doc.ai_domain}<span style="display:inline-flex;align-items:center;gap:5px;padding:3px 9px;border-radius:999px;background:#fff;border:1px solid #dde3d6;font-size:11.5px;color:#23291f;"><span style="width:7px;height:7px;border-radius:50%;background:{domainColor(doc.ai_domain)};"></span>{domainLabel(doc.ai_domain)}</span>{/if}
+            {#if doc.ai_sub_group}<span style="padding:3px 9px;border-radius:999px;background:#fff;border:1px solid #dde3d6;font-size:11.5px;color:#697061;">{doc.ai_sub_group}</span>{/if}
+            {#if doc.ai_analysis_tier === 'deep'}<span style="padding:3px 9px;border-radius:999px;background:#4f8a6b;color:#fff;font-size:11.5px;font-weight:600;letter-spacing:.3px;">tier DEEP</span>{/if}
+            {#if doc.ai_confidence != null}<span style="padding:3px 9px;border-radius:999px;background:#e3ebdf;border:1px solid #c8d6c0;font-size:11.5px;color:#3d7256;font-variant-numeric:tabular-nums;">신뢰도 {doc.ai_confidence.toFixed(2)}</span>{/if}
+            {#if canShowMarkdown}<span style="padding:3px 9px;border-radius:999px;background:#eafaf2;border:1px solid #b8e3cc;font-size:11.5px;color:#1f9d6b;">PDF→MD success</span>{/if}
+          </div>
         </div>
+        <div style="display:flex;gap:6px;flex-shrink:0;flex-wrap:wrap;">
+          {#if doc.edit_url}<button type="button" onclick={() => window.open(doc.edit_url, '_blank')} style="font-size:11.5px;color:#697061;border:1px solid #dde3d6;border-radius:8px;padding:5px 9px;background:#fff;cursor:pointer;">Synology</button>{/if}
+          <button type="button" onclick={downloadOriginal} style="font-size:11.5px;color:#697061;border:1px solid #dde3d6;border-radius:8px;padding:5px 9px;background:#fff;cursor:pointer;">원본</button>
+          <button type="button" onclick={copyLink} style="font-size:11.5px;color:#697061;border:1px solid #dde3d6;border-radius:8px;padding:5px 9px;background:#fff;cursor:pointer;">링크</button>
+          {#if doc.category === 'library'}<button type="button" onclick={toggleNote} style="font-size:11.5px;color:{noteOpen ? '#fff' : '#697061'};border:1px solid {noteOpen ? '#4f8a6b' : '#dde3d6'};border-radius:8px;padding:5px 9px;background:{noteOpen ? '#4f8a6b' : '#fff'};cursor:pointer;">{noteOpen ? '필기 닫기' : '필기'}</button>{/if}
+          <button type="button" onclick={() => (manageOpen = !manageOpen)} style="font-size:11.5px;color:#697061;border:1px solid #dde3d6;border-radius:8px;padding:5px 9px;background:#fff;cursor:pointer;">관리</button>
+        </div>
+      </div>
+    </div>
 
-        <!-- 뷰어 — 모바일 가독성: 본문 폰트 키우고 line-height 늘림 -->
-        <Card class="min-h-[500px]">
+    {#if useSectionView}
+      <!-- 데스크탑(xl+): 3영역 -->
+      <div class="hidden xl:grid" style="grid-template-columns:252px minmax(0,1fr) 336px;gap:13px;align-items:start;">
+        <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:13px 11px;position:sticky;top:14px;max-height:calc(100vh-2rem);overflow-y:auto;">{@render treeNav(false)}</div>
+        <div style="min-width:0;"><div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:20px 22px;">{@render focusView()}</div></div>
+        <div style="position:sticky;top:14px;">{@render rail()}</div>
+      </div>
+
+      <!-- 모바일(<xl): 나란한 토글 pill + 패널 + 본문 연속 -->
+      <div class="xl:hidden">
+        <div style="display:flex;gap:8px;margin-bottom:10px;position:sticky;top:0;z-index:5;background:#e7ebe4;padding:6px 0;">
+          <button type="button" onclick={() => (mTree = !mTree)} style="flex:1;display:flex;align-items:center;justify-content:space-between;gap:6px;border-radius:10px;padding:9px 12px;font-size:12.5px;font-weight:600;cursor:pointer;background:{mTree ? '#e3ebdf' : '#f4f7f1'};border:1px solid {mTree ? '#4f8a6b' : '#dde3d6'};color:{mTree ? '#23291f' : '#697061'};">절 구조 <span style="font-size:10px;color:#9aa090;font-weight:500;">{outline.length}절</span><span style="transition:transform .16s;transform:rotate({mTree ? 90 : 0}deg);color:#9aa090;font-weight:700;">›</span></button>
+          <button type="button" onclick={() => (mIns = !mIns)} style="flex:1;display:flex;align-items:center;justify-content:space-between;gap:6px;border-radius:10px;padding:9px 12px;font-size:12.5px;font-weight:600;cursor:pointer;background:{mIns ? '#e3ebdf' : '#f4f7f1'};border:1px solid {mIns ? '#4f8a6b' : '#dde3d6'};color:{mIns ? '#23291f' : '#697061'};">인사이트<span style="transition:transform .16s;transform:rotate({mIns ? 90 : 0}deg);color:#9aa090;font-weight:700;">›</span></button>
+        </div>
+        {#if mTree}<div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:12px;padding:6px;margin-bottom:10px;">{@render treeNav(true)}</div>{/if}
+        {#if mIns}<div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:12px;padding:13px 14px;margin-bottom:10px;">{@render rail()}</div>{/if}
+        <div style="display:flex;flex-direction:column;gap:10px;">{#each outline as it (it.section.chunk_id)}{@render sectionCard(it)}{/each}</div>
+      </div>
+    {:else}
+      <!-- 절 없음 fallback: 절이 없어도 인사이트는 항상 보이게 (모바일=인사이트 상단 / 데스크탑=우측 레일) -->
+      {#snippet fbViewer()}
+        <div style="min-width:0;background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:18px 20px;min-height:360px;">
+          {#if !hasSections && canShowMarkdown}<p style="font-size:11px;color:#9aa090;margin-bottom:12px;">이 문서는 절 분석이 없어 전체 본문으로 표시합니다. 위/옆 인사이트는 그대로 제공됩니다.</p>{/if}
           {#if viewerType === 'markdown' || viewerType === 'hwp-markdown'}
-            <MarkdownDoc
-              documentId={doc.id}
-              mdContent={doc.md_content}
-              mdFrontmatter={doc.md_frontmatter}
-              mdStatus={doc.md_status}
-              mdExtractionError={doc.md_extraction_error}
-              mdExtractionQuality={doc.md_extraction_quality}
-              anchorMap={anchorMap}
-              extractedText={doc.extracted_text || rawMarkdown}
-              class="prose prose-invert prose-base lg:prose-sm max-w-none"
-            />
+            <MarkdownDoc documentId={doc.id} mdContent={doc.md_content} mdFrontmatter={doc.md_frontmatter} mdStatus={doc.md_status} mdExtractionError={doc.md_extraction_error} mdExtractionQuality={doc.md_extraction_quality} extractedText={doc.extracted_text || rawMarkdown} class="prose prose-base max-w-none" />
           {:else if viewerType === 'pdf'}
             <div class="mb-2 flex items-center gap-2">
-              <MarkdownStatusBadge
-                mdStatus={doc.md_status}
-                mdExtractionError={doc.md_extraction_error}
-                mdExtractionQuality={doc.md_extraction_quality}
-              />
-              {#if canShowMarkdown}
-                <Button
-                  size="sm"
-                  variant={pdfViewMode === 'markdown' ? 'primary' : 'secondary'}
-                  onclick={() => (pdfViewMode = 'markdown')}
-                >
-                  Markdown
-                </Button>
-                <Button
-                  size="sm"
-                  variant={pdfViewMode === 'pdf' ? 'primary' : 'secondary'}
-                  onclick={() => (pdfViewMode = 'pdf')}
-                >
-                  PDF 원본
-                </Button>
-              {/if}
+              <MarkdownStatusBadge mdStatus={doc.md_status} mdExtractionError={doc.md_extraction_error} mdExtractionQuality={doc.md_extraction_quality} />
+              {#if canShowMarkdown}<Button size="sm" variant={pdfViewMode === 'markdown' ? 'primary' : 'secondary'} onclick={() => (pdfViewMode = 'markdown')}>Markdown</Button><Button size="sm" variant={pdfViewMode === 'pdf' ? 'primary' : 'secondary'} onclick={() => (pdfViewMode = 'pdf')}>PDF 원본</Button>{/if}
             </div>
             {#if pdfViewMode === 'markdown' && canShowMarkdown}
-              <MarkdownDoc
-                documentId={doc.id}
-                mdContent={doc.md_content}
-                mdFrontmatter={doc.md_frontmatter}
-                mdStatus={doc.md_status}
-                mdExtractionError={doc.md_extraction_error}
-                mdExtractionQuality={doc.md_extraction_quality}
-                extractedText={doc.extracted_text}
-                class="prose prose-invert prose-base lg:prose-sm max-w-none"
-              />
-            {:else}
-              <iframe
-                src="/api/documents/{doc.id}/file?token={getAccessToken()}"
-                class="w-full h-[80vh] rounded"
-                title={doc.title}
-              ></iframe>
-            {/if}
+              <MarkdownDoc documentId={doc.id} mdContent={doc.md_content} mdFrontmatter={doc.md_frontmatter} mdStatus={doc.md_status} mdExtractionError={doc.md_extraction_error} mdExtractionQuality={doc.md_extraction_quality} extractedText={doc.extracted_text} class="prose prose-base max-w-none" />
+            {:else}<iframe src="/api/documents/{doc.id}/file?token={getAccessToken()}" class="w-full h-[80vh] rounded" title={doc.title}></iframe>{/if}
           {:else if viewerType === 'image'}
-            <img
-              src="/api/documents/{doc.id}/file?token={getAccessToken()}"
-              alt={doc.title}
-              class="max-w-full rounded"
-            />
+            <img src="/api/documents/{doc.id}/file?token={getAccessToken()}" alt={doc.title} class="max-w-full rounded" />
           {:else if viewerType === 'synology'}
-            <EmptyState
-              icon={ExternalLink}
-              title="Synology Office 문서"
-              description="외부 편집기에서 열어야 합니다."
-            >
-              <Button
-                variant="primary"
-                size="sm"
-                href={doc.edit_url || 'https://link.hyungi.net'}
-                target="_blank"
-              >
-                새 창에서 열기
-              </Button>
-            </EmptyState>
+            <EmptyState icon={FileText} title="Synology Office 문서" description="외부 편집기에서 열어야 합니다."><Button variant="primary" size="sm" href={doc.edit_url || 'https://link.hyungi.net'} target="_blank">새 창에서 열기</Button></EmptyState>
           {:else if viewerType === 'article'}
-            <div>
-              <h1 class="text-xl font-bold text-text mb-3">{doc.title}</h1>
-              <div class="flex items-center gap-2 mb-4 text-xs text-dim">
-                <span>출처: {doc.source_channel}</span>
-                <span class="text-faint">·</span>
-                <span>
-                  {new Date(doc.created_at).toLocaleDateString('ko-KR', {
-                    year: 'numeric',
-                    month: 'short',
-                    day: 'numeric',
-                  })}
-                </span>
-              </div>
-              {#if doc.md_content || doc.extracted_text}
-                <!-- article = 텍스트 네이티브(markdown 변환 비대상). md_status='skipped' 라도
-                     "Markdown 제외" badge 를 띄우지 않도록 mdStatus 미전달(badge 는 mdStatus 로만 구동). -->
-                <MarkdownDoc
-                  documentId={doc.id}
-                  mdContent={doc.md_content}
-                  mdFrontmatter={doc.md_frontmatter}
-                  mdStatus={null}
-                  mdExtractionError={doc.md_extraction_error}
-                  mdExtractionQuality={doc.md_extraction_quality}
-                  extractedText={doc.extracted_text}
-                  class="mb-6"
-                />
-              {/if}
-              {#if doc.edit_url}
-                <Button
-                  variant="primary"
-                  size="sm"
-                  icon={ExternalLink}
-                  href={doc.edit_url}
-                  target="_blank"
-                >
-                  원문 보기
-                </Button>
-              {/if}
-            </div>
-          {:else}
-            <EmptyState
-              icon={FileText}
-              title="인앱 미리보기 미지원"
-              description="포맷: {doc.file_format}"
-            />
-          {/if}
-        </Card>
+            {#if doc.md_content || doc.extracted_text}<MarkdownDoc documentId={doc.id} mdContent={doc.md_content} mdFrontmatter={doc.md_frontmatter} mdStatus={null} mdExtractionError={doc.md_extraction_error} mdExtractionQuality={doc.md_extraction_quality} extractedText={doc.extracted_text} class="prose prose-base max-w-none" />{/if}
+            {#if doc.edit_url}<div class="mt-4"><Button variant="primary" size="sm" href={doc.edit_url} target="_blank">원문 보기</Button></div>{/if}
+          {:else}<EmptyState icon={FileText} title="인앱 미리보기 미지원" description="포맷: {doc.file_format}" />{/if}
+        </div>
+      {/snippet}
 
-        <!-- 손글씨 노트 패드 (자료실 자료, "필기" 토글 시) -->
-        {#if noteOpen && doc.category === 'library' && noteLoaded}
-          <Card class="overflow-hidden p-0">
-            <div class="h-[60vh] min-h-[400px] flex flex-col">
-              <HandwriteCanvas
-                sessionId={doc.id}
-                initialStrokes={noteStrokes}
-                onChange={(strokes) => saveNote(strokes)}
-              />
-            </div>
-          </Card>
-        {/if}
+      <!-- 데스크탑: 본문 | 인사이트 레일 -->
+      <div class="hidden xl:grid xl:grid-cols-[minmax(0,1fr)_336px] gap-3.5 items-start">
+        {@render fbViewer()}
+        <div style="position:sticky;top:14px;">{@render rail()}</div>
       </div>
+      <!-- 모바일: 인사이트(상단 상시) + 본문 -->
+      <div class="xl:hidden">
+        <div style="margin-bottom:12px;">{@render rail()}</div>
+        {@render fbViewer()}
+      </div>
+    {/if}
 
-      <!-- 오른쪽 — 슬림 전역 인사이트 레일 (D3: 탭 게이트 제거, 요약·심층·불일치 상시 노출).
-           정보/관리는 접이(<details>) — 데스크탑은 인사이트 상시, 모바일은 본문 메인 + 열어서 확인. -->
-      <aside class="min-w-0 space-y-3">
-        {#if doc.category === 'library'}
-          <Card>
-            <ReadCounter
-              documentId={doc.id}
-              initialCount={doc.read_count ?? 0}
-              initialLastReadAt={doc.last_read_at ?? null}
-            />
-          </Card>
-        {/if}
+    <!-- 관리 (편집/삭제) — 헤더 '관리'로 토글 -->
+    {#if manageOpen}
+      <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;padding:16px 18px;margin-top:14px;">
+        <div style="font-size:12px;font-weight:700;color:#697061;margin-bottom:12px;letter-spacing:.3px;">관리 · 분류 편집</div>
+        <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
+          <AIClassificationEditor {doc} />
+          <LibraryPathEditor {doc} />
+          <NoteEditor {doc} />
+          <EditUrlEditor {doc} />
+          <TagsEditor {doc} />
+        </div>
+        <div class="pt-3 mt-3 border-t border-default"><DocumentDangerZone {doc} ondelete={handleDocDelete} /></div>
+      </div>
+    {/if}
 
-        <!-- 요약·분석 — 기본 펼침(데스크탑 상시감, 모바일 접기 가능) -->
-        <details open class="bg-surface border border-default rounded-card overflow-hidden group">
-          <summary class="cursor-pointer list-none flex items-center justify-between px-3.5 py-2.5 text-xs font-semibold text-dim uppercase tracking-wide select-none">
-            <span>요약 · 분석</span>
-            <ChevronRight size={14} class="transition-transform group-open:rotate-90 text-faint" />
-          </summary>
-          <div class="px-3.5 pb-3.5 space-y-4">
-            <AnalysisPanel docId={doc.id} doc={doc} />
-            <AIClassificationEditor {doc} />
-            <div>
-              <h4 class="text-xs font-semibold text-dim uppercase mb-1.5">관련 문서</h4>
-              <!-- TODO(backend): GET /documents/{id}/related?limit=10 (벡터 유사도) — v1 제외(자리만) -->
-              <EmptyState
-                icon={FileText}
-                title="추후 지원"
-                description="관련 문서 추천은 backend 연동 후 제공됩니다."
-              />
-            </div>
-          </div>
-        </details>
+    {#if noteOpen && doc.category === 'library' && noteLoaded}
+      <div style="background:#f4f7f1;border:1px solid #dde3d6;border-radius:14px;overflow:hidden;margin-top:14px;"><div class="h-[60vh] min-h-[400px] flex flex-col"><HandwriteCanvas sessionId={doc.id} initialStrokes={noteStrokes} onChange={(s) => saveNote(s)} /></div></div>
+    {/if}
 
-        <!-- 문서 정보 — 접이(기본 닫힘) -->
-        <details class="bg-surface border border-default rounded-card overflow-hidden group">
-          <summary class="cursor-pointer list-none flex items-center justify-between px-3.5 py-2.5 text-xs font-semibold text-dim uppercase tracking-wide select-none">
-            <span>문서 정보</span>
-            <ChevronRight size={14} class="transition-transform group-open:rotate-90 text-faint" />
-          </summary>
-          <div class="px-3.5 pb-3.5 space-y-3">
-            <FileInfoView {doc} />
-            <ProcessingStatusView {doc} />
-          </div>
-        </details>
-
-        <!-- 관리 — 접이(기본 닫힘) -->
-        <details class="bg-surface border border-default rounded-card overflow-hidden group">
-          <summary class="cursor-pointer list-none flex items-center justify-between px-3.5 py-2.5 text-xs font-semibold text-dim uppercase tracking-wide select-none">
-            <span>관리</span>
-            <ChevronRight size={14} class="transition-transform group-open:rotate-90 text-faint" />
-          </summary>
-          <div class="px-3.5 pb-3.5 space-y-3">
-            <LibraryPathEditor {doc} />
-            <NoteEditor {doc} />
-            <EditUrlEditor {doc} />
-            <TagsEditor {doc} />
-            <div class="pt-2 border-t border-default">
-              <DocumentDangerZone {doc} ondelete={handleDocDelete} />
-            </div>
-          </div>
-        </details>
-      </aside>
-    </div>
-
-    <!-- 모바일 sticky 하단 바 — 자료실 자료의 학습 흐름 네비게이션 -->
     {#if doc.category === 'library'}
       <div class="lg:hidden fixed bottom-0 inset-x-0 z-30 bg-surface border-t border-default px-3 py-2 flex items-center gap-2 shadow-lg">
-        <button
-          type="button"
-          onclick={() => neighbors.prev && goto(`/documents/${neighbors.prev.id}`)}
-          disabled={!neighbors.prev}
-          class="px-2 py-2 rounded text-dim disabled:opacity-30 disabled:cursor-not-allowed"
-          aria-label="이전 자료"
-        ><ChevronLeft size={20} /></button>
-
-        <button
-          type="button"
-          onclick={readAndGoNext}
-          disabled={!neighbors.next}
-          class="flex-1 flex items-center justify-center gap-1.5 px-3 py-2.5 rounded-lg bg-accent text-white text-sm font-medium disabled:opacity-50"
-        >
-          <Check size={16} />
-          {#if neighbors.next}
-            1회독 완료 + 다음
-          {:else}
-            1회독 완료 (마지막 자료)
-          {/if}
-        </button>
-
-        <button
-          type="button"
-          onclick={() => neighbors.next && goto(`/documents/${neighbors.next.id}`)}
-          disabled={!neighbors.next}
-          class="px-2 py-2 rounded text-dim disabled:opacity-30 disabled:cursor-not-allowed"
-          aria-label="다음 자료 (회독 카운트 안 함)"
-        ><ChevronRight size={20} /></button>
+        <button type="button" onclick={() => neighbors.prev && goto(`/documents/${neighbors.prev.id}`)} disabled={!neighbors.prev} class="px-3 py-2 rounded text-dim disabled:opacity-30" aria-label="이전">‹</button>
+        <button type="button" onclick={readAndGoNext} disabled={!neighbors.next} class="flex-1 px-3 py-2.5 rounded-lg bg-accent text-white text-sm font-medium disabled:opacity-50">{#if neighbors.next}1회독 완료 + 다음{:else}1회독 완료 (마지막){/if}</button>
+        <button type="button" onclick={() => neighbors.next && goto(`/documents/${neighbors.next.id}`)} disabled={!neighbors.next} class="px-3 py-2 rounded text-dim disabled:opacity-30" aria-label="다음">›</button>
       </div>
-      <!-- 본문이 sticky 바 뒤에 가리지 않도록 패딩 -->
       <div class="lg:hidden h-20"></div>
     {/if}
   {/if}
+ </div>
 </div>
+
+<style>
+  .d3node:hover { background: #ecf0e8; }
+  .d3active:hover { background: #e3ebdf; }
+  .d3child { position: relative; }
+  .d3child::before { content: ""; position: absolute; left: 2px; top: -3px; bottom: 50%; width: 1px; background: #cdd6c4; }
+  .d3child::after { content: ""; position: absolute; left: 2px; top: 50%; width: 7px; height: 1px; background: #cdd6c4; }
+  .m-secbody[open] .m-chev { transform: rotate(90deg); }
+  .d3warn { animation: d3pulse 2.4s ease-in-out infinite; }
+  @keyframes d3pulse { 0%, 100% { box-shadow: 0 0 0 0 rgba(181, 132, 10, .35); } 50% { box-shadow: 0 0 0 3px rgba(181, 132, 10, 0); } }
+</style>

migrations/357_background_jobs.sql

@@ -0,0 +1,19 @@
+-- 2026-06-14 PR-Background-Jobs-Observability: 큐 밖 관리 스크립트(백필 등) 진행 가시화.
+-- processing_queue 는 파이프라인 stage 전용 — hier_overnight_backfill / section_summary_pilot
+-- 같은 off-queue 관리 스크립트는 여기에 진행상황을 남겨 대시보드 보드가 노출한다.
+-- worker_jobs(user_id NOT NULL, worker-pool 전용)와 별개 — 이건 owner 없는 관리 작업 heartbeat.
+-- 단일 statement (asyncpg multi-statement 불허 컨벤션). 인덱스는 소량 테이블이라 생략.
+CREATE TABLE IF NOT EXISTS background_jobs (
+    id           BIGSERIAL PRIMARY KEY,
+    kind         TEXT NOT NULL,                 -- 'hier_redecompose' | 'section_summary' | ...
+    label        TEXT,                          -- 사람이 읽는 대상 표기 (예: 'doc 5210 (Sec VIII)')
+    state        TEXT NOT NULL DEFAULT 'running'
+                    CHECK (state IN ('running', 'done', 'failed')),
+    processed    INTEGER NOT NULL DEFAULT 0,    -- 처리한 단위 수 (절/leaf 등)
+    total        INTEGER,                       -- 전체 단위 수 (미상이면 NULL)
+    detail       JSONB NOT NULL DEFAULT '{}'::jsonb,
+    error        TEXT,
+    started_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    updated_at   TIMESTAMPTZ NOT NULL DEFAULT now(),
+    finished_at  TIMESTAMPTZ
+);

migrations/358_documents_embedding_hnsw.sql

@@ -0,0 +1,11 @@
+-- 358: documents.embedding HNSW 벡터 인덱스 + hnsw.ef_search (검색 latency T3, 2026-06-15)
+-- PROD 적용 = CREATE INDEX CONCURRENTLY 로 수동 빌드(40k rows 무중단, /dev/shm 회피 위해 단일 스레드)
+--   + schema_migrations(358) 수동 기록 완료. runner 는 단일 트랜잭션이라 CONCURRENTLY 불가.
+-- 본 파일 = fresh-init/재현용: non-concurrent IF NOT EXISTS (빈 테이블 init 시 즉시, 기존 index 존재 시 no-op).
+CREATE INDEX IF NOT EXISTS idx_documents_embedding_hnsw
+  ON documents USING hnsw (embedding vector_cosine_ops)
+  WHERE (deleted_at IS NULL AND embedding IS NOT NULL);
+
+-- docs vector leg LIMIT = limit*4 (기본 80) → HNSW recall 위해 ef_search >= 80 필요.
+-- ivfflat.probes=20 과 동일하게 DB 레벨 GUC (ALTER DATABASE) 로 설정.
+ALTER DATABASE pkm SET hnsw.ef_search = 100;

scripts/hier_overnight_backfill.py

@@ -32,6 +32,7 @@ from core.config import settings
 from services.hier_decomp.builder import build_hier_tree
 from services.hier_decomp.persist import persist_hier_tree
 from services.search.llm_gate import Priority, acquire_mlx_gate
+from services.background_jobs import finish_job, heartbeat, start_job
 
 # 단일 진실: 절 분석 상수/헬퍼 (PROMPT_VERSION 일치 = 멱등 보존)
 from section_summary_pilot import (
@@ -140,8 +141,10 @@ def _make_engine():
     return create_async_engine(os.environ["DATABASE_URL"], pool_pre_ping=True)
 
 
-async def _analyze_doc_leaves(session, client, doc_id, doc_domain, model_name, stop_at):
-    """doc 의 미분석 hier leaf 분석 → upsert. stop_at(epoch) 넘으면 leaf 경계 중단."""
+async def _analyze_doc_leaves(session, client, doc_id, doc_domain, model_name, stop_at,
+                              engine=None, job_id=None, base_processed=0):
+    """doc 의 미분석 hier leaf 분석 → upsert. stop_at(epoch) 넘으면 leaf 경계 중단.
+    engine/job_id 주어지면 background_jobs 에 ~10절마다 진행 heartbeat(보드 가시화)."""
     rows = (await session.execute(LEAF_SQL, {"doc": doc_id, "pv": PROMPT_VERSION})).mappings().all()
     ok = fail = skip = 0
     timings, types = [], []
@@ -187,6 +190,8 @@ async def _analyze_doc_leaves(session, client, doc_id, doc_domain, model_name, s
             "content_hash": r["content_hash"], "error": err,
         })
         await session.commit()
+        if job_id and (ok + fail + skip) % 10 == 0:
+            await heartbeat(engine, job_id, processed=base_processed + ok + fail + skip)
     await session.commit()
     return {"ok": ok, "fail": fail, "skip": skip, "leaves": len(rows),
             "timings": timings, "types": types, "aborted": aborted}
@@ -256,6 +261,12 @@ async def cmd_run(args):
                      _candidate_params(allowlist, doc_ids))).mappings().all()
         _log(f"후보 doc {len(cands)} 선별. 시작.")
 
+        # 관측: 큐 밖 작업이라 대시보드 보드가 못 보므로 background_jobs 에 진행 노출(best-effort)
+        _job_kind = "hier_redecompose" if reprocess else "hier_backfill"
+        _job_label = (f"doc {args.doc} {'재분해' if reprocess else '분해'}" if doc_ids
+                      else f"{len(cands)}개 문서 {'재분해' if reprocess else '분해'}")
+        job_id = await start_job(engine, _job_kind, _job_label, total=None)
+
         for c in cands:
             if time.time() >= stop_at:
                 _log(f"⏰ deadline 버퍼 도달 — doc 경계에서 중단 (처리 {tot_docs} doc)")
@@ -272,7 +283,10 @@ async def cmd_run(args):
                              "timings": [], "types": [], "aborted": False}
                 else:
                     async with sm() as session:
-                        astat = await _analyze_doc_leaves(session, client, doc_id, doc_domain, model_name, stop_at)
+                        astat = await _analyze_doc_leaves(
+                            session, client, doc_id, doc_domain, model_name, stop_at,
+                            engine=engine, job_id=job_id,
+                            base_processed=(tot_ok + tot_fail + tot_skip))
             except Exception as exc:
                 _log(f"  ✗ doc={doc_id} 처리 실패(건너뜀): {type(exc).__name__}: {repr(exc)[:160]}")
                 continue
@@ -280,6 +294,8 @@ async def cmd_run(args):
             tot_docs += 1
             tot_ok += astat["ok"]; tot_fail += astat["fail"]; tot_skip += astat["skip"]
             all_timings += astat["timings"]; all_types += astat["types"]
+            await heartbeat(engine, job_id, processed=(tot_ok + tot_fail + tot_skip),
+                            total=tot_leaves_created)
             avg = statistics.mean(astat["timings"]) if astat["timings"] else 0
             _log(f"  ✓ doc={doc_id} ({len(body):,}자 {doc_domain.split('/')[0]}) "
                  f"leaf생성={leaves_created} 분석ok={astat['ok']} fail={astat['fail']} skip={astat['skip']} "
@@ -287,6 +303,7 @@ async def cmd_run(args):
             if astat["aborted"]:
                 _log("⏰ leaf 분석 중 deadline 도달 — 중단")
                 break
+        await finish_job(engine, job_id, state="done")
     finally:
         await client.close()
         await engine.dispose()

tests/fixtures/arxiv_search_pressure_vessel.xml

@@ -0,0 +1,383 @@
+<?xml version='1.0' encoding='UTF-8'?>
+<feed xmlns:opensearch="http://a9.com/-/spec/opensearch/1.1/" xmlns:arxiv="http://arxiv.org/schemas/atom" xmlns="http://www.w3.org/2005/Atom">
+  <id>https://arxiv.org/api/m9A/71G4hH6NGyarIQjqA3n6Zzk</id>
+  <title>arXiv Query: search_query=abs:"pressure vessel"&amp;id_list=&amp;start=0&amp;max_results=10</title>
+  <updated>2026-06-13T21:57:59Z</updated>
+  <link href="https://arxiv.org/api/query?search_query=abs:%22pressure+vessel%22&amp;start=0&amp;max_results=10&amp;id_list=" type="application/atom+xml"/>
+  <opensearch:itemsPerPage>10</opensearch:itemsPerPage>
+  <opensearch:totalResults>89</opensearch:totalResults>
+  <opensearch:startIndex>0</opensearch:startIndex>
+  <entry>
+    <id>http://arxiv.org/abs/1209.2405v1</id>
+    <title>A Survey of Pressure Vessel Code Compliance for Superconducting RF Cryomodules</title>
+    <updated>2012-09-11T19:34:46Z</updated>
+    <link href="https://arxiv.org/abs/1209.2405v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/1209.2405v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>Superconducting radio frequency (SRF) cavities made from niobium and cooled with liquid helium are becoming key components of many particle accelerators. The helium vessels surrounding the RF cavities, portions of the niobium cavities themselves, and also possibly the vacuum vessels containing these assemblies, generally fall under the scope of local and national pressure vessel codes. In the U.S., Department of Energy rules require national laboratories to follow national consensus pressure vessel standards or to show "a level of safety greater than or equal to" that of the applicable standard. Thus, while used for its superconducting properties, niobium ends up being treated as a low-temperature pressure vessel material. Niobium material is not a code listed material and therefore requires the designer to understand the mechanical properties for material used in each pressure vessel fabrication; compliance with pressure vessel codes therefore becomes a problem. This report summarizes the approaches that various institutions have taken in order to bring superconducting RF cryomodules into compliance with pressure vessel codes.</summary>
+    <category term="physics.acc-ph" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2012-09-11T19:34:46Z</published>
+    <arxiv:comment>7 pp</arxiv:comment>
+    <arxiv:primary_category term="physics.acc-ph"/>
+    <author>
+      <name>Thomas Peterson</name>
+      <arxiv:affiliation>Fermilab</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Arkadiy Klebaner</name>
+      <arxiv:affiliation>Fermilab</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Tom Nicol</name>
+      <arxiv:affiliation>Fermilab</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Jay Theilacker</name>
+      <arxiv:affiliation>Fermilab</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Hitoshi Hayano</name>
+      <arxiv:affiliation>KEK, Tsukuba</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Eiji Kako</name>
+      <arxiv:affiliation>KEK, Tsukuba</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Hirotaka Nakai</name>
+      <arxiv:affiliation>KEK, Tsukuba</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Akira Yamamoto</name>
+      <arxiv:affiliation>KEK, Tsukuba</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Kay Jensch</name>
+      <arxiv:affiliation>DESY</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Axel Matheisen</name>
+      <arxiv:affiliation>DESY</arxiv:affiliation>
+    </author>
+    <author>
+      <name>John Mammosser</name>
+      <arxiv:affiliation>Jefferson Lab</arxiv:affiliation>
+    </author>
+    <arxiv:doi>10.1063/1.4707088</arxiv:doi>
+    <link rel="related" href="https://doi.org/10.1063/1.4707088" title="doi"/>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/2003.02057v1</id>
+    <title>Investigation of Unit-1 Nuclear Reactor of the Fukushima Daiichi by Cosmic Muon Radiography</title>
+    <updated>2020-03-03T03:21:53Z</updated>
+    <link href="https://arxiv.org/abs/2003.02057v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/2003.02057v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>We have investigated the status of the nuclear fuel assemblies in Unit-1 reactor of the Fukushima Daiichi Nuclear Power plant by the method called Cosmic Muon Radiography. In this study, muon tracking detectors were placed outside of the reactor building. We succeeded in identifying the inner structure of the reactor complex such as the reactor containment vessel, pressure vessel, and other structures of the reactor building, through the concrete wall of the reactor building. We found that a large amount of fuel assemblies was missing in the original fuel loading zone inside the pressure vessel. It can be naturally interpreted that most of the nuclear fuel was melt and dropped down to the bottom of the pressure vessel or even below.</summary>
+    <category term="physics.ins-det" scheme="http://arxiv.org/schemas/atom"/>
+    <category term="hep-ex" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2020-03-03T03:21:53Z</published>
+    <arxiv:comment>14 pages, 17 figures</arxiv:comment>
+    <arxiv:primary_category term="physics.ins-det"/>
+    <author>
+      <name>Hirofumi Fujii</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Kazuhiko Hara</name>
+      <arxiv:affiliation>University of Tsukuba</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Kohei Hayashi</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Hidekazu Kakuno</name>
+      <arxiv:affiliation>Tokyo Metropolitan University</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Hideyo Kodama</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Kanetada Nagamine</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Kotaro Sato</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Shin-Hong Kim</name>
+      <arxiv:affiliation>University of Tsukuba</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Atsuto Suzuki</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Takayuki Sumiyoshi</name>
+      <arxiv:affiliation>Tokyo Metropolitan University</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Kazuki Takahashi</name>
+      <arxiv:affiliation>University of Tsukuba</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Fumihiko Takasaki</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Shuji Tanaka</name>
+      <arxiv:affiliation>High Energy Accelerator Research Organization</arxiv:affiliation>
+    </author>
+    <author>
+      <name>Satoru Yamashita</name>
+      <arxiv:affiliation>University of Tokyo</arxiv:affiliation>
+    </author>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/1609.07515v1</id>
+    <title>Low Background Stainless Steel for the Pressure Vessel in the PandaX-II Dark Matter Experiment</title>
+    <updated>2016-09-21T10:33:04Z</updated>
+    <link href="https://arxiv.org/abs/1609.07515v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/1609.07515v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>We report on the custom produced low radiation background stainless steel and the welding rod for the PandaX experiment, one of the deep underground experiments to search for dark matter and neutrinoless double beta decay using xenon. The anthropogenic 60 Co concentration in these samples is at the range of 1 mBq/kg or lower. We also discuss the radioactivity of nuclear-grade stainless steel from TISCO which has a similar background rate. The PandaX-II pressure vessel was thus fabricated using the stainless steel from CISRI and TISCO. Based on the analysis of the radioactivity data, we also made discussions on potential candidate for low background metal materials for future pressure vessel development.</summary>
+    <category term="physics.ins-det" scheme="http://arxiv.org/schemas/atom"/>
+    <category term="hep-ex" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2016-09-21T10:33:04Z</published>
+    <arxiv:primary_category term="physics.ins-det"/>
+    <author>
+      <name>Tao Zhang</name>
+    </author>
+    <author>
+      <name>Changbo Fu</name>
+    </author>
+    <author>
+      <name>Xiangdong Ji</name>
+    </author>
+    <author>
+      <name>Jianglai Liu</name>
+    </author>
+    <author>
+      <name>Xiang Liu</name>
+    </author>
+    <author>
+      <name>Xuming Wang</name>
+    </author>
+    <author>
+      <name>Chunfa Yao</name>
+    </author>
+    <author>
+      <name>Xunhua Yuan</name>
+    </author>
+    <arxiv:doi>10.1088/1748-0221/11/09/T09004</arxiv:doi>
+    <link rel="related" href="https://doi.org/10.1088/1748-0221/11/09/T09004" title="doi"/>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/2308.09786v1</id>
+    <title>Mechanical design of the optical modules intended for IceCube-Gen2</title>
+    <updated>2023-08-18T19:20:09Z</updated>
+    <link href="https://arxiv.org/abs/2308.09786v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/2308.09786v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>IceCube-Gen2 is an expansion of the IceCube neutrino observatory at the South Pole that aims to increase the sensitivity to high-energy neutrinos by an order of magnitude. To this end, about 10,000 new optical modules will be installed, instrumenting a fiducial volume of about 8 km^3. Two newly developed optical module types increase current sensitivity per module by a factor of three by integrating 16 and 18 newly developed four-inch PMTs in specially designed 12.5-inch diameter pressure vessels. Both designs use conical silicone gel pads to optically couple the PMTs to the pressure vessel to increase photon collection efficiency. The outside portion of gel pads are pre-cast onto each PMT prior to integration, while the interiors are filled and cast after the PMT assemblies are installed in the pressure vessel via a pushing mechanism. This paper presents both the mechanical design, as well as the performance of prototype modules at high pressure (70 MPa) and low temperature (-40 degree Celsius), characteristic of the environment inside the South Pole ice.</summary>
+    <category term="astro-ph.IM" scheme="http://arxiv.org/schemas/atom"/>
+    <category term="astro-ph.HE" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2023-08-18T19:20:09Z</published>
+    <arxiv:comment>Presented at the 38th International Cosmic Ray Conference (ICRC2023). See arXiv:2307.13048 for all IceCube-Gen2 contributions</arxiv:comment>
+    <arxiv:primary_category term="astro-ph.IM"/>
+    <author>
+      <name>Yuya Makino</name>
+      <arxiv:affiliation>for the IceCube-Gen2 Collaboration</arxiv:affiliation>
+    </author>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/0804.0261v1</id>
+    <title>Circulation in Blowdown Flows</title>
+    <updated>2008-04-01T22:22:32Z</updated>
+    <link href="https://arxiv.org/abs/0804.0261v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/0804.0261v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>  The blowdown of high pressure gas in a pressure vessel produces rapid adiabatic cooling of the gas remaining in the vessel. The gas near the wall is warmed by conduction from the wall, producing radial temperature and density gradients that affect the flow, the mass efflux rate and the thermodynamic states of both the outflowing and the contained gas. The resulting buoyancy-driven flow circulates gas through the vessel and reduces, but does not eliminate, these gradients. The purpose of this note is to estimate when blowdown cooling is rapid enough that the gas in the pressure vessel is neither isothermal nor isopycnic, though it remains isobaric. I define a dimensionless number, the buoyancy circulation number BC, that parametrizes these effects.</summary>
+    <category term="physics.flu-dyn" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2008-04-01T22:22:32Z</published>
+    <arxiv:comment>5 pp., no figures</arxiv:comment>
+    <arxiv:primary_category term="physics.flu-dyn"/>
+    <arxiv:journal_ref>J. Pressure Vessel Tech. 131, 034501 (2009)</arxiv:journal_ref>
+    <author>
+      <name>J. I. Katz</name>
+    </author>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/1204.0234v1</id>
+    <title>Substantiation of Thermodynamic Criteria of Explosion Safety in Process of Severe Accidents in Pressure Vessel Reactors</title>
+    <updated>2012-03-27T11:21:14Z</updated>
+    <link href="https://arxiv.org/abs/1204.0234v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/1204.0234v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>The paper represents original development of thermodynamic criteria of occurrence conditions of steam-gas explosions in the process of severe accidents. The received results can be used for modelling of processes of severe accidents in pressure vessel reactors.</summary>
+    <category term="physics.gen-ph" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2012-03-27T11:21:14Z</published>
+    <arxiv:comment>5 pages, 1 figure</arxiv:comment>
+    <arxiv:primary_category term="physics.gen-ph"/>
+    <author>
+      <name>V. I. Skalozubov</name>
+    </author>
+    <author>
+      <name>V. N. Vashchenko</name>
+    </author>
+    <author>
+      <name>S. S. Jarovoj</name>
+    </author>
+    <author>
+      <name>V. Yu. Kochnyeva</name>
+    </author>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/2511.11485v1</id>
+    <title>Data-efficient U-Net for Segmentation of Carbide Microstructures in SEM Images of Steel Alloys</title>
+    <updated>2025-11-14T17:01:02Z</updated>
+    <link href="https://arxiv.org/abs/2511.11485v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/2511.11485v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>Understanding reactor-pressure-vessel steel microstructure is crucial for predicting mechanical properties, as carbide precipitates both strengthen the alloy and can initiate cracks. In scanning electron microscopy images, gray-value overlap between carbides and matrix makes simple thresholding ineffective. We present a data-efficient segmentation pipeline using a lightweight U-Net (30.7~M parameters) trained on just \textbf{10 annotated scanning electron microscopy images}. Despite limited data, our model achieves a \textbf{Dice-Sørensen coefficient of 0.98}, significantly outperforming the state-of-the-art in the field of metallurgy (classical image analysis: 0.85), while reducing annotation effort by one order of magnitude compared to the state-of-the-art data efficient segmentation model. This approach enables rapid, automated carbide quantification for alloy design and generalizes to other steel types, demonstrating the potential of data-efficient deep learning in reactor-pressure-vessel steel analysis.</summary>
+    <category term="cs.LG" scheme="http://arxiv.org/schemas/atom"/>
+    <category term="cond-mat.mtrl-sci" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2025-11-14T17:01:02Z</published>
+    <arxiv:primary_category term="cs.LG"/>
+    <arxiv:journal_ref>Machine Learning and the Physical Sciences Workshop @ NeurIPS 2025 https://openreview.net/forum?id=xYY5pn4f8N</arxiv:journal_ref>
+    <author>
+      <name>Alinda Ezgi Gerçek</name>
+    </author>
+    <author>
+      <name>Till Korten</name>
+    </author>
+    <author>
+      <name>Paul Chekhonin</name>
+    </author>
+    <author>
+      <name>Maleeha Hassan</name>
+    </author>
+    <author>
+      <name>Peter Steinbach</name>
+    </author>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/2511.09689v1</id>
+    <title>An ASME-Compliant Helium-4 Evaporation Refrigerator for the SpinQuest Experiment</title>
+    <updated>2025-11-12T19:45:47Z</updated>
+    <link href="https://arxiv.org/abs/2511.09689v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/2511.09689v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>This paper presents the design, safety basis, and commissioning results of a 1 K liquid helium-4 (4He) evaporation refrigerator developed for the Fermilab SpinQuest Experiment (E1039). The system represents the first high power helium evaporation refrigerator operated in a fixed target scattering experiment at Fermilab and was engineered to comply with the Fermilab ES\&amp;H Manual (FESHM) requirements governing pressure vessels, piping, cryogenic systems, and vacuum vessels. The design is mapped to ASME B31.3 (Process Piping) and the ASME Boiler and Pressure Vessel Code (BPVC) for pressure boundary integrity and overpressure protection, with documented compliance to FESHM Chapters 5031 (Pressure Vessels), 5031.1 (Piping Systems), and 5033 (Vacuum Vessels). This work documents the methodology used to reach compliance and approval for the 4He evaporation refrigerator at Fermilab which the field lacks. Design considerations specific to the high radiation target-cave environment including remotely located instrumentation approximately 20 m from the cryostat are summarized, together with the relief-system sizing methodology used to accommodate transient heat loads from dynamic nuclear polarization microwaves and the high-intensity proton beam. Commissioning data from July 2024 confirms that the system satisfies all thermal performance and safety objectives.</summary>
+    <category term="physics.ins-det" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2025-11-12T19:45:47Z</published>
+    <arxiv:comment>For IEEE Transactions in Nuclear Physics, 11 pages, 14 figures</arxiv:comment>
+    <arxiv:primary_category term="physics.ins-det"/>
+    <author>
+      <name>Jordan D. Roberts</name>
+    </author>
+    <author>
+      <name>Vibodha Bandara</name>
+    </author>
+    <author>
+      <name>Kenichi Nakano</name>
+    </author>
+    <author>
+      <name>Dustin Keller</name>
+    </author>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/1507.04072v1</id>
+    <title>High-Voltage Terminal Test of Test Stand for 1-MV Electrostatic Accelerator</title>
+    <updated>2015-07-15T02:41:11Z</updated>
+    <link href="https://arxiv.org/abs/1507.04072v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/1507.04072v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>The Korea Multipurpose Accelerator Complex (KOMAC) has been developing a 300-kV test stand for a 1-MV electrostatic accelerator ion source. The ion source and accelerating tube will be installed in a high-pressure vessel. The ion source in the high-pressure vessel is required to have a high reliability. The test stand has been proposed and developed to confirm the stable operating conditions of the ion source. The ion source will be tested at the test stand to verify the long-time operating conditions. The test stand comprises a 300-kV high-voltage terminal, a battery for the ion-source power, a 60-Hz inverter, 200-MHz RF power, a 5-kV extraction power supply, a 300-kV accelerating tube, and a vacuum system. The results of the 300-kV high-voltage terminal tests are presented in this paper.</summary>
+    <category term="physics.acc-ph" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2015-07-15T02:41:11Z</published>
+    <arxiv:comment>International Conference on Accelerators and Beam Utilization (ICABU2014)</arxiv:comment>
+    <arxiv:primary_category term="physics.acc-ph"/>
+    <arxiv:journal_ref>Yong-Sub Cho KNS (2014); W. Sima IEEE (2004) 480-483; LA-UR-87-126 (1987); Jeong-tae Kim KNS (2014)</arxiv:journal_ref>
+    <author>
+      <name>Sae-Hoon Park</name>
+    </author>
+    <author>
+      <name>Yu-Seok Kim</name>
+    </author>
+    <arxiv:doi>10.3938/jkps</arxiv:doi>
+    <link rel="related" href="https://doi.org/10.3938/jkps" title="doi"/>
+  </entry>
+  <entry>
+    <id>http://arxiv.org/abs/2005.05585v1</id>
+    <title>Investigation of the Status of Unit 2 Nuclear Reactor of the Fukushima Daiichi by the Cosmic Muon Radiography</title>
+    <updated>2020-05-12T07:26:37Z</updated>
+    <link href="https://arxiv.org/abs/2005.05585v1" rel="alternate" type="text/html"/>
+    <link href="https://arxiv.org/pdf/2005.05585v1" rel="related" type="application/pdf" title="pdf"/>
+    <summary>We have investigated the status of the nuclear debris in the Unit-2 Nuclear Reactor of the Fukushima Daiichi Nuclear Power plant by the method called Cosmic Muon Radiography. In this measurement, the muon detector was placed outside of the reactor building as was the case of the measurement for the Unit-1 Reactor. Compared to the previous measurements, the detector was down-sized, which made us possible to locate it closer to the reactor and to investigate especially the lower part of the fuel loading zone. We identified the inner structures of the reactor such as the containment vessel, pressure vessel and other objects through the thick concrete wall of the reactor building. Furthermore, the observation showed existence of heavy material at the bottom of the pressure vessel, which can be interpreted as the debris of melted nuclear fuel dropped from the loading zone.</summary>
+    <category term="physics.ins-det" scheme="http://arxiv.org/schemas/atom"/>
+    <published>2020-05-12T07:26:37Z</published>
+    <arxiv:comment>11 figures and 2 tables</arxiv:comment>
+    <arxiv:primary_category term="physics.ins-det"/>
+    <author>
+      <name>Hirofumi Fujii</name>
+    </author>
+    <author>
+      <name>Kazuhiko Hara</name>
+    </author>
+    <author>
+      <name>Shugo Hashimoto</name>
+    </author>
+    <author>
+      <name>Kohei Hayashi</name>
+    </author>
+    <author>
+      <name>Hidekazu Kakuno</name>
+    </author>
+    <author>
+      <name>Hideyo Kodama</name>
+    </author>
+    <author>
+      <name>Gi Meiki</name>
+    </author>
+    <author>
+      <name>Masato Mizokami</name>
+    </author>
+    <author>
+      <name>Shinya Mizokami</name>
+    </author>
+    <author>
+      <name>Kanetada Nagamine</name>
+    </author>
+    <author>
+      <name>Kotaro Sato</name>
+    </author>
+    <author>
+      <name>Shunsuke Sekita</name>
+    </author>
+    <author>
+      <name>Hiroshi Shirai</name>
+    </author>
+    <author>
+      <name>Shin-Hong Kim</name>
+    </author>
+    <author>
+      <name>Takayuki Sumiyoshi</name>
+    </author>
+    <author>
+      <name>Atsuto Suzuki</name>
+    </author>
+    <author>
+      <name>Yoshihisa Takada</name>
+    </author>
+    <author>
+      <name>Kazuki Takahashi</name>
+    </author>
+    <author>
+      <name>Yu Takahashi</name>
+    </author>
+    <author>
+      <name>Fumihiko Takasaki</name>
+    </author>
+    <author>
+      <name>Daichi Yamada</name>
+    </author>
+    <author>
+      <name>Satoru Yamashita</name>
+    </author>
+  </entry>
+</feed>

tests/test_arxiv_collector_units.py

@@ -0,0 +1,75 @@
+"""B-3 PR2 — arXiv 파서·쿼리빌더 순수 단위 테스트 (plan safety-library-b3-1).
+
+fixture = arXiv API 실응답 박제(abs:"pressure vessel" relevance 10건 —
+DOI 보유 / journal_ref 만 보유 / 둘 다 없음 3경로 포함). run()/적재(DB)는 PR2 라이브 검증.
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "app"))
+
+from workers.arxiv_collector import (  # noqa: E402
+    build_search_query,
+    parse_arxiv_feed,
+)
+
+FIX = Path(__file__).parent / "fixtures" / "arxiv_search_pressure_vessel.xml"
+
+
+def _entries():
+    total, entries = parse_arxiv_feed(FIX.read_text(encoding="utf-8"))
+    return total, {e.arxiv_id: e for e in entries}, entries
+
+
+# ─── 피드 레벨 ───
+
+def test_feed_total_and_count():
+    total, by_id, entries = _entries()
+    assert total == 89                                 # fixture totalResults (페이징 재료)
+    assert len(entries) == 10
+
+
+def test_versionless_ids():
+    _, by_id, entries = _entries()
+    # arxiv_id 는 versionless (버전 접미는 .version 으로 분리)
+    assert all("/" not in e.arxiv_id for e in entries)
+    assert "1209.2405" in by_id and by_id["1209.2405"].version == "v1"
+
+
+# ─── DOI 보유 entry ───
+
+def test_entry_with_doi():
+    _, by_id, _ = _entries()
+    e = by_id["1209.2405"]
+    assert e.doi == "10.1063/1.4707088"            # normalize_doi 적용(소문자·정규화)
+    assert e.journal_ref is None
+    assert e.primary_category == "physics.acc-ph"
+    assert e.title.startswith("A Survey of Pressure Vessel")
+    assert len(e.summary) > 200                     # 초록 본문
+    assert e.published is not None
+    assert e.abs_url and "/abs/" in e.abs_url
+    assert e.pdf_url and "pdf" in e.pdf_url
+
+
+# ─── journal_ref 만 (DOI 없음) — 압력용기 저널 출판분 ───
+
+def test_entry_journal_ref_without_doi():
+    _, by_id, _ = _entries()
+    e = by_id["0804.0261"]
+    assert e.doi is None
+    assert e.journal_ref and "Pressure Vessel" in e.journal_ref
+
+
+# ─── 둘 다 없음(최근 preprint) 경로도 존재 ───
+
+def test_entry_neither_doi_nor_journal_ref_exists():
+    _, _, entries = _entries()
+    assert any(e.doi is None and e.journal_ref is None for e in entries)
+
+
+# ─── 쿼리 빌더 ───
+
+def test_build_search_query():
+    q = build_search_query("eess.SY", ["pressure vessel", "safety"])
+    assert q == 'cat:eess.SY AND (abs:"pressure vessel" OR abs:safety)'

tests/test_openalex_collector_units.py

@@ -0,0 +1,106 @@
+"""B-3 PR3 — OpenAlex 파서·초록복원·license 순수 단위 테스트 (plan safety-library-b3-1).
+
+fixture = OpenAlex /works 실응답 박제(process safety/pressure vessel OA 5건 —
+cc-by/cc-by-nc-nd/license None, 초록 있음/없음). run()/적재(DB)는 PR3 라이브 검증.
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "app"))
+
+from workers.openalex_collector import (  # noqa: E402
+    _reconstruct_abstract,
+    _seeds,
+    build_filter,
+    build_issn_filter,
+    license_meta,
+    parse_openalex_works,
+)
+
+FIX = Path(__file__).parent / "fixtures" / "openalex_works_response.json"
+
+
+def _works():
+    count, cursor, works = parse_openalex_works(FIX.read_text(encoding="utf-8"))
+    return count, {w.openalex_id: w for w in works}, works
+
+
+# ─── 피드 레벨 ───
+
+def test_count_and_results():
+    count, by_id, works = _works()
+    assert count == 1111
+    assert len(works) == 5
+    assert all(w.openalex_id.startswith("W") and "/" not in w.openalex_id for w in works)
+
+
+# ─── 초록 보유 + CC 라이선스 ───
+
+def test_work_with_abstract_and_cc():
+    _, by_id, _ = _works()
+    w = by_id["W2910511816"]
+    assert w.doi and w.doi.startswith("10.") and w.doi == w.doi.lower()  # normalize_doi
+    assert len(w.abstract) > 50            # inverted-index 복원
+    assert w.oa_status == "diamond" and w.is_oa is True
+    assert w.license == "cc-by"
+    assert license_meta(w.license, w.is_oa, w.source_name)["redistribute"] is True
+
+
+# ─── 초록 없는 thin 레코드(skip 대상) ───
+
+def test_work_without_abstract():
+    _, by_id, _ = _works()
+    w = by_id["W3107397139"]
+    assert w.abstract == ""                # inverted-index 부재 → 빈 초록
+    lm = license_meta(w.license, w.is_oa, w.source_name)
+    assert lm["redistribute"] is False     # license None → 비배포
+
+
+# ─── cc-by-nc-nd 도 CC 계열 → redistribute True ───
+
+def test_cc_variant_redistribute():
+    _, by_id, _ = _works()
+    w = by_id["W4391130399"]
+    assert w.license == "cc-by-nc-nd"
+    assert license_meta(w.license, w.is_oa, w.source_name)["redistribute"] is True
+
+
+# ─── 초록 inverted-index 복원 순서 ───
+
+def test_reconstruct_abstract_order():
+    inv = {"Safety": [0], "of": [1, 4], "pressure": [2], "vessels": [3], "design": [5]}
+    assert _reconstruct_abstract(inv) == "Safety of pressure vessels of design"
+    assert _reconstruct_abstract(None) == ""
+    assert _reconstruct_abstract({}) == ""
+
+
+# ─── license_meta 분기 ───
+
+def test_license_meta_branches():
+    assert license_meta("cc-by", True, "X")["redistribute"] is True
+    assert license_meta("cc0", True, "X")["redistribute"] is True
+    none_oa = license_meta(None, True, "X")
+    assert none_oa["redistribute"] is False and none_oa["scheme"] == "open-unspecified"
+    closed = license_meta(None, False, "X")
+    assert closed["redistribute"] is False and closed["scheme"] == "proprietary"
+
+
+# ─── 쿼리 빌더 ───
+
+def test_build_filter():
+    assert build_filter("process safety") == "title_and_abstract.search:process safety"
+    assert build_filter("process safety", "2026-06-01") == \
+        "title_and_abstract.search:process safety,from_publication_date:2026-06-01"
+
+
+# ─── PR6: ISSN 소스 시드 (KR/JP 안전 저널 직접 커버) ───
+
+def test_build_issn_filter_and_seeds():
+    assert build_issn_filter("1738-3803") == "primary_location.source.issn:1738-3803"
+    assert build_issn_filter("1738-3803", "2026-01-01") == \
+        "primary_location.source.issn:1738-3803,from_publication_date:2026-01-01"
+    seeds = _seeds()
+    kinds = [k for _, _, k in seeds]
+    assert kinds[0] == "issn"  # ISSN 시드가 키워드보다 먼저(cap 우선권)
+    assert any(v == "1738-3803" and k == "issn" for _, v, k in seeds)  # 한국안전학회지 포함

tests/test_paper_doi_units.py

@@ -0,0 +1,141 @@
+"""B-3 PR1 — 논문 DOI 코어 순수 단위 테스트 (plan safety-library-b3-1).
+
+holder.find_paper_holder(DB 조회)는 PR2 arXiv 실수집 시 라이브 검증 — 여기선 순수 함수만.
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent / "app"))
+
+from services.papers.doi import (  # noqa: E402
+    arxiv_doi,
+    normalize_doi,
+    paper_doi_hash,
+    parse_arxiv_id,
+    parse_doi_from_text,
+    read_paper_doi,
+    with_paper_doi,
+    with_parent_doi,
+)
+
+
+# ─── normalize_doi: 단일 함수(저장=조회) ───
+
+def test_normalize_strips_url_and_lowercases():
+    assert normalize_doi("https://doi.org/10.1585/PFR.15.2402039") == "10.1585/pfr.15.2402039"
+    assert normalize_doi("http://dx.doi.org/10.1115/1.4045678") == "10.1115/1.4045678"
+    assert normalize_doi("doi:10.1016/j.jlp.2020.104321") == "10.1016/j.jlp.2020.104321"
+    assert normalize_doi("DOI: 10.1234/ABC") == "10.1234/abc"
+
+
+def test_normalize_trims_whitespace_and_citation_noise():
+    assert normalize_doi("  https://doi.org/10.1234/abc  ") == "10.1234/abc"
+    assert normalize_doi("10.1234/abc.") == "10.1234/abc"
+    assert normalize_doi("10.1234/abc;") == "10.1234/abc"
+
+
+def test_normalize_preserves_parens_in_doi():
+    # 괄호는 DOI 일부일 수 있어 보존 (과삭제 = 다른 논문 병합 = 데이터 손상, near-dup 보다 위험)
+    assert normalize_doi("10.1016/s0010-8650(00)80003-2") == "10.1016/s0010-8650(00)80003-2"
+    assert normalize_doi("https://doi.org/10.1016/S0010-8650(00)80003-2") == "10.1016/s0010-8650(00)80003-2"
+
+
+def test_normalize_rejects_non_doi():
+    assert normalize_doi(None) is None
+    assert normalize_doi("") is None
+    assert normalize_doi("   ") is None
+    assert normalize_doi("not-a-doi") is None
+    assert normalize_doi("arXiv:2606.08108") is None  # arXiv id 는 DOI 아님
+
+
+def test_normalize_is_idempotent_store_equals_lookup():
+    # 저장측·조회측이 같은 함수를 거치면 표기 차이가 한 값으로 붕괴 (dedup 성립 조건)
+    forms = [
+        "https://doi.org/10.1/X",
+        "doi:10.1/x",
+        "10.1/X",
+        "  HTTPS://DOI.ORG/10.1/x ",
+    ]
+    assert {normalize_doi(f) for f in forms} == {"10.1/x"}
+    assert normalize_doi(normalize_doi("https://doi.org/10.1/X")) == "10.1/x"  # 멱등
+
+
+# ─── paper_doi_hash: holder file_hash 키 ───
+
+def test_paper_doi_hash_deterministic_len32():
+    h = paper_doi_hash("10.1234/abc")
+    assert len(h) == 32
+    assert h == paper_doi_hash("10.1234/abc")
+
+
+def test_paper_doi_hash_distinct_per_doi():
+    assert paper_doi_hash("10.1/a") != paper_doi_hash("10.1/b")
+
+
+# ─── 2-Document extract_meta 계약 (holder doi / child parent_doi 상호 배타) ───
+
+def test_with_paper_doi_holder_shape_and_merge_safe():
+    meta = with_paper_doi({"license": {"scheme": "cc_by"}, "source_id": 7}, "10.1/x")
+    assert meta["paper"]["doi"] == "10.1/x"
+    assert "parent_doi" not in meta["paper"]
+    assert meta["license"]["scheme"] == "cc_by"  # 타 키 보존
+    assert meta["source_id"] == 7
+
+
+def test_with_parent_doi_child_shape_no_doi():
+    meta = with_parent_doi({"license": {"scheme": "proprietary"}}, "10.1/holder")
+    assert meta["paper"]["parent_doi"] == "10.1/holder"
+    assert "doi" not in meta["paper"]  # child 는 doi 미보유 (partial-unique 인덱스 밖)
+    assert meta["license"]["scheme"] == "proprietary"
+
+
+def test_holder_child_mutually_exclusive():
+    child = with_parent_doi({}, "10.1/p")
+    promoted = with_paper_doi(child, "10.1/self")
+    assert promoted["paper"]["doi"] == "10.1/self"
+    assert "parent_doi" not in promoted["paper"]
+
+
+def test_input_not_mutated():
+    src = {"paper": {"doi": "10.1/old"}}
+    with_parent_doi(src, "10.1/new")
+    assert src["paper"]["doi"] == "10.1/old"  # 원본 dict 불변
+
+
+# ─── read_paper_doi: 인덱스 식의 조회측 거울 ───
+
+def test_read_paper_doi():
+    assert read_paper_doi({"paper": {"doi": "10.1/x"}}) == "10.1/x"
+    assert read_paper_doi({"paper": {"doi": "https://doi.org/10.1/X"}}) == "10.1/x"  # 방어적 재정규화
+    assert read_paper_doi({}) is None
+    assert read_paper_doi(None) is None
+    assert read_paper_doi({"paper": {"parent_doi": "10.1/p"}}) is None  # child 는 doi 없음
+    assert read_paper_doi({"paper": {}}) is None
+
+
+# ─── PR4: arXiv id 파싱 + arXiv DataCite DOI (교차소스 dedup 통일 키) ───
+
+def test_parse_arxiv_id():
+    assert parse_arxiv_id("Title arXiv:2606.10236v1 Announce Type: new Abstract") == "2606.10236"
+    assert parse_arxiv_id("see arXiv:2601.02852 for details") == "2601.02852"
+    assert parse_arxiv_id("arXiv:cond-mat/0703470v2") == "cond-mat/0703470"
+    assert parse_arxiv_id("no arxiv here") is None
+    assert parse_arxiv_id(None) is None
+
+
+def test_arxiv_doi_canonical():
+    # OpenAlex canonical 실측 일치: 10.48550/arxiv.{id} (소문자)
+    assert arxiv_doi("2606.10236") == "10.48550/arxiv.2606.10236"
+    assert arxiv_doi(None) is None
+    # 수집기·reconcile 가 같은 함수 → 같은 paper.doi (교차소스 dedup 성립)
+    assert arxiv_doi(parse_arxiv_id("x arXiv:2606.10236v1 y")) == "10.48550/arxiv.2606.10236"
+
+
+# ─── PR5: 구매 PDF 본문 DOI 파싱 (parent_doi 링크용, PDF 구조 무관) ───
+
+def test_parse_doi_from_text():
+    assert parse_doi_from_text("ref https://doi.org/10.1016/j.jlp.2024.105474 end") == "10.1016/j.jlp.2024.105474"
+    assert parse_doi_from_text("DOI 10.1115/1.4045678. Next.") == "10.1115/1.4045678"
+    assert parse_doi_from_text("no doi here") is None
+    assert parse_doi_from_text(None) is None