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

ds-watch 와 동일하게 CODE_SIGNING_ALLOWED/REQUIRED=NO 를 제거해
아이폰 실기기 설치 시 Xcode 자동서명(본인 Apple ID 팀) 가능하도록.

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

app/api/documents.py

@@ -28,7 +28,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 from starlette.requests import ClientDisconnect
 
 from ai.client import AIClient, _load_prompt, parse_json_response
-from core.auth import get_current_user
+from core.auth import get_current_user, get_egress_class
 from core.config import settings
 from core.database import async_session, get_session
 from core.utils import file_hash
@@ -742,11 +742,31 @@ async def get_document(
     doc_id: int,
     user: Annotated[User, Depends(get_current_user)],
     session: Annotated[AsyncSession, Depends(get_session)],
+    egress_class: Annotated[str, Depends(get_egress_class)],
 ):
-    """문서 단건 조회. 본문(extracted_text)·canonical markdown 동봉."""
+    """문서 단건 조회. 본문(extracted_text)·canonical markdown 동봉.
+
+    cloud egress(갭2): egress=cloud 토큰(예: Claude/MCP)은 search 와 동일한 cloud-eligibility
+    게이트를 통과한 문서만 열람 가능 — id 직접 fetch 로 비공개/인프라/개인/restricted 문서를
+    우회 열람하는 경로를 차단한다. 부적격은 404(존재 자체 비노출). local 토큰=게이트 미발동(무회귀).
+    """
+    from sqlalchemy import text as sql_text
+    from services.search.retrieval_service import cloud_eligible_doc_sql
+
     doc = await session.get(Document, doc_id)
     if not doc or doc.deleted_at is not None:
         raise HTTPException(status_code=404, detail="문서를 찾을 수 없습니다")
+    if egress_class == "cloud":
+        eligible = (
+            await session.execute(
+                sql_text(
+                    "SELECT 1 FROM documents WHERE id = :doc_id AND deleted_at IS NULL"
+                    + cloud_eligible_doc_sql("")
+                ).bindparams(doc_id=doc_id)
+            )
+        ).first()
+        if eligible is None:
+            raise HTTPException(status_code=404, detail="문서를 찾을 수 없습니다")
     return DocumentDetailResponse.model_validate(doc)
 
 
@@ -1028,6 +1048,19 @@ async def get_document_image_raw(
             DocumentImage.image_key == image_key,
         )
     )
+    if img is None:
+        # clause-KB: 절-문서는 부모 표준 이미지를 공유(md_content=부모 슬라이스) → parent_id 폴백.
+        from sqlalchemy import text as sql_text
+        _par = (await session.execute(
+            sql_text("SELECT parent_id FROM documents WHERE id = :id").bindparams(id=doc_id)
+        )).scalar()
+        if _par is not None:
+            img = await session.scalar(
+                select(DocumentImage).where(
+                    DocumentImage.document_id == _par,
+                    DocumentImage.image_key == image_key,
+                )
+            )
     if img is None:
         raise HTTPException(status_code=404, detail="이미지를 찾을 수 없습니다")
 
@@ -1801,3 +1834,305 @@ async def analyze_document(
             error_code=error_code,
             source=source,
         )
+
+
+# ─── ASME 절-지식베이스: 유기적 책 네비 (clause-KB, doc_kind='clause' 자식 문서 기반) ───
+class ClauseTocItem(BaseModel):
+    id: int
+    clause_code: str | None = None
+    clause_part: str | None = None
+    clause_order: int | None = None
+    title: str | None = None
+
+
+class ClauseBookResponse(BaseModel):
+    parent_id: int
+    parent_title: str | None = None
+    clauses: list[ClauseTocItem]
+
+
+@router.get("/{doc_id}/clauses", response_model=ClauseBookResponse)
+async def get_document_clauses(
+    doc_id: int,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[AsyncSession, Depends(get_session)],
+):
+    """부모 표준 doc 의 절-문서 목차(유기적 책 TOC). doc_kind='clause' 자식을 clause_order 순 반환.
+
+    절-문서는 in_corpus=false + doc_kind='clause'(검색 제외)라 일반 목록/검색엔 안 뜨지만,
+    이 책-내 네비는 부모 표준에서 자식 절로 진입하는 전용 경로다(ASME 2025판=한 권의 책).
+    """
+    from sqlalchemy import text as sql_text
+
+    parent = await session.get(Document, doc_id)
+    if not parent or parent.deleted_at is not None:
+        raise HTTPException(status_code=404, detail="문서를 찾을 수 없습니다")
+    rows = (
+        await session.execute(
+            sql_text(
+                """
+                SELECT id, clause_code, clause_part, clause_order, title
+                FROM documents
+                WHERE parent_id = :pid AND doc_kind = 'clause' AND deleted_at IS NULL
+                ORDER BY clause_order
+                """
+            ).bindparams(pid=doc_id)
+        )
+    ).mappings().all()
+    return ClauseBookResponse(
+        parent_id=doc_id,
+        parent_title=parent.title,
+        clauses=[ClauseTocItem(**dict(r)) for r in rows],
+    )
+
+
+class BacklinkRef(BaseModel):
+    code: str
+    doc_id: int | None = None   # 해소된 절-문서(같은 부모) — dangling 이면 None
+    title: str | None = None
+    anchor: str | None = None
+    ctx: str | None = None
+
+
+class BacklinksResponse(BaseModel):
+    doc_id: int
+    clause_code: str | None = None
+    parent_id: int | None = None
+    prev: ClauseTocItem | None = None
+    next: ClauseTocItem | None = None
+    forward: list[BacklinkRef]   # 이 절이 참조하는 절들
+    back: list[BacklinkRef]      # 이 절을 참조하는 절들
+
+
+@router.get("/{doc_id}/backlinks", response_model=BacklinksResponse)
+async def get_document_backlinks(
+    doc_id: int,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[AsyncSession, Depends(get_session)],
+):
+    """절-문서의 양방향 백링크 + 같은 부모 내 이전/다음 절(유기적 책 흐름)."""
+    from sqlalchemy import text as sql_text
+
+    doc = await session.get(Document, doc_id)
+    if not doc or doc.deleted_at is not None:
+        raise HTTPException(status_code=404, detail="문서를 찾을 수 없습니다")
+
+    _meta = (await session.execute(sql_text(
+        "SELECT parent_id, clause_code, clause_order FROM documents WHERE id = :id"
+    ).bindparams(id=doc_id))).mappings().first()
+    _parent_id = _meta["parent_id"] if _meta else None
+    _clause_code = _meta["clause_code"] if _meta else None
+    _clause_order = _meta["clause_order"] if _meta else None
+    forward = (
+        await session.execute(
+            sql_text(
+                """
+                SELECT cl.dst_code AS code, cl.dst_doc_id AS doc_id, cl.anchor, cl.ctx, d.title
+                FROM clause_links cl
+                LEFT JOIN documents d ON d.id = cl.dst_doc_id
+                WHERE cl.src_doc_id = :id
+                ORDER BY cl.char_off NULLS LAST
+                LIMIT 300
+                """
+            ).bindparams(id=doc_id)
+        )
+    ).mappings().all()
+    back = (
+        await session.execute(
+            sql_text(
+                """
+                SELECT s.clause_code AS code, cl.src_doc_id AS doc_id, s.title, cl.ctx
+                FROM clause_links cl
+                JOIN documents s ON s.id = cl.src_doc_id
+                WHERE cl.dst_doc_id = :id
+                ORDER BY s.clause_order NULLS LAST
+                LIMIT 300
+                """
+            ).bindparams(id=doc_id)
+        )
+    ).mappings().all()
+
+    prev = nxt = None
+    if _parent_id is not None and _clause_order is not None:
+        prow = (
+            await session.execute(
+                sql_text(
+                    """
+                    SELECT id, clause_code, clause_part, clause_order, title FROM documents
+                    WHERE parent_id = :pid AND doc_kind='clause' AND deleted_at IS NULL
+                      AND clause_order < :ord
+                    ORDER BY clause_order DESC LIMIT 1
+                    """
+                ).bindparams(pid=_parent_id, ord=_clause_order)
+            )
+        ).mappings().first()
+        nrow = (
+            await session.execute(
+                sql_text(
+                    """
+                    SELECT id, clause_code, clause_part, clause_order, title FROM documents
+                    WHERE parent_id = :pid AND doc_kind='clause' AND deleted_at IS NULL
+                      AND clause_order > :ord
+                    ORDER BY clause_order ASC LIMIT 1
+                    """
+                ).bindparams(pid=_parent_id, ord=_clause_order)
+            )
+        ).mappings().first()
+        prev = ClauseTocItem(**dict(prow)) if prow else None
+        nxt = ClauseTocItem(**dict(nrow)) if nrow else None
+
+    return BacklinksResponse(
+        doc_id=doc_id,
+        clause_code=_clause_code,
+        parent_id=_parent_id,
+        prev=prev,
+        next=nxt,
+        forward=[BacklinkRef(**dict(r)) for r in forward],
+        back=[BacklinkRef(**dict(r)) for r in back],
+    )
+
+
+# ─── 관련 문서 (유사도, on-demand pgvector KNN — 저부하·무저장) ───
+class RelatedItem(BaseModel):
+    id: int
+    title: str | None = None
+    ai_domain: str | None = None
+    material_type: str | None = None
+    year: int | None = None
+    sim: float | None = None
+
+
+class RelatedResponse(BaseModel):
+    doc_id: int
+    related: list[RelatedItem]
+
+
+@router.get("/{doc_id}/related", response_model=RelatedResponse)
+async def get_related_documents(
+    doc_id: int,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[AsyncSession, Depends(get_session)],
+    limit: int = 8,
+    same_type: bool = True,
+):
+    """문서-레벨 임베딩 코사인 최근접 = '관련 문서'. on-demand(저장/배치 없음).
+
+    인용그래프가 부적합한 코퍼스(업계 기술기사=인용망 부재)의 대안 연결 레이어.
+    same_type=true면 같은 material_type 내, false면 전 코퍼스. doc_kind='clause'(절-문서)는 제외.
+    """
+    from sqlalchemy import text as sql_text
+
+    lim = max(1, min(limit, 30))
+    type_clause = "AND d.material_type = src.material_type" if same_type else ""
+    rows = (
+        await session.execute(
+            sql_text(
+                f"""
+                WITH src AS (
+                    SELECT embedding, material_type FROM documents WHERE id = :id
+                )
+                SELECT d.id, d.title, d.ai_domain, d.material_type, d.facet_year AS year,
+                       round((1 - (d.embedding <=> (SELECT embedding FROM src)))::numeric, 3) AS sim
+                FROM documents d, src
+                WHERE d.doc_kind = 'standard' AND d.deleted_at IS NULL
+                  AND d.id <> :id AND d.embedding IS NOT NULL
+                  AND (SELECT embedding FROM src) IS NOT NULL
+                  {type_clause}
+                ORDER BY d.embedding <=> (SELECT embedding FROM src)
+                LIMIT :lim
+                """
+            ).bindparams(id=doc_id, lim=lim)
+        )
+    ).mappings().all()
+    return RelatedResponse(
+        doc_id=doc_id,
+        related=[RelatedItem(**{k: r[k] for k in ("id", "title", "ai_domain", "material_type", "year")}, sim=float(r["sim"]) if r["sim"] is not None else None) for r in rows],
+    )
+
+
+# ─── 절 공부도구 (노트/형광펜/암기카드) — clause_study ───
+class StudyItem(BaseModel):
+    id: int
+    kind: str
+    payload: dict = {}
+    created_at: datetime | None = None
+
+
+class StudyListResponse(BaseModel):
+    doc_id: int
+    items: list[StudyItem]
+
+
+class StudyCreate(BaseModel):
+    kind: str           # note | highlight | card
+    payload: dict = {}
+
+
+def _parse_payload(p):
+    import json
+    if isinstance(p, str):
+        try:
+            return json.loads(p)
+        except Exception:
+            return {}
+    return p or {}
+
+
+@router.get("/{doc_id}/study", response_model=StudyListResponse)
+async def list_study(
+    doc_id: int,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[AsyncSession, Depends(get_session)],
+):
+    """절-문서의 공부도구 항목(노트/형광펜/암기카드) 목록."""
+    from sqlalchemy import text as sql_text
+    rows = (
+        await session.execute(
+            sql_text("SELECT id, kind, payload, created_at FROM clause_study "
+                     "WHERE doc_id = :id ORDER BY created_at DESC").bindparams(id=doc_id)
+        )
+    ).mappings().all()
+    return StudyListResponse(
+        doc_id=doc_id,
+        items=[StudyItem(id=r["id"], kind=r["kind"], payload=_parse_payload(r["payload"]),
+                         created_at=r["created_at"]) for r in rows],
+    )
+
+
+@router.post("/{doc_id}/study", response_model=StudyItem, status_code=201)
+async def add_study(
+    doc_id: int,
+    body: StudyCreate,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[AsyncSession, Depends(get_session)],
+):
+    """노트/형광펜/암기카드 1건 추가."""
+    import json
+    from sqlalchemy import text as sql_text
+    if body.kind not in ("note", "highlight", "card"):
+        raise HTTPException(status_code=400, detail="kind 는 note/highlight/card")
+    row = (
+        await session.execute(
+            sql_text("INSERT INTO clause_study(doc_id, kind, payload) "
+                     "VALUES (:d, :k, cast(:p AS jsonb)) RETURNING id, kind, payload, created_at")
+            .bindparams(d=doc_id, k=body.kind, p=json.dumps(body.payload, ensure_ascii=False))
+        )
+    ).mappings().first()
+    await session.commit()
+    return StudyItem(id=row["id"], kind=row["kind"], payload=_parse_payload(row["payload"]),
+                     created_at=row["created_at"])
+
+
+@router.delete("/{doc_id}/study/{study_id}", status_code=204)
+async def delete_study(
+    doc_id: int,
+    study_id: int,
+    user: Annotated[User, Depends(get_current_user)],
+    session: Annotated[AsyncSession, Depends(get_session)],
+):
+    from sqlalchemy import text as sql_text
+    await session.execute(
+        sql_text("DELETE FROM clause_study WHERE id = :s AND doc_id = :d")
+        .bindparams(s=study_id, d=doc_id)
+    )
+    await session.commit()

app/api/search.py

@@ -15,7 +15,7 @@ from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from core.auth import get_current_user
+from core.auth import get_current_user, get_egress_class
 from core.database import get_session
 from core.utils import setup_logger
 from models.user import User
@@ -139,6 +139,7 @@ def _build_search_debug(pr: PipelineResult) -> SearchDebug:
 async def search(
     q: str,
     user: Annotated[User, Depends(get_current_user)],
+    egress_class: Annotated[str, Depends(get_egress_class)],
     session: Annotated[AsyncSession, Depends(get_session)],
     background_tasks: BackgroundTasks,
     mode: str = Query("hybrid", pattern="^(fts|trgm|vector|hybrid)$"),
@@ -211,6 +212,8 @@ async def search(
         None, description="안전 자료실 C-1: 관할 필터 (KR/US/EU/JP/GB/INT)"),
     year_from: int | None = Query(None, ge=1900, le=2100, description="published_date 연도 하한 (NULL=created_at fallback)"),
     year_to: int | None = Query(None, ge=1900, le=2100, description="published_date 연도 상한"),
+    domain_bucket: str | None = Query(None, description="377: domain_bucket 스코프 CSV (Safety,Engineering,Law,Philosophy,Programming,General,News). domain_bucket = ANY"),
+    exclude_bucket: str | None = Query(None, description="377: domain_bucket 제외 CSV (예: News). 지식질의 시 News 기본제외용"),
     facets: bool = Query(False, description="안전 자료실 C-1 후속: top-K 결과 분류 축 분포(material_type/jurisdiction/version_status)를 응답 facets 에 집계. 미지정=계산/노출 0"),
 ):
     """문서 검색 — FTS + ILIKE + 벡터 결합 (Phase 3.1 이후 run_search wrapper)"""
@@ -221,6 +224,9 @@ async def search(
             jurisdiction=jurisdiction,
             year_from=year_from,
             year_to=year_to,
+            domain_buckets=[b.strip() for b in domain_bucket.split(",") if b.strip()] if domain_bucket else None,
+            exclude_buckets=[b.strip() for b in exclude_bucket.split(",") if b.strip()] if exclude_bucket else None,
+            cloud_egress=(egress_class == "cloud"),
         )
         pr = await run_search(
             session,

app/core/auth.py

@@ -31,11 +31,11 @@ def hash_password(password: str) -> str:
     return bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
 
 
-def create_access_token(subject: str, expires_minutes: int | None = None) -> str:
+def create_access_token(subject: str, expires_minutes: int | None = None, egress: str = "local") -> str:
     minutes = expires_minutes if expires_minutes is not None else ACCESS_TOKEN_EXPIRE_MINUTES
     now = datetime.now(timezone.utc)
     expire = now + timedelta(minutes=minutes)
-    payload = {"sub": subject, "exp": expire, "iat": int(now.timestamp()), "type": "access"}
+    payload = {"sub": subject, "exp": expire, "iat": int(now.timestamp()), "type": "access", "egress": egress}
     return jwt.encode(payload, settings.jwt_secret, algorithm=ALGORITHM)
 
 
@@ -100,6 +100,15 @@ def verify_totp(code: str, secret: str | None = None) -> bool:
     return totp.verify(code)
 
 
+async def get_egress_class(
+    credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)],
+) -> str:
+    """토큰 egress claim -> 'cloud'|'local' (갭2 cloud-egress allowlist). claim 부재=local
+    (비파괴; 기존 토큰=신뢰/로컬). 쿼리파라미터 아님 -> 호출자가 끌 수 없음(우회 차단)."""
+    payload = decode_token(credentials.credentials)
+    return (payload or {}).get("egress", "local")
+
+
 async def get_current_user(
     credentials: Annotated[HTTPAuthorizationCredentials, Depends(security)],
     session: Annotated[AsyncSession, Depends(get_session)],

app/services/search/retrieval_service.py

@@ -76,10 +76,15 @@ class AxisFilter:
     jurisdiction: str | None = None
     year_from: int | None = None
     year_to: int | None = None
+    domain_buckets: list[str] | None = None    # 377: domain_bucket = ANY (도메인 스코프)
+    exclude_buckets: list[str] | None = None    # 377: domain_bucket <> ALL (예: News 제외)
+    cloud_egress: bool = False    # 갭2: 클라우드 소비자 cloud-eligibility allowlist 강제(토큰 claim 유래)
 
     def active(self) -> bool:
         return bool(self.material_types or self.jurisdiction
-                    or self.year_from is not None or self.year_to is not None)
+                    or self.year_from is not None or self.year_to is not None
+                    or self.domain_buckets or self.exclude_buckets
+                    or self.cloud_egress)
 
 
 def _axis_sql(alias: str, af: "AxisFilter | None", params: dict) -> str:
@@ -104,6 +109,22 @@ def _axis_sql(alias: str, af: "AxisFilter | None", params: dict) -> str:
     if af.year_to is not None:
         cl.append(f"COALESCE({p}published_date, {p}created_at::date) <= make_date(:af_yt, 12, 31)")
         params["af_yt"] = af.year_to
+    if af.domain_buckets:
+        cl.append(f"{p}domain_bucket = ANY(:af_db)")
+        params["af_db"] = af.domain_buckets
+    if af.exclude_buckets:
+        cl.append(f"{p}domain_bucket <> ALL(:af_xdb)")
+        params["af_xdb"] = af.exclude_buckets
+    if af.cloud_egress:
+        # 갭2 클라우드 egress allowlist(default-deny). restricted 는 _license_sql 별도 차단.
+        cl.append(
+            f"({p}data_origin = 'external' OR ("
+            f"{p}data_origin = 'work' "
+            f"AND {p}domain_bucket IN ('Engineering','Safety','Law') "
+            f"AND ({p}source_channel IS NULL OR {p}source_channel::text NOT IN ('voice','chat','memo')) "
+            f"AND {p}category::text IS DISTINCT FROM 'memo' "
+            f"AND ({p}user_note IS NULL OR {p}user_note = '')))"
+        )
     return " AND " + " AND ".join(cl)
 
 
@@ -121,7 +142,21 @@ def _license_sql(alias: str) -> str:
     술어 정의 = license_filter.restricted_exclude_sql 공유(digest/briefing/study 풀이와 단일 source).
     """
     from services.search.license_filter import restricted_exclude_sql
-    return " AND " + restricted_exclude_sql(alias)
+    _p = (alias + ".") if alias else ""
+    # ASME clause-KB(379): clause docs (doc_kind='clause') = read/nav/backlink only, excluded from retrieval/digest legs.
+    return " AND " + restricted_exclude_sql(alias) + f" AND {_p}doc_kind = 'standard'"
+
+
+def cloud_eligible_doc_sql(alias: str = "") -> str:
+    """단일 문서가 cloud 소비자(예: Claude/MCP)에게 노출 가능한가 = search retrieval 과
+    동일한 egress allowlist(갭2) + license 제한(B-4) 결합 술어. fetch_document(cloud) 가
+    search 와 byte-동일 게이트를 공유하도록 단일 source([[feedback_structural_integrity_over_path_discipline]]).
+
+    cloud_egress·license leg 모두 bind 파라미터 없는 리터럴 술어라 호출측 추가 params 불요.
+    주의: _license_sql 은 소유자 단건 다운로드엔 미적용(a안)이지만, cloud 노출은 구매 전자책
+    verbatim 누출을 막아야 하므로 여기선 항상 적용 = search 와 동일(local 토큰은 이 게이트 미발동).
+    반환 ' AND (egress allowlist) AND (license)' (alias='' = 컬럼 직접 참조). default-deny."""
+    return _axis_sql(alias, AxisFilter(cloud_egress=True), {}) + _license_sql(alias)
 
 
 # 2단계 gate (R2-B1) — SQL string interpolation 직전 final allowlist.

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,87 @@
+# 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
+    # 실기기 설치(맥/아이폰)는 Xcode 자동서명(본인 Apple ID 팀). 헤드리스 빌드만 CLI 로 CODE_SIGNING_ALLOWED=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/RelatedDocs.svelte

@@ -0,0 +1,45 @@
+<script>
+  // 관련 문서 (유사도) — 문서 레벨 임베딩 KNN. 자기완결: docId 받아 /related 조회.
+  import { onMount } from 'svelte';
+  import { api } from '$lib/api';
+
+  let { documentId } = $props();
+  let items = $state([]);
+  let loaded = $state(false);
+
+  const KIND = { law: '법령', guide: '지침', paper: '논문', standard: '표준', incident: '사례' };
+
+  onMount(async () => {
+    try {
+      const r = await api(`/documents/${documentId}/related?limit=6`);
+      items = r?.related ?? [];
+    } catch (e) { /* silent */ }
+    finally { loaded = true; }
+  });
+</script>
+
+{#if items.length}
+  <div class="rel">
+    <div class="lab">관련 문서</div>
+    {#each items as it (it.id)}
+      <a class="ri" href={`/documents/${it.id}`}>
+        <span class="rt">{it.title}</span>
+        <span class="rm">
+          {#if it.material_type && KIND[it.material_type]}<span class="kind">{KIND[it.material_type]}</span>{/if}
+          <span class="rs">{Math.round((it.sim ?? 0) * 100)}</span>
+        </span>
+      </a>
+    {/each}
+  </div>
+{/if}
+
+<style>
+  .rel { background: var(--surface); border: 1px solid var(--border); border-radius: 14px; padding: 13px; }
+  .lab { font-size: 10.5px; font-weight: 700; color: var(--text-dim); letter-spacing: .4px; margin-bottom: 8px; }
+  .ri { display: flex; align-items: baseline; gap: 8px; padding: 5px 6px; border-radius: 7px; text-decoration: none; }
+  .ri:hover { background: var(--surface-hover, #ecf0e8); }
+  .rt { flex: 1; font-size: 12px; line-height: 1.4; color: var(--text); overflow: hidden; display: -webkit-box; -webkit-line-clamp: 2; -webkit-box-orient: vertical; }
+  .rm { flex-shrink: 0; display: flex; align-items: center; gap: 5px; }
+  .kind { font-size: 9px; font-weight: 700; color: var(--accent-hover, #3d7256); background: #e3efe2; border: 1px solid #cfe3cd; border-radius: 4px; padding: 0 4px; }
+  .rs { font-size: 10.5px; font-family: ui-monospace, Menlo, monospace; color: var(--faint, #9aa090); }
+</style>

frontend/src/lib/components/SlimRail.svelte

@@ -0,0 +1,33 @@
+<script>
+  // 시안 B — 글로벌 네비 슬림 아이콘 레일 (분류 사이드바 접힘 상태). 앱 토큰 사용.
+  import { page } from '$app/stores';
+  import { Home, FolderTree, Newspaper, StickyNote, Hash, GraduationCap, MessageCircle, Inbox, CalendarCheck } from 'lucide-svelte';
+
+  const items = [
+    { href: '/', icon: Home, label: '홈', exact: true },
+    { href: '/library', icon: FolderTree, label: '문서' },
+    { href: '/news', icon: Newspaper, label: '뉴스' },
+    { href: '/memos', icon: StickyNote, label: '메모' },
+    { href: '/clause', icon: Hash, label: '절' },
+    { href: '/events', icon: CalendarCheck, label: '일정' },
+    { href: '/study', icon: GraduationCap, label: '공부' },
+    { href: '/chat', icon: MessageCircle, label: '이드' },
+    { href: '/inbox', icon: Inbox, label: '편지함' },
+  ];
+  let path = $derived($page.url.pathname);
+  const active = (it) => (it.exact ? path === it.href : path.startsWith(it.href));
+</script>
+
+<nav class="flex flex-col items-center gap-1 py-2 h-full overflow-y-auto bg-sidebar">
+  {#each items as it (it.href)}
+    {@const Icon = it.icon}
+    <a
+      href={it.href}
+      title={it.label}
+      class="flex flex-col items-center justify-center gap-0.5 w-12 h-[46px] rounded-lg text-dim hover:bg-surface-hover hover:text-accent transition-colors {active(it) ? 'bg-surface-active text-accent font-semibold' : ''}"
+    >
+      <Icon size={17} strokeWidth={1.75} />
+      <span class="text-[8.5px] leading-none tracking-tight">{it.label}</span>
+    </a>
+  {/each}
+</nav>

frontend/src/routes/+layout.svelte

@@ -11,6 +11,7 @@
   import { queueOverview } from '$lib/stores/queueOverview';
   import { MACHINE_STATE_LABEL, machineChipClass } from '$lib/utils/queueDisplay';
   import Sidebar from '$lib/components/Sidebar.svelte';
+  import SlimRail from '$lib/components/SlimRail.svelte';
   import SystemStatusDot from '$lib/components/SystemStatusDot.svelte';
   import QueueDrawer from '$lib/components/QueueDrawer.svelte';
   import QuickMemoButton from '$lib/components/QuickMemoButton.svelte';
@@ -21,7 +22,7 @@
   const PUBLIC_PATHS = ['/login', '/setup', '/__styleguide'];
   const NO_CHROME_PATHS = ['/login', '/setup', '/__styleguide'];
   // /news = 풀스크린 브리핑 → 데스크탑 상시 사이드바 없음
-  const NO_SIDEBAR_PATHS = ['/news'];
+  const NO_SIDEBAR_PATHS = ['/news', '/book'];  // /book = 책 몰입(글로벌 분류 트리 숨김, 상단 네비 유지)
 
   // toast 의미 토큰 매핑 (A-8 B3)
   const TOAST_CLASS = {
@@ -198,8 +199,8 @@
       <!-- 메인: 데스크탑 상시 사이드바 + 콘텐츠 -->
       <div class="flex-1 min-h-0 flex">
         {#if showSidebar}
-          <aside class="hidden lg:block shrink-0 overflow-hidden transition-[width] duration-200 ease-out {sidebarCollapsed ? 'w-0 border-r-0' : 'w-sidebar border-r border-default'}">
-            <Sidebar />
+          <aside class="hidden lg:block shrink-0 overflow-hidden transition-[width] duration-200 ease-out {sidebarCollapsed ? 'w-14 border-r border-default' : 'w-sidebar border-r border-default'}">
+            {#if sidebarCollapsed}<SlimRail />{:else}<Sidebar />{/if}
           </aside>
         {/if}
         <main class="flex-1 min-w-0 overflow-auto">

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

@@ -0,0 +1,281 @@
+<script>
+  // ASME/법령 절-KB — 코드북·공부 리더 (r2). parent 표준/법령을 한 권의 책처럼.
+  // 좌 인덱스(Part/章→절/조) · 중 본문(MarkdownDoc=공식·표·이미지) · breadcrumb·이전다음·양방향 백링크.
+  import { onMount, tick } from 'svelte';
+  import { page } from '$app/stores';
+  import { goto } from '$app/navigation';
+  import { api } from '$lib/api';
+  import MarkdownDoc from '$lib/components/MarkdownDoc.svelte';
+
+  let parentId = $state(null);
+  let parentTitle = $state('');
+  let clauses = $state([]);
+  let selectedId = $state(null);
+  let clauseDoc = $state(null);
+  let links = $state(null);
+  let expanded = $state({});
+  let loading = $state(false);
+  let q = $state('');
+
+  // 공부도구 (노트/형광펜/암기카드) — clause_study
+  let studyItems = $state([]);
+  let studyOpen = $state(false);
+  let noteDraft = $state('');
+  const KLABEL = { note: '노트', highlight: '형광펜', card: '암기카드' };
+  async function loadStudy(id) {
+    try { const r = await api(`/documents/${id}/study`); studyItems = r?.items ?? []; }
+    catch { studyItems = []; }
+  }
+  async function addStudy(kind, payload) {
+    if (!selectedId) return;
+    try { await api(`/documents/${selectedId}/study`, { method: 'POST', body: JSON.stringify({ kind, payload }) }); await loadStudy(selectedId); }
+    catch (e) { console.warn(e); }
+  }
+  function selText() { return (typeof window !== 'undefined' && window.getSelection ? window.getSelection().toString() : '').trim(); }
+  function addNote() { const t = noteDraft.trim(); if (!t) return; addStudy('note', { text: t }); noteDraft = ''; }
+  function addHighlight() { const s = selText(); if (!s) { studyOpen = true; alert('본문에서 형광펜 칠할 부분을 먼저 드래그하세요'); return; } addStudy('highlight', { text: s }); studyOpen = true; }
+  function addCard() {
+    const s = selText();
+    const code = links?.clause_code ?? selMeta?.clause_code ?? '';
+    addStudy('card', { cue: `${code} ${strip(clauseDoc?.title, code)}`.trim(), fact: s || (clauseDoc?.md_content ?? clauseDoc?.extracted_text ?? '').replace(/[#*>]/g, '').slice(0, 280).trim() });
+    studyOpen = true;
+  }
+  async function delStudy(id) {
+    try { await api(`/documents/${selectedId}/study/${id}`, { method: 'DELETE' }); await loadStudy(selectedId); } catch {}
+  }
+
+  let parts = $derived.by(() => {
+    const out = [], idx = {};
+    for (const c of clauses) {
+      const p = c.clause_part || '·';
+      if (!(p in idx)) { idx[p] = out.length; out.push({ part: p, items: [] }); }
+      out[idx[p]].items.push(c);
+    }
+    return out;
+  });
+  let visibleParts = $derived.by(() => {
+    const term = q.trim().toLowerCase();
+    if (!term) return parts;
+    return parts.map(g => ({ part: g.part, items: g.items.filter(c =>
+      (c.clause_code || '').toLowerCase().includes(term) || (c.title || '').toLowerCase().includes(term)) }))
+      .filter(g => g.items.length);
+  });
+  let selMeta = $derived(clauses.find((c) => c.id === selectedId) || null);
+  const strip = (t, c) => (t || '').replace(c || '', '').replace(/^[(\s)]+|[(\s)]+$/g, '').trim();
+
+  async function loadBook() {
+    const r = await api(`/documents/${parentId}/clauses`);
+    parentTitle = r?.parent_title ?? '';
+    clauses = r?.clauses ?? [];
+    const e = {};
+    for (const c of clauses) e[c.clause_part || '·'] = true;
+    expanded = e;
+  }
+  async function loadClause(id) {
+    if (!id) return;
+    loading = true;
+    selectedId = id;
+    try {
+      const [d, l] = await Promise.all([api(`/documents/${id}`), api(`/documents/${id}/backlinks`)]);
+      clauseDoc = d; links = l;
+      loadStudy(id);
+      const sel = clauses.find((c) => c.id === id);
+      if (sel) expanded = { ...expanded, [sel.clause_part || '·']: true };
+      goto(`/book/${parentId}?c=${id}`, { replaceState: true, keepFocus: true, noScroll: true });
+      await tick(); window.scrollTo({ top: 0 });
+    } finally { loading = false; }
+  }
+  onMount(async () => {
+    parentId = Number($page.params.id);
+    await loadBook();
+    const c = Number($page.url.searchParams.get('c'));
+    await loadClause(c && clauses.find((x) => x.id === c) ? c : clauses[0]?.id);
+  });
+</script>
+
+<div class="book">
+  <!-- top bar -->
+  <div class="bar">
+    <span class="brand">절-KB</span>
+    <span class="crumbs">{parentTitle} {#if selMeta}<b class="sep">›</b> {selMeta.clause_part} <b class="sep">›</b> <b>{links?.clause_code ?? selMeta.clause_code}</b>{/if}</span>
+    <div class="search"><input placeholder="절·조 번호 또는 키워드" bind:value={q} /></div>
+    <div class="tools"><span class="tool on">읽기</span><span class="tool">형광펜</span><span class="tool">노트</span><span class="tool">암기카드</span></div>
+  </div>
+
+  <div class="main">
+    <!-- left index -->
+    <aside class="idx">
+      <a class="btitle" href={`/documents/${parentId}`}>{parentTitle || '표준'}</a>
+      <div class="bmeta">절 {clauses.length} · 한 권의 책처럼 탐색</div>
+      {#each visibleParts as g (g.part)}
+        <div class="parttab" role="button" tabindex="0" onclick={() => (expanded = { ...expanded, [g.part]: !expanded[g.part] })}>
+          <span class="bar2"></span><span class="pname">{g.part}</span><span class="ct">{g.items.length}</span>
+        </div>
+        {#if expanded[g.part] || q.trim()}
+          {#each g.items as c (c.id)}
+            <div class="ci" class:on={c.id === selectedId} role="button" tabindex="0" onclick={() => loadClause(c.id)}>
+              <span class="no">{c.clause_code}</span><span class="tt">{strip(c.title, c.clause_code)}</span>
+            </div>
+          {/each}
+        {/if}
+      {/each}
+    </aside>
+
+    <!-- reader -->
+    <section class="read">
+      <div class="col">
+        {#if clauseDoc}
+          <div class="studybar">
+            <button class="sbtn" title="선택 형광펜" onclick={addHighlight}>▰</button>
+            <button class="sbtn" class:on={studyOpen} title="노트/공부" onclick={() => (studyOpen = !studyOpen)}>✎</button>
+            <button class="sbtn" title="암기카드 추가" onclick={addCard}>＋</button>
+            {#if studyItems.length}<span class="scount">{studyItems.length}</span>{/if}
+          </div>
+          <div class="kicker"><span class="pth">{selMeta?.clause_part}</span></div>
+          <div class="h-no">{links?.clause_code ?? selMeta?.clause_code}</div>
+          <h1 class="h-title">{strip(clauseDoc.title, links?.clause_code ?? '')}</h1>
+
+          <div class="flow">
+            <button class="fl" disabled={!links?.prev} onclick={() => loadClause(links?.prev?.id)}>← {links?.prev?.clause_code ?? ''}</button>
+            <button class="fl next" disabled={!links?.next} onclick={() => loadClause(links?.next?.id)}>{links?.next?.clause_code ?? ''} →</button>
+          </div>
+
+          {#key clauseDoc.id}
+            <div class="docbody">
+              <MarkdownDoc documentId={clauseDoc.id} mdContent={clauseDoc.md_content ?? clauseDoc.extracted_text} mdStatus={null} class="prose prose-base max-w-none" />
+            </div>
+          {/key}
+
+          {#if links && (links.forward.length || links.back.length)}
+            <section class="conn">
+              {#if links.forward.length}
+                <div><h4>이 절이 참조 <span>{links.forward.length}</span></h4>
+                  <div class="chiprow">{#each links.forward as f}
+                    {#if f.doc_id}<button class="ref" onclick={() => loadClause(f.doc_id)}>{f.code}</button>
+                    {:else}<span class="ref dg" title="외부/미분해">{f.code}</span>{/if}
+                  {/each}</div></div>
+              {/if}
+              {#if links.back.length}
+                <div><h4>이 절을 참조 <span>{links.back.length}</span></h4>
+                  <div class="chiprow">{#each links.back as b}<button class="ref" onclick={() => loadClause(b.doc_id)}>{b.code}</button>{/each}</div></div>
+              {/if}
+            </section>
+          {/if}
+
+          {#if studyOpen}
+            <section class="study">
+              <div class="slab">공부 — 노트 · 형광펜 · 암기카드{#if studyItems.length} <span>{studyItems.length}</span>{/if}</div>
+              <div class="noteadd">
+                <textarea bind:value={noteDraft} placeholder="이 절에 노트…" rows="2"></textarea>
+                <button class="nbtn" onclick={addNote}>노트 저장</button>
+              </div>
+              {#if studyItems.length}
+                <ul class="slist">
+                  {#each studyItems as it (it.id)}
+                    <li class="sitem">
+                      <span class="skind k-{it.kind}">{KLABEL[it.kind] ?? it.kind}</span>
+                      <span class="stext">{it.payload?.text ?? it.payload?.cue ?? ''}</span>
+                      <button class="sdel" title="삭제" onclick={() => delStudy(it.id)}>×</button>
+                    </li>
+                  {/each}
+                </ul>
+              {:else}
+                <p class="shint">본문을 드래그한 뒤 형광펜(▰)/암기카드(＋), 또는 위에 노트를 적으세요.</p>
+              {/if}
+            </section>
+          {/if}
+
+          <div class="pager">
+            <button class="pg" disabled={!links?.prev} onclick={() => loadClause(links?.prev?.id)}>
+              <div class="d">← 이전</div><div class="t"><span class="pno">{links?.prev?.clause_code ?? '—'}</span> {strip(links?.prev?.title, links?.prev?.clause_code)}</div></button>
+            <button class="pg next" disabled={!links?.next} onclick={() => loadClause(links?.next?.id)}>
+              <div class="d">다음 →</div><div class="t"><span class="pno">{links?.next?.clause_code ?? '—'}</span> {strip(links?.next?.title, links?.next?.clause_code)}</div></button>
+          </div>
+        {:else}
+          <p class="empty">{loading ? '불러오는 중…' : '왼쪽에서 절을 선택하세요'}</p>
+        {/if}
+      </div>
+    </section>
+  </div>
+</div>
+
+<style>
+  :global(body) { background: var(--bg); }
+  .book { --paper:#fbfcf9; --serif:"Iowan Old Style","Palatino Linotype","Noto Serif KR",Georgia,serif;
+    display:flex; flex-direction:column; min-height:100vh; }
+  .bar { display:flex; align-items:center; gap:14px; height:50px; padding:0 18px; background:var(--paper); border-bottom:1px solid var(--border); }
+  .brand { font-weight:700; font-size:13.5px; color:var(--text); }
+  .crumbs { color:var(--text-dim); font-size:12.5px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; max-width:46%; }
+  .crumbs b { color:var(--text); font-weight:600; } .crumbs .sep { color:#c8d6c0; margin:0 5px; }
+  .search { margin-left:auto; }
+  .search input { width:280px; background:var(--surface); border:1px solid var(--border); border-radius:9px; padding:7px 12px; font-size:13px; color:var(--text); outline:none; }
+  .search input:focus { border-color:var(--accent); }
+  .tools { display:flex; gap:2px; }
+  .tool { font-size:12px; color:var(--text-dim); padding:6px 10px; border-radius:8px; border:1px solid transparent; cursor:pointer; }
+  .tool:hover { background:var(--surface); } .tool.on { background:#ecf0e8; border-color:var(--border); color:var(--accent-hover); font-weight:600; }
+
+  .main { display:flex; align-items:flex-start; flex:1; }
+  .idx { width:264px; flex-shrink:0; align-self:stretch; border-right:1px solid var(--border);
+    background:linear-gradient(180deg,#f6f8f3,#f1f4ec); padding:16px 10px 30px 16px; position:sticky; top:0; max-height:100vh; overflow:auto; }
+  .btitle { display:block; font-family:var(--serif); font-size:15.5px; font-weight:600; color:var(--text); text-decoration:none; line-height:1.32; }
+  .btitle:hover { text-decoration:underline; }
+  .bmeta { font-size:11px; color:#9aa090; margin:3px 0 14px; }
+  .parttab { display:flex; align-items:center; gap:8px; margin:11px 0 4px; padding:3px 4px; border-radius:6px; cursor:pointer;
+    font-size:11px; font-weight:700; letter-spacing:.5px; color:var(--text-dim); text-transform:uppercase; }
+  .parttab:hover { background:#fff; } .parttab .bar2 { width:3px; height:12px; border-radius:2px; background:var(--domain-engineering); }
+  .parttab .pname { flex:1; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; } .parttab .ct { color:#9aa090; font-weight:600; letter-spacing:0; }
+  .ci { display:flex; gap:9px; align-items:baseline; padding:4px 9px; border-radius:7px; cursor:pointer; line-height:1.4; }
+  .ci .no { font-family:ui-monospace,Menlo,monospace; font-size:11px; color:var(--accent); font-weight:600; min-width:52px; white-space:nowrap; }
+  .ci .tt { font-size:12.5px; color:var(--text-dim); overflow:hidden; text-overflow:ellipsis; }
+  .ci:hover { background:#fff; }
+  .ci.on { background:#fff; box-shadow:inset 3px 0 0 var(--accent), 0 1px 2px rgba(35,41,31,.05); }
+  .ci.on .no { color:var(--accent-hover); font-weight:700; } .ci.on .tt { color:var(--text); font-weight:600; }
+
+  .read { flex:1; min-width:0; padding:34px 40px 80px; }
+  .col { max-width:680px; margin:0 auto; position:relative; }
+  .studybar { position:absolute; right:-30px; top:4px; display:flex; flex-direction:column; gap:6px; }
+  .sbtn { width:34px; height:34px; border-radius:9px; border:1px solid var(--border); background:var(--paper); color:var(--text-dim); font-size:13px; cursor:pointer; }
+  .sbtn:hover { background:var(--surface); color:var(--accent-hover); }
+  .kicker { margin-bottom:5px; } .kicker .pth { font-size:11.5px; color:#9aa090; font-weight:600; letter-spacing:.3px; }
+  .h-no { font-family:ui-monospace,Menlo,monospace; font-size:13px; color:var(--accent); font-weight:700; letter-spacing:.5px; }
+  .h-title { font-family:var(--serif); font-size:26px; line-height:1.24; font-weight:600; margin:2px 0 14px; letter-spacing:-.2px; color:var(--text); }
+  .flow { display:flex; justify-content:space-between; gap:8px; margin-bottom:18px; }
+  .flow .fl { font-size:11.5px; color:var(--text-dim); background:var(--surface); border:1px solid var(--border); border-radius:8px; padding:5px 11px; cursor:pointer; }
+  .flow .fl:hover:not(:disabled) { background:#ecf0e8; } .flow .fl:disabled { opacity:.35; cursor:default; }
+  .docbody { font-size:15.5px; }
+  .docbody :global(.prose) { color:#2a3024; line-height:1.78; }
+  .docbody :global(.prose h1), .docbody :global(.prose h2), .docbody :global(.prose h3) { font-family:var(--serif); }
+  .docbody :global(a) { color:var(--accent-hover); }
+  .conn { margin-top:34px; padding-top:18px; border-top:1px solid var(--border); display:grid; grid-template-columns:1fr 1fr; gap:22px; }
+  .conn h4 { font-size:11px; font-weight:700; color:var(--text-dim); letter-spacing:.4px; margin:0 0 9px; } .conn h4 span { color:#9aa090; font-weight:500; }
+  .chiprow { display:flex; flex-wrap:wrap; gap:5px; }
+  .ref { font-family:ui-monospace,Menlo,monospace; font-size:11.5px; font-weight:600; color:var(--accent-hover); background:#eef4ec; border:1px solid #d9e6d8; border-radius:6px; padding:2px 8px; cursor:pointer; }
+  .ref:hover { background:#e2efe0; } .ref.dg { color:#9aa090; background:var(--surface); border-color:var(--border); cursor:default; }
+  .pager { display:flex; gap:10px; margin-top:30px; }
+  .pg { flex:1; text-align:left; border:1px solid var(--border); border-radius:11px; padding:11px 14px; background:var(--paper); cursor:pointer; }
+  .pg.next { text-align:right; } .pg:hover:not(:disabled) { border-color:#cfd7c6; background:#fff; } .pg:disabled { opacity:.4; cursor:default; }
+  .pg .d { font-size:10.5px; color:#9aa090; } .pg .t { font-size:12.5px; color:var(--text-dim); font-weight:600; margin-top:1px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+  .pg .pno { font-family:ui-monospace,Menlo,monospace; color:var(--accent); }
+  .empty { color:#9aa090; text-align:center; padding:80px 0; }
+  .sbtn.on { background:#ecf0e8; color:var(--accent-hover,#3d7256); border-color:var(--border); }
+  .scount { font-size:9px; font-weight:700; color:#fff; background:var(--accent,#4f8a6b); border-radius:8px; padding:1px 5px; text-align:center; }
+  .study { margin-top:24px; padding:14px; border:1px solid var(--border); border-radius:12px; background:var(--surface); }
+  .slab { font-size:11px; font-weight:700; color:var(--text-dim); letter-spacing:.3px; margin-bottom:9px; }
+  .slab span { color:var(--accent-hover,#3d7256); }
+  .noteadd { display:flex; gap:8px; align-items:flex-end; margin-bottom:10px; }
+  .noteadd textarea { flex:1; resize:vertical; border:1px solid var(--border); border-radius:8px; padding:7px 9px; font-size:12.5px; font-family:inherit; color:var(--text); background:var(--paper,#fbfcf9); outline:none; }
+  .noteadd textarea:focus { border-color:var(--accent); }
+  .nbtn { flex-shrink:0; font-size:12px; color:#fff; background:var(--accent,#4f8a6b); border:0; border-radius:8px; padding:8px 12px; cursor:pointer; }
+  .nbtn:hover { background:var(--accent-hover,#3d7256); }
+  .slist { list-style:none; margin:0; padding:0; display:flex; flex-direction:column; gap:5px; }
+  .sitem { display:flex; align-items:baseline; gap:8px; padding:6px 8px; border-radius:8px; background:var(--paper,#fbfcf9); border:1px solid var(--border); }
+  .skind { flex-shrink:0; font-size:9.5px; font-weight:700; border-radius:4px; padding:1px 6px; }
+  .k-note { color:#3d7256; background:#e3efe2; border:1px solid #cfe3cd; }
+  .k-highlight { color:#8a6306; background:#faf3e2; border:1px solid #ecdca3; }
+  .k-card { color:#1d4ed8; background:#eef4fc; border:1px solid #d7e4f7; }
+  .stext { flex:1; font-size:12px; line-height:1.5; color:var(--text); white-space:pre-wrap; word-break:break-word; }
+  .sdel { flex-shrink:0; background:none; border:0; color:var(--faint,#9aa090); cursor:pointer; font-size:14px; }
+  .sdel:hover { color:var(--error,#c0392b); }
+  .shint { font-size:11.5px; color:var(--faint,#9aa090); margin:0; }
+  @media(max-width:820px){ .idx{display:none} .read{padding:24px 18px} .conn{grid-template-columns:1fr} .studybar{position:static;flex-direction:row} .crumbs{max-width:30%} .search input{width:150px} }
+</style>

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

@@ -16,6 +16,7 @@
   import Skeleton from '$lib/components/ui/Skeleton.svelte';
   import HandwriteCanvas from '$lib/components/HandwriteCanvas.svelte';
   import MarkdownDoc from '$lib/components/MarkdownDoc.svelte';
+  import RelatedDocs from '$lib/components/RelatedDocs.svelte';
   import { renderDocMarkdown } from '$lib/utils/docMarkdown';
   import MarkdownStatusBadge from '$lib/components/MarkdownStatusBadge.svelte';
   import NoteEditor from '$lib/components/editors/NoteEditor.svelte';
@@ -321,6 +322,7 @@
 <!-- ════ 우 슬림 레일 (시안 카드 스타일) ════ -->
 {#snippet rail()}
   <div style="display:flex;flex-direction:column;gap:11px;font-size:14px;">
+    <RelatedDocs documentId={doc.id} />
     {#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>

migrations/379_asme_clause_kb.sql

@@ -0,0 +1,37 @@
+-- 379_asme_clause_kb.sql
+-- ASME 절-지식베이스: 절 = 개별 documents 행(parent_id) + 절↔절 백링크 + 태깅 (additive, idempotent)
+-- 검색 무접촉: 절 doc 은 embedding NULL(벡터 제외) + doc_kind='clause'(retrieval doc-leg 필터로 제외).
+
+ALTER TABLE documents
+  ADD COLUMN IF NOT EXISTS parent_id    bigint REFERENCES documents(id),
+  ADD COLUMN IF NOT EXISTS doc_kind     text NOT NULL DEFAULT 'standard',
+  ADD COLUMN IF NOT EXISTS clause_code  text,
+  ADD COLUMN IF NOT EXISTS clause_part  text,
+  ADD COLUMN IF NOT EXISTS clause_order int;
+
+CREATE INDEX IF NOT EXISTS idx_documents_parent_id   ON documents(parent_id) WHERE parent_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_documents_doc_kind    ON documents(doc_kind);
+CREATE INDEX IF NOT EXISTS idx_documents_clause_code ON documents(clause_code) WHERE clause_code IS NOT NULL;
+
+-- 절↔절 백링크 (dangling 허용: dst_doc_id nullable)
+CREATE TABLE IF NOT EXISTS clause_links (
+  id          bigserial PRIMARY KEY,
+  src_doc_id  bigint NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+  dst_code    text   NOT NULL,
+  dst_doc_id  bigint REFERENCES documents(id) ON DELETE SET NULL,
+  anchor      text,
+  ctx         text,
+  char_off    int
+);
+CREATE INDEX IF NOT EXISTS idx_clause_links_src     ON clause_links(src_doc_id);
+CREATE INDEX IF NOT EXISTS idx_clause_links_dst     ON clause_links(dst_doc_id) WHERE dst_doc_id IS NOT NULL;
+CREATE INDEX IF NOT EXISTS idx_clause_links_dstcode ON clause_links(dst_code);
+
+-- 태깅 (Part 자동 + 주제)
+CREATE TABLE IF NOT EXISTS document_tags (
+  doc_id    bigint NOT NULL REFERENCES documents(id) ON DELETE CASCADE,
+  tag       text   NOT NULL,
+  tag_kind  text   NOT NULL DEFAULT 'topic',
+  PRIMARY KEY (doc_id, tag)
+);
+CREATE INDEX IF NOT EXISTS idx_document_tags_tag ON document_tags(tag);

migrations/380_clause_study.sql

@@ -0,0 +1,9 @@
+-- 380_clause_study.sql — 절-문서 공부도구(노트/형광펜/암기카드) 저장. FK 없음(documents 락 회피).
+CREATE TABLE IF NOT EXISTS clause_study (
+  id         bigserial PRIMARY KEY,
+  doc_id     bigint NOT NULL,
+  kind       text   NOT NULL,            -- 'note' | 'highlight' | 'card'
+  payload    jsonb  NOT NULL DEFAULT '{}',
+  created_at timestamptz NOT NULL DEFAULT now()
+);
+CREATE INDEX IF NOT EXISTS idx_clause_study_doc ON clause_study(doc_id, kind);

scripts/asme_backlinks_persist.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""ASME clause-KB backlinks: resolve clause-id mentions in each clause doc -> clause_links.
+dst resolved to the clause doc of the same parent (top-level code); sub-code mention -> anchor;
+unresolved (cross-standard / material spec not split) -> dangling (dst_doc_id NULL).
+Idempotent per parent. Usage: python3 asme_backlinks_persist.py <parent_id> [--commit]
+"""
+import asyncio, os, re, sys
+
+MENTION_RE = re.compile(r'(?<![A-Za-z0-9])([A-Z]{1,4}-\d+(?:\.\d+)*[A-Za-z]?)(?![A-Za-z0-9])')
+def top(code): return re.match(r'^[A-Z]{1,4}-\d+', code).group(0)
+
+async def main():
+    parent = int(sys.argv[1]); commit = '--commit' in sys.argv
+    import asyncpg
+    conn = await asyncpg.connect(os.environ['DATABASE_URL'].replace('+asyncpg', ''))
+    docs = await conn.fetch("SELECT id, clause_code, md_content FROM documents "
+                            "WHERE parent_id=$1 AND doc_kind='clause' ORDER BY clause_order", parent)
+    code2id = {d['clause_code']: d['id'] for d in docs}
+    edges = []          # (src_id, dst_code, dst_doc_id, anchor, ctx, char_off)
+    resolved = dangling = 0
+    for d in docs:
+        body = d['md_content']; src_top = d['clause_code']
+        seen = set()
+        for m in MENTION_RE.finditer(body):
+            code = m.group(1); t = top(code)
+            if t == src_top: continue                 # self-reference
+            if (d['id'], code) in seen: continue      # dedup per (src,dst_code)
+            seen.add((d['id'], code))
+            dst_id = code2id.get(t)                    # resolve to same-parent clause doc
+            anchor = code.lower().replace('.', '-') if code != t else None
+            off = m.start()
+            ctx = re.sub(r'\s+', ' ', body[max(0, off-50):off+50]).strip()
+            edges.append((d['id'], code, dst_id, anchor, ctx, off))
+            if dst_id: resolved += 1
+            else: dangling += 1
+    print(f"parent={parent} clause_docs={len(docs)} edges={len(edges)} resolved={resolved} dangling={dangling}")
+    # top referenced clauses
+    from collections import Counter
+    tgt = Counter(top(e[1]) for e in edges if e[2])
+    print("most-referenced:", tgt.most_common(8))
+    if not commit:
+        print("DRY-RUN. pass --commit to persist."); await conn.close(); return
+    async with conn.transaction():
+        ids = [d['id'] for d in docs]
+        await conn.execute("DELETE FROM clause_links WHERE src_doc_id = ANY($1::bigint[])", ids)
+        await conn.executemany(
+            "INSERT INTO clause_links(src_doc_id,dst_code,dst_doc_id,anchor,ctx,char_off) "
+            "VALUES ($1,$2,$3,$4,$5,$6)", edges)
+        n = await conn.fetchval("SELECT count(*) FROM clause_links WHERE src_doc_id = ANY($1::bigint[])", ids)
+        print(f"COMMITTED: {n} clause_links for parent {parent}")
+    await conn.close()
+
+asyncio.run(main())

scripts/asme_clause_persist.py

@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+"""ASME clause-KB persist (v2: over-CAP pagination). Split a parent standard into per-clause
+documents (A-granularity); over-CAP clause bodies are paginated into readable page-docs.
+Idempotent per parent. doc_kind='clause', embedding NULL (search-excluded), parent_id=<parent>.
+Usage: python3 asme_clause_persist.py <parent_id> [--commit]
+"""
+import asyncio, os, re, sys, hashlib, statistics
+
+CAP = 12000; PAGE_TOK = 11000
+EN, KO = 0.217, 0.529
+LINE_RE = re.compile(r'^([ \t#>*]{0,8})([A-Z]{2,4}-\d+(?:\.\d+)*[A-Za-z]?)(.*)$')
+MENTION_RE = re.compile(r'(?<![A-Za-z0-9])([A-Z]{1,4}-\d+(?:\.\d+)*[A-Za-z]?)(?![A-Za-z0-9])')
+EXACT_TOP = re.compile(r'^[A-Z]{2,4}-\d+$')
+TITLE_AFTER = re.compile(r'^[\s.]*[A-Z(]')
+REF_LEAD = re.compile(r'^[\s.]*(and|or|to|of|in|on|the|as|is|are|shall|through|per|see|with|'
+                      r'for|by|that|which|such|또는|및|등|의|은|는|에|을|를|과|와)\b', re.I)
+
+def tok(s):
+    ko = sum(1 for c in s if '가' <= c <= '힣'); return int((len(s)-ko)*EN + ko*KO)
+
+def clean_title(rest):
+    t = re.sub(r'<sup>ð</sup>\s*\**\d*\**\s*<sup>Þ</sup>', '', rest)
+    t = re.sub(r'ð\**\d*\**Þ', '', t)
+    t = t.replace('**', '').replace('#', '')
+    return re.sub(r'\s+', ' ', t).strip(' *:—-')
+
+def is_header(markup, rest):
+    if '#' in markup or '*' in markup: return True
+    rs = rest.strip()
+    if rs == '': return True
+    if REF_LEAD.match(rest): return False
+    if rs[0] in ',;.)': return False
+    if '가' <= rs[0] <= '힣': return False
+    if rs[0].islower(): return False
+    return bool(TITLE_AFTER.match(rs))
+
+def paginate(body):
+    """split an over-CAP body into <=MAX_PAGES line-aligned pages of ~PAGE_TOK tokens."""
+    pages, cur, ct = [], [], 0
+    for ln in body.split('\n'):
+        lt = tok(ln) + 1
+        if ct + lt > PAGE_TOK and cur:
+            pages.append('\n'.join(cur)); cur, ct = [ln], lt
+        else:
+            cur.append(ln); ct += lt
+    if cur: pages.append('\n'.join(cur))
+    return pages
+
+def build_clauses(text):
+    lines = text.split('\n'); off = []; a = 0
+    for ln in lines: off.append(a); a += len(ln) + 1
+    bounds = []; seen = set()
+    for i, ln in enumerate(lines):
+        m = LINE_RE.match(ln)
+        if not m: continue
+        markup, code, rest = m.group(1), m.group(2), m.group(3)
+        if not EXACT_TOP.match(code): continue
+        if not is_header(markup, rest): continue
+        if code in seen: continue
+        seen.add(code); bounds.append((off[i], code, clean_title(rest)))
+    raw = []
+    for idx, (start, code, title) in enumerate(bounds):
+        end = bounds[idx+1][0] if idx+1 < len(bounds) else len(text)
+        body = text[start:end]
+        part = re.match(r'^[A-Z]{2,4}', code).group(0)
+        links = sorted(set(re.match(r'^[A-Z]{1,4}-\d+', mm).group(0)
+                           for mm in MENTION_RE.findall(body)) - {code})
+        raw.append(dict(code=code, part=part, title=(code + (' ' + title if title else '')),
+                        body=body, tok=tok(body), links=links))
+    # expand over-CAP into pages; assign running clause_order
+    final, order = [], 0
+    for c in raw:
+        if c['tok'] <= CAP:
+            final.append({**c, 'order': order}); order += 1; continue
+        pages = paginate(c['body'])
+        for pi, pb in enumerate(pages):
+            code = c['code'] if pi == 0 else f"{c['code']}·p{pi+1}"
+            title = c['title'] if pi == 0 else f"{c['title']} (페이지 {pi+1}/{len(pages)})"
+            final.append(dict(code=code, part=c['part'], order=order, title=title,
+                              body=pb, tok=tok(pb), links=c['links'] if pi == 0 else []))
+            order += 1
+    return final
+
+async def main():
+    parent = int(sys.argv[1]); commit = '--commit' in sys.argv
+    import asyncpg
+    conn = await asyncpg.connect(os.environ['DATABASE_URL'].replace('+asyncpg', ''))
+    row = await conn.fetchrow("SELECT md_content, ai_domain, data_origin FROM documents WHERE id=$1", parent)
+    if not row: print(f"parent {parent} not found"); return
+    clauses = build_clauses(row['md_content'])
+    toks = [c['tok'] for c in clauses]
+    over = [c for c in clauses if c['tok'] > CAP]
+    print(f"parent={parent} clause_docs={len(clauses)} median_tok={int(statistics.median(toks))} "
+          f"max_tok={max(toks)} over_cap_remaining={len(over)}")
+    if over: print("still over-CAP:", [f"{c['code']}:{c['tok']}t" for c in over])
+    if not commit:
+        print("DRY-RUN. pass --commit to persist."); await conn.close(); return
+    async with conn.transaction():
+        deld = await conn.execute("DELETE FROM documents WHERE parent_id=$1 AND doc_kind='clause'", parent)
+        print("deleted prior:", deld)
+        for c in clauses:
+            fh = hashlib.sha256(f"{parent}:{c['code']}:{c['body']}".encode()).hexdigest()
+            cid = await conn.fetchval("""
+                INSERT INTO documents
+                  (file_format, file_hash, title, md_content, parent_id, doc_kind,
+                   clause_code, clause_part, clause_order, ai_domain, data_origin,
+                   md_status, review_status, conversion_status, preview_status)
+                VALUES ('md',$1,$2,$3,$4,'clause',$5,$6,$7,$8,$9,'success','approved','none','none')
+                RETURNING id
+            """, fh, c['title'], c['body'], parent, c['code'], c['part'], c['order'],
+                 row['ai_domain'], row['data_origin'] or 'external')
+            await conn.execute("INSERT INTO document_tags(doc_id,tag,tag_kind) VALUES ($1,$2,'part') "
+                               "ON CONFLICT DO NOTHING", cid, c['part'])
+        n = await conn.fetchval("SELECT count(*) FROM documents WHERE parent_id=$1 AND doc_kind='clause'", parent)
+        print(f"COMMITTED: {n} clause docs for parent {parent}")
+    await conn.close()
+
+asyncio.run(main())

scripts/guide_clause_persist.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""기술지침(KOSHA guide) 절-KB persist: 번호섹션(# 1. 목적 / ## 4.1) 단위 분해 + 제본.
+ASME/법령과 동일 clause-KB 모델(doc_kind='clause', parent_id=지침, 검색제외, /book 리더 공용).
+Usage: python3 guide_clause_persist.py <id|all> [--commit]
+"""
+import asyncio, os, re, sys, hashlib, statistics
+
+CAP = 12000; PAGE_TOK = 11000
+EN, KO = 0.217, 0.529
+# 번호섹션 헤더: '# 1. 목 적', '## 4.1 누출...'  (번호 1~3자리=연도(4자리) 배제)
+ART_RE = re.compile(r'^#{1,6}\s*(\d{1,3}(?:\.\d{1,3})*)\.?\s+(\S.*)$')
+TOP_RE = re.compile(r'^\d{1,3}$')
+# 외부 표준/법규 참조(대부분 dangling): ASME B16.5 · KS B 1501 · 규칙 제N조
+EXT_RE = re.compile(r'(ASME\s+[A-Z][0-9.]+|KS\s+[A-Z]\s*[0-9]+|ISO\s+[0-9]+|제\d+조)')
+
+def tok(s):
+    ko = sum(1 for c in s if '가' <= c <= '힣'); return int((len(s)-ko)*EN + ko*KO)
+
+def build_sections(text):
+    lines = text.split('\n'); off = []; a = 0
+    for ln in lines: off.append(a); a += len(ln) + 1
+    bounds = []; seen = set()
+    for i, ln in enumerate(lines):
+        m = ART_RE.match(ln)
+        if not m: continue
+        code, name = m.group(1), m.group(2).strip()
+        if not TOP_RE.match(code): continue       # top-level 번호섹션만 경계
+        if code in seen: continue
+        if len(name) < 1: continue
+        seen.add(code); bounds.append((off[i], code, name))
+    out = []
+    for idx, (start, code, name) in enumerate(bounds):
+        end = bounds[idx+1][0] if idx+1 < len(bounds) else len(text)
+        body = text[start:end].strip()
+        ext = sorted(set(EXT_RE.findall(body)))[:8]
+        out.append(dict(code=code, part='본문', order=0, title=f"{code}. {name}"[:120],
+                        body=body, tok=tok(body), links=[], ext=ext))
+    # over-CAP 페이지네이션 + 순번
+    final, order = [], 0
+    for c in out:
+        if c['tok'] <= CAP:
+            final.append({**c, 'order': order}); order += 1; continue
+        pages, cur, ct = [], [], 0
+        for ln in c['body'].split('\n'):
+            lt = tok(ln)+1
+            if ct+lt > PAGE_TOK and cur: pages.append('\n'.join(cur)); cur=[ln]; ct=lt
+            else: cur.append(ln); ct+=lt
+        if cur: pages.append('\n'.join(cur))
+        for pi, pb in enumerate(pages):
+            final.append(dict(code=c['code'] if pi==0 else f"{c['code']}·p{pi+1}", part='본문',
+                              order=order, title=c['title'] if pi==0 else f"{c['title']} (p{pi+1})",
+                              body=pb, tok=tok(pb), links=[], ext=[]))
+            order += 1
+    return final
+
+async def process_one(conn, gid, commit, verbose=True):
+    row = await conn.fetchrow("SELECT title, md_content, ai_domain, data_origin FROM documents WHERE id=$1", gid)
+    if not row: return ('notfound', 0)
+    if not row['md_content']: return ('nullmd', 0)
+    secs = build_sections(row['md_content'])
+    if len(secs) < 2: return ('few', len(secs))     # 섹션 2 미만 = 번호구조 아님
+    toks = [c['tok'] for c in secs]
+    if verbose:
+        print(f"guide={gid} «{(row['title'] or '')[:40]}» 섹션={len(secs)} median={int(statistics.median(toks))} max={max(toks)}")
+        print("  샘플:", [c['title'][:26] for c in secs[:7]])
+    if not commit: return ('dry', len(secs))
+    async with conn.transaction():
+        await conn.execute("DELETE FROM clause_links WHERE src_doc_id IN (SELECT id FROM documents WHERE parent_id=$1 AND doc_kind='clause')", gid)
+        await conn.execute("DELETE FROM documents WHERE parent_id=$1 AND doc_kind='clause'", gid)
+        for c in secs:
+            fh = hashlib.sha256(f"{gid}:{c['code']}:{c['body']}".encode()).hexdigest()
+            cid = await conn.fetchval("""
+                INSERT INTO documents (file_format,file_hash,title,md_content,parent_id,doc_kind,
+                  clause_code,clause_part,clause_order,ai_domain,data_origin,
+                  md_status,review_status,conversion_status,preview_status)
+                VALUES ('md',$1,$2,$3,$4,'clause',$5,$6,$7,$8,$9,'success','approved','none','none') RETURNING id
+            """, fh, c['title'], c['body'], gid, c['code'], c['part'], c['order'], row['ai_domain'], row['data_origin'] or 'external')
+            await conn.execute("INSERT INTO document_tags(doc_id,tag,tag_kind) VALUES ($1,'기술지침','kind') ON CONFLICT DO NOTHING", cid)
+        n = await conn.fetchval("SELECT count(*) FROM documents WHERE parent_id=$1 AND doc_kind='clause'", gid)
+        print(f"  COMMITTED: {n} 섹션 for guide {gid}")
+    return ('committed', len(secs))
+
+async def main():
+    import asyncpg
+    arg = sys.argv[1]; commit = '--commit' in sys.argv
+    conn = await asyncpg.connect(os.environ['DATABASE_URL'].replace('+asyncpg', ''))
+    if arg == 'all':
+        gs = await conn.fetch("SELECT id FROM documents WHERE material_type='guide' AND doc_kind='standard' "
+                              "AND deleted_at IS NULL AND md_content IS NOT NULL ORDER BY id")
+        agg = {}; tot = 0
+        for i, r in enumerate(gs):
+            st, n = await process_one(conn, r['id'], commit, verbose=False)
+            agg[st] = agg.get(st, 0)+1; tot += n if st in ('dry','committed') else 0
+            if commit and (i+1) % 40 == 0: print(f"  …{i+1}/{len(gs)} (누적섹션 {tot})")
+        print(f"BATCH {'COMMIT' if commit else 'DRY'} guides={len(gs)} status={agg} 총섹션={tot}")
+    else:
+        await process_one(conn, int(arg), commit, verbose=True)
+    await conn.close()
+
+asyncio.run(main())

scripts/law_clause_persist.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""법령 조-KB persist: 법령을 조(條) 단위 개별 문서로 분해 + 조↔조 백링크 + 장(章) 태그.
+ASME clause-KB와 동일 모델(doc_kind='clause', parent_id=법령, embedding NULL, 검색제외).
+법령 추출 노이즈(조 앞 ### 메타 반복) 트림. Usage: python3 law_clause_persist.py <law_id> [--commit]
+"""
+import asyncio, os, re, sys, hashlib, statistics
+
+CAP = 12000; PAGE_TOK = 11000
+EN, KO = 0.217, 0.529
+# 조 헤더: '### 제3조의2(가스안전관리...) 본문'
+ART_RE = re.compile(r'^#{0,6}\s*(제\d+조(?:의\d+)?)\s*\(([^)]*)\)\s*(.*)$')
+CHAP_RE = re.compile(r'^#{1,6}\s*(제\d+장(?:의\d+)?)\s*(.*)$')         # 장 = part
+# 같은-법 조 멘션(백링크)
+MENTION_RE = re.compile(r'제\d+조(?:의\d+)?')
+# 타법 참조: 「법명」 ... 제N조
+EXTLAW_RE = re.compile(r'「([^」]+)」')
+
+def tok(s):
+    ko = sum(1 for c in s if '가' <= c <= '힣'); return int((len(s)-ko)*EN + ko*KO)
+def art_code(c): return c  # '제3조의2'
+
+def build_articles(text):
+    lines = text.split('\n'); off = []; a = 0
+    for ln in lines: off.append(a); a += len(ln) + 1
+    arts = []      # (line_idx, code, name, part)
+    cur_part = None
+    for i, ln in enumerate(lines):
+        ch = CHAP_RE.match(ln)
+        if ch and not ART_RE.match(ln):
+            cur_part = (ch.group(1) + (' ' + ch.group(2).strip() if ch.group(2).strip() else '')).strip()
+            continue
+        m = ART_RE.match(ln)
+        if m:
+            arts.append((i, m.group(1), m.group(2).strip(), cur_part))
+    # 본문 슬라이스 + 다음 조 앞 메타 노이즈 트림
+    out = []
+    for idx, (li, code, name, part) in enumerate(arts):
+        end_li = arts[idx+1][0] if idx+1 < len(arts) else len(lines)
+        body_lines = lines[li:end_li]
+        # 트림: 끝에서부터 '### {짧은 메타}' (조번호/조문/날짜/제목, [개정] 제N조 아님) 제거
+        while len(body_lines) > 1:
+            last = body_lines[-1].strip()
+            if last == '':
+                body_lines.pop(); continue
+            mh = re.match(r'^#{1,6}\s+(.*)$', last)
+            if mh:
+                c = mh.group(1).strip()
+                if not c.startswith('[') and not c.startswith('제') and (
+                        c in ('조문', 'N') or re.fullmatch(r'\d+', c) or re.fullmatch(r'\d{8}', c) or len(c) <= 30):
+                    body_lines.pop(); continue
+            break
+        body = '\n'.join(body_lines).strip()
+        links = sorted(set(MENTION_RE.findall(body)) - {code})
+        ext = sorted(set(EXTLAW_RE.findall(body)))[:6]
+        out.append(dict(code=code, part=part or '본칙', order=0,
+                        title=f"{code}({name})" if name else code,
+                        body=body, tok=tok(body), links=links, ext=ext))
+    # 페이지네이션(over-CAP) + 순번
+    final, order = [], 0
+    for c in out:
+        if c['tok'] <= CAP:
+            final.append({**c, 'order': order}); order += 1; continue
+        # 11K 토큰 라인 단위 분할
+        pages, cur, ct = [], [], 0
+        for ln in c['body'].split('\n'):
+            lt = tok(ln)+1
+            if ct+lt > PAGE_TOK and cur: pages.append('\n'.join(cur)); cur=[ln]; ct=lt
+            else: cur.append(ln); ct+=lt
+        if cur: pages.append('\n'.join(cur))
+        for pi, pb in enumerate(pages):
+            final.append(dict(code=c['code'] if pi==0 else f"{c['code']}·p{pi+1}", part=c['part'],
+                              order=order, title=c['title'] if pi==0 else f"{c['title']} (p{pi+1}/{len(pages)})",
+                              body=pb, tok=tok(pb), links=c['links'] if pi==0 else [], ext=[]))
+            order += 1
+    return final
+
+async def process_one(conn, law, commit, verbose=True):
+    row = await conn.fetchrow("SELECT title, coalesce(md_content, extracted_text) AS md_content, ai_domain, data_origin FROM documents WHERE id=$1", law)
+    if not row: return ('notfound', 0, 0)
+    if not row['md_content']: return ('nullmd', 0, 0)
+    arts = build_articles(row['md_content'])
+    if not arts: return ('noart', 0, 0)
+    toks = [c['tok'] for c in arts]
+    nlink = sum(len(c['links']) for c in arts)
+    if verbose:
+        parts = {}
+        for c in arts: parts[c['part']] = parts.get(c['part'], 0)+1
+        print(f"law={law} «{(row['title'] or '')[:34]}» 조문={len(arts)} median={int(statistics.median(toks))} "
+              f"max={max(toks)} 장={len(parts)} 백링크={nlink}")
+        print("  샘플:", [c['title'][:22] for c in arts[:6]])
+    if not commit:
+        return ('dry', len(arts), nlink)
+    async with conn.transaction():
+        await conn.execute(
+            "DELETE FROM clause_links WHERE src_doc_id IN (SELECT id FROM documents WHERE parent_id=$1 AND doc_kind='clause')", law)
+        await conn.execute("DELETE FROM documents WHERE parent_id=$1 AND doc_kind='clause'", law)
+        code2id = {}
+        for c in arts:
+            fh = hashlib.sha256(f"{law}:{c['code']}:{c['body']}".encode()).hexdigest()
+            cid = await conn.fetchval("""
+                INSERT INTO documents (file_format,file_hash,title,md_content,parent_id,doc_kind,
+                  clause_code,clause_part,clause_order,ai_domain,data_origin,
+                  md_status,review_status,conversion_status,preview_status)
+                VALUES ('md',$1,$2,$3,$4,'clause',$5,$6,$7,$8,$9,'success','approved','none','none') RETURNING id
+            """, fh, c['title'], c['body'], law, c['code'], c['part'], c['order'],
+                 row['ai_domain'], row['data_origin'] or 'external')
+            code2id[c['code']] = cid
+            await conn.execute("INSERT INTO document_tags(doc_id,tag,tag_kind) VALUES ($1,$2,'chapter') ON CONFLICT DO NOTHING", cid, c['part'])
+        # 조↔조 백링크 (같은 법 내부; 타법 참조는 dangling)
+        edges = []
+        for c in arts:
+            src = code2id[c['code']]
+            for dst in c['links']:
+                edges.append((src, dst, code2id.get(dst), None, None, None))
+        if edges:
+            await conn.executemany(
+                "INSERT INTO clause_links(src_doc_id,dst_code,dst_doc_id,anchor,ctx,char_off) VALUES ($1,$2,$3,$4,$5,$6)", edges)
+        n = await conn.fetchval("SELECT count(*) FROM documents WHERE parent_id=$1 AND doc_kind='clause'", law)
+        print(f"  COMMITTED: {n} 조문 + {len(edges)} 백링크 for law {law}")
+    return ('committed', n, len(edges))
+
+
+async def main():
+    import asyncpg
+    arg = sys.argv[1]; commit = '--commit' in sys.argv
+    conn = await asyncpg.connect(os.environ['DATABASE_URL'].replace('+asyncpg', ''))
+    if arg == 'all':
+        laws = await conn.fetch("SELECT lm.document_id AS id FROM legal_meta lm "
+                                "JOIN documents d ON d.id=lm.document_id "
+                                "WHERE lm.law_doc_kind='primary' AND lm.version_status='current' "
+                                "AND coalesce(d.md_content, d.extracted_text) IS NOT NULL "
+                                "ORDER BY lm.document_id")
+        agg = {}; tot_art = tot_link = 0; zero = []
+        for i, r in enumerate(laws):
+            st, na, nl = await process_one(conn, r['id'], commit, verbose=False)
+            agg[st] = agg.get(st, 0) + 1
+            tot_art += na; tot_link += nl
+            if st == 'noart': zero.append(r['id'])
+            if commit and (i + 1) % 30 == 0: print(f"  …{i+1}/{len(laws)} (누적 조 {tot_art})")
+        print(f"BATCH {'COMMIT' if commit else 'DRY'} laws={len(laws)} status={agg} 총조문={tot_art} 총백링크={tot_link}")
+        if zero: print(f"  0-조(추출구조 이질) {len(zero)}건: {zero[:20]}")
+    else:
+        await process_one(conn, int(arg), commit, verbose=True)
+    await conn.close()
+
+asyncio.run(main())

scripts/paper_citation_analyze.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""논문 인용그래프 가능성 측정(read-only) — 본문 DOI로 코퍼스내 인용 엣지 추정.
+own_doi = 헤더(앞 2500자) 첫 DOI / cited = References 이후(또는 전체) DOI. owner 맵 → 엣지.
+"""
+import asyncio, os, re, sys
+
+DOI_RE = re.compile(r'10\.\d{4,9}/[^\s"<>)\]\},;]+')
+REF_RE = re.compile(r'(references|참고문헌|bibliography|reference\s*list)', re.I)
+
+def norm(d): return d.rstrip('.').lower()
+
+async def main():
+    import asyncpg
+    conn = await asyncpg.connect(os.environ['DATABASE_URL'].replace('+asyncpg', ''))
+    rows = await conn.fetch("SELECT id, title, coalesce(md_content, extracted_text) AS txt FROM documents "
+                            "WHERE material_type='paper' AND doc_kind='standard' AND deleted_at IS NULL "
+                            "AND coalesce(md_content, extracted_text) IS NOT NULL")
+    owner = {}        # doi -> paper id (헤더 DOI = 그 논문 소유)
+    cited = {}        # paper id -> set(cited doi)
+    n_own = n_refsec = 0
+    for r in rows:
+        txt = r['txt']
+        head = txt[:2500]
+        hdois = [norm(d) for d in DOI_RE.findall(head)]
+        if hdois:
+            owner.setdefault(hdois[0], r['id']); n_own += 1
+        m = REF_RE.search(txt)
+        body = txt[m.start():] if m else ''
+        if m: n_refsec += 1
+        cds = set(norm(d) for d in DOI_RE.findall(body))
+        if cds: cited[r['id']] = cds
+    # 엣지: paper -> owner(cited doi)
+    edges = []
+    for pid, cds in cited.items():
+        for d in cds:
+            o = owner.get(d)
+            if o and o != pid: edges.append((pid, o, d))
+    cited_papers = set(e[0] for e in edges)
+    target_papers = set(e[1] for e in edges)
+    print(f"papers={len(rows)} 헤더DOI보유={n_own} References보유={n_refsec} owner_map={len(owner)}")
+    print(f"인용엣지(코퍼스내)={len(edges)} 인용하는논문={len(cited_papers)} 피인용논문={len(target_papers)}")
+    # 피인용 top
+    from collections import Counter
+    top = Counter(e[1] for e in edges).most_common(6)
+    if top:
+        idmap = {r['id']: r['title'] for r in rows}
+        print("피인용 top:")
+        for pid, c in top: print(f"  {c}회 ← {(idmap.get(pid) or '')[:48]}")
+    await conn.close()
+
+asyncio.run(main())

scripts/paper_openalex_match.py

@@ -0,0 +1,39 @@
+#!/usr/bin/env python3
+"""OpenAlex 고신뢰 매치율 측정 — References 보유 논문(학술 추정) 표본."""
+import asyncio, os, re
+
+def toks(s):
+    return set(re.findall(r'[a-z0-9]+', (s or '').lower()))
+def sim(a, b):
+    ta, tb = toks(a), toks(b)
+    if not ta or not tb: return 0.0
+    return len(ta & tb) / len(ta | tb)
+
+async def main():
+    import asyncpg, httpx
+    conn = await asyncpg.connect(os.environ['DATABASE_URL'].replace('+asyncpg', ''))
+    rows = await conn.fetch("SELECT id, title FROM documents WHERE material_type='paper' "
+                            "AND doc_kind='standard' AND deleted_at IS NULL AND title IS NOT NULL "
+                            "AND coalesce(md_content,extracted_text) ~* 'references|참고문헌' "
+                            "ORDER BY id LIMIT 40")
+    hi = mid = lo = 0; hits = []
+    async with httpx.AsyncClient(timeout=20) as client:
+        for r in rows:
+            title = re.sub(r'\s+', ' ', r['title']).strip()
+            try:
+                resp = await client.get("https://api.openalex.org/works",
+                    params={"search": title[:200], "per_page": 1, "mailto": "hyun49196@gmail.com"})
+                res = (resp.json().get("results") or [])
+                if not res: lo += 1; continue
+                s = sim(title, res[0].get("title"))
+                if s >= 0.6: hi += 1; hits.append((s, title[:40], (res[0].get('title') or '')[:40], res[0].get('cited_by_count'), len(res[0].get('referenced_works') or [])))
+                elif s >= 0.4: mid += 1
+                else: lo += 1
+            except Exception: lo += 1
+    print(f"표본={len(rows)} 고신뢰(≥0.6)={hi} 중간(0.4~0.6)={mid} 저신뢰/무매치={lo}")
+    print("고신뢰 매치 샘플:")
+    for s, a, b, cb, rf in hits[:8]:
+        print(f"  sim={s:.2f} cited={cb} refs={rf} | {a} ≈ {b}")
+    await conn.close()
+
+asyncio.run(main())

scripts/paper_openalex_test.py

@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+"""OpenAlex 보강 타당성 테스트 — 소수 논문 제목으로 매칭/메타 확인 (외부 API)."""
+import asyncio, os, re
+
+async def main():
+    import asyncpg, httpx
+    conn = await asyncpg.connect(os.environ['DATABASE_URL'].replace('+asyncpg', ''))
+    rows = await conn.fetch("SELECT id, title FROM documents WHERE material_type='paper' "
+                            "AND doc_kind='standard' AND deleted_at IS NULL AND title IS NOT NULL "
+                            "AND length(title) > 15 ORDER BY id LIMIT 6")
+    async with httpx.AsyncClient(timeout=20) as client:
+        for r in rows:
+            title = re.sub(r'\s+', ' ', r['title']).strip()
+            try:
+                resp = await client.get("https://api.openalex.org/works",
+                    params={"search": title[:200], "per_page": 1, "mailto": "hyun49196@gmail.com"})
+                js = resp.json()
+                res = (js.get("results") or [])
+                if not res:
+                    print(f"[{r['id']}] NO MATCH | {title[:50]}"); continue
+                w = res[0]
+                oid = (w.get("id") or "").split("/")[-1]
+                print(f"[{r['id']}] {title[:46]}")
+                print(f"   → OA {oid} | {(w.get('title') or '')[:46]} | {w.get('publication_year')} | "
+                      f"cited_by={w.get('cited_by_count')} | refs={len(w.get('referenced_works') or [])} | doi={w.get('doi')}")
+            except Exception as e:
+                print(f"[{r['id']}] ERROR {type(e).__name__}: {e}")
+    await conn.close()
+
+asyncio.run(main())