QA: HOTFIX-003 review iteration 1 — PASSED

TASK-046: /sisters/[name] 상단 프로필 hero 재디자인, avatar 120px 확대
TASK-047: 개요 레이아웃 우선순위 재정렬 (hero → system summary → activity)
TASK-048: ActivityService sanitize 추가
  - stderr/bash command not found/raw 내부 오류 직접 노출 금지
  - 원격 노드 연결 실패 메시지 사용자 친화화

테스트 23/23 pass, FE 16 routes build 성공

.plans/sprints/HOTFIX-002.md

@@ -0,0 +1,31 @@
+# HOTFIX-002: Sprint 태스크 수/완료 수 파싱 보정
+
+## 목표
+프로젝트 상세 화면에서 Sprint 상태는 맞게 보이지만 `태스크 0개 / 완료 0개`로 표시되는 문제 수정
+
+## 태스크
+
+### TASK-044: Sprint task count 파싱 수정
+- `.plans/sprints/SPRINT-XXX.md`에서 실제 태스크 개수를 파싱
+- 지원 포맷:
+  - `TASK-001: 설명`
+  - `- TASK-001 설명`
+  - `- [ ] TASK-001 설명`
+  - `- [x] TASK-001 설명`
+- 중복 카운트 방지
+- heading/본문에 포함된 단순 문자열 오탐 방지
+
+### TASK-045: 완료 task count 계산 보정
+- 완료 태스크 수 계산 규칙 정의
+- 우선순위:
+  1. 체크박스 `[x]` / `[X]`
+  2. 명시 status (`done`, `completed`, `passed` 등 정해진 패턴)
+  3. Sprint 자체가 done이면, 태스크 status 정보가 없을 경우 전체 완료 처리 여부 검토
+- UI에 `총 태스크 수 / 완료 태스크 수` 정상 반영
+
+## 검증 기준
+- 프로젝트 상세 Sprint 섹션에서 `0개 / 0개` 고정 해소
+- 실제 Sprint 문서 기준으로 task total 표시
+- 완료 태스크 수가 포맷에 맞게 계산
+- 빌드/테스트 통과
+- 외부 URL QA 필수

.plans/sprints/HOTFIX-003.md

@@ -0,0 +1,34 @@
+# HOTFIX-003: 자매 상세 프로필 헤더/개요 레이아웃 개선 + Activity 로그 정리
+
+## 목표
+자매 상세 페이지에서 프로필 사진이 너무 작고 개요 정보 우선순위가 어색한 문제, Activity 로그에 raw stderr가 그대로 노출되는 문제를 개선
+
+## 태스크
+
+### TASK-046: 자매 상세 프로필 헤더 확대
+- `/sisters/[name]` 상단 프로필 영역 재디자인
+- 프로필 사진 크기 확대 (최소 96px~128px 권장)
+- 이름 / 역할 / 상태 배지 / 핵심 메타를 프로필 헤더에 재배치
+- “프로필 페이지” 느낌이 나도록 상단 hero 영역 구성
+
+### TASK-047: 개요 레이아웃 우선순위 조정
+- 현재 시스템 카드/활동 로그/개요의 시각적 비중 재조정
+- 프로필 헤더 → 핵심 상태 요약 → 활동 로그 순으로 위계 정리
+- 시스템 정보 카드(UPTIME, CPU, MEM, DISK)는 유지하되 보조 정보로 배치
+- 모바일에서도 헤더/요약/로그 순서가 자연스럽게 보이도록 조정
+
+### TASK-048: Activity 로그 사용자 친화화
+- raw stderr / 내부 명령문 / `bash: ... command not found` 같은 내부 오류 문자열 직접 노출 금지
+- ActivityLog 저장 시 또는 렌더 시 필터링/정규화:
+  - 내부 stderr는 숨기거나
+  - 사람이 읽을 수 있는 문장으로 변환
+- 사용자용 feed에는 의미 있는 이벤트만 노출
+- 필요하면 내부 디버그 로그와 사용자 표시 로그를 분리
+
+## 검증 기준
+- 자매 상세 페이지 프로필 사진이 현재보다 명확히 크게 표시
+- 개요 탭 시각적 우선순위가 자연스러움
+- 모바일에서도 레이아웃 깨짐 없음
+- activity feed에 raw stderr 직접 노출 0건
+- npm run build 성공 + 테스트 통과
+- 외부 URL QA 필수

.plans/sprints/SPRINT-009.md

@@ -0,0 +1,63 @@
+# SPRINT-009: 관리자 단순화 + 프로젝트 진행률 정상화 + 프로필 사진 수정
+
+## 목표
+관리자 전용 서비스에 맞게 회원가입 제거, 프로젝트 진행률 계산 정상화, 자매 프로필 사진 표시 버그 수정
+
+## 태스크
+
+### TASK-032: 회원가입 제거
+- `/register` 페이지 제거
+- `POST /api/auth/register` 엔드포인트 제거 또는 비활성화
+- `INVITE_CODE` 환경변수 및 초대코드 기반 가입 로직 제거
+- 로그인 전용 플로우로 단순화
+- FE: 로그인 페이지에서 회원가입 링크 제거
+- UX: 비로그인 시 `/login`으로만 이동
+
+### TASK-033: 프로젝트 Sprint 동기화
+- 각 프로젝트 repo의 `.plans/sprints/` 디렉토리를 읽어 Sprint DB 레코드 생성/업데이트
+- Gitea API로 repo tree 조회 또는 raw 파일 fetch
+- 동기화 대상:
+  - `SPRINT-001.md` ~ `SPRINT-XXX.md`
+  - Sprint number, name, status(기본 pending) 추출
+- API:
+  - `POST /api/admin/projects/:id/sync-sprints`
+  - `POST /api/admin/projects/sync-all-sprints`
+- Gitea sync 시 Sprint 동기화도 함께 수행 가능하도록 확장
+
+### TASK-034: 프로젝트 진행률 계산 수정
+- 현재 “스프린트 없음” 문제 해결
+- 진행률 계산 방식:
+  - 기본: `완료 Sprint 수 / 전체 Sprint 수`
+  - 가능하면 `.qa/` 또는 상태 기반으로 `done/review/in_progress` 반영
+- 프로젝트 목록 페이지(`/projects`): 진행률 바/퍼센트 표시
+- 프로젝트 상세 페이지(`/projects/[id]`): Sprint 목록 + 상태 표시
+- “No sprint data” fallback 제거
+
+### TASK-035: 프로필 사진 버그 수정
+- 현재 아이콘 fallback만 보이는 문제 원인 파악
+- 점검 항목:
+  - avatar API 경로 연결 여부
+  - FE 이미지 src 설정
+  - 캐시(5분 TTL) fallback 지속 문제
+  - 실제 서버 파일 경로 (`~/.openclaw/avatar.png|jpg|webp`) 확인
+- 수정 목표:
+  - 실제 사진 있으면 항상 우선 표시
+  - 실패 시에만 SVG fallback
+- 반영 위치:
+  - 대시보드 자매 카드
+  - `/sisters`
+  - `/sisters/[name]`
+
+## 의존성
+- TASK-032는 독립적
+- TASK-033 → TASK-034 순서 필수
+- TASK-035는 독립적, 병렬 가능
+
+## 검증 기준
+- `/register` 접근 불가 또는 로그인으로 리다이렉트
+- 회원가입 API 제거/비활성화 확인
+- 프로젝트별 Sprint 동기화 후 진행률 표시 정상
+- 프로젝트 목록/상세에서 Sprint 데이터 렌더링
+- 자매 프로필 사진 실제 이미지 표시 확인
+- npm run build 성공 + 테스트 통과
+- 외부 URL QA 필수

.plans/sprints/SPRINT-010.md

@@ -0,0 +1,56 @@
+# SPRINT-010: 관리자 코드 정리 + 인증 단일화
+
+## 목표
+JWT 로그인 기반으로 완전히 정리하고, 불필요한 API Key/초대코드/죽은 코드를 제거
+
+## 태스크
+
+### TASK-036: 관리 페이지 API Key UI 제거
+- 관리자 페이지에서 API Key 입력 필드/상태 제거
+- adminFetch가 JWT만 사용하도록 FE 정리
+- AuthContext 기반 인증 상태만 사용
+- 관련 안내 문구/placeholder 제거
+
+### TASK-037: JWT 전용 FE 정리
+- 로그인/토큰 관리 흐름 단순화
+- CompositeGuard 하위호환 때문에 남긴 FE 분기 제거
+- refresh/login/logout 로직 정리
+- 불필요한 fallback 코드 제거
+- 에러 처리 UX 정리 (401 → 로그인 페이지 이동)
+
+### TASK-038: API Key 하위호환 제거 또는 축소
+- 백엔드에서 API Key 지원 범위를 정리
+- 원칙:
+  - 일반 웹 UI는 JWT만 사용
+  - 필요한 내부 자동화가 없다면 API Key 완전 제거
+- 제거 대상 후보:
+  - ApiKeyStrategy
+  - CompositeGuard
+  - ADMIN_API_KEYS env
+- 만약 완전 제거가 부담되면 “운영/내부 스크립트 전용 엔드포인트”만 남기고 UI 경로는 JWT 전용으로 제한
+
+### TASK-039: 죽은 코드/불필요 코드 청소
+- invite/register 관련 unused code 제거
+- API Key 관련 사용 안 하는 util 제거
+- old fallback 코드 정리
+- 문서 업데이트:
+  - `.plans/design/` 변경 필요 시 반영
+  - README / 환경변수 설명 업데이트
+- grep 기반 점검:
+  - `INVITE_CODE`
+  - `register`
+  - `API_KEY`
+  - `CompositeGuard`
+  - 사용 안 되는 state/props/components
+
+## 의존성
+- Sprint 009 완료 후 진행 권장
+- TASK-036 → TASK-037 → TASK-038 → TASK-039 순서 권장
+
+## 검증 기준
+- 관리 페이지에서 API Key 입력 UI 0건
+- 로그인 후 JWT만으로 관리자 기능 정상 동작
+- `/register` 관련 코드/엔드포인트 정리 확인
+- API Key 제거 또는 제한 후 기존 UI 정상 동작
+- unused code 정리 후 build/test 통과
+- 외부 URL QA 필수

.plans/sprints/SPRINT-011.md

@@ -0,0 +1,56 @@
+# SPRINT-011: 진행률/프로필 사진 실제 반영 핫픽스
+
+## 목표
+프로젝트 진행률이 0%로 보이는 문제와 자매 프로필 사진이 fallback으로만 보이는 문제를 실제 데이터 기준으로 수정
+
+## 태스크
+
+### TASK-040: Sprint status 동기화 수정
+- 현재 `Status: value` 단일 줄 파싱이 실제 `.plans/sprints/*.md` 포맷과 맞지 않는 문제 수정
+- 실제 Sprint 문서 포맷 조사 후 파싱 규칙 재정의
+- 우선순위:
+  1. 명시 메타 블록 / heading 기반 status 파싱
+  2. QA 결과 파일(`.qa/SPRINT-XXX-review-*.md`) 기반 완료 여부 보조 판정
+  3. 없으면 pending
+- 오탐 방지: 본문 전체 키워드 검색 금지
+
+### TASK-041: 프로젝트 진행률 계산 수정
+- Sprint status가 실제 반영되도록 프로젝트 진행률 계산 로직 수정
+- 표시 기준:
+  - `done` Sprint 수 / 전체 Sprint 수 → %
+  - 필요 시 `review`, `in_progress`는 별도 상태 태그 표시
+- `/projects` 목록: 퍼센트 + progress bar 정상 반영
+- `/projects/[id]` 상세: Sprint 상태 목록 정확 표시
+- “0%만 뜨는” 현상 해소
+
+### TASK-042: 프로필 사진 실제 노출 수정
+- avatar API 응답 200이어도 fallback만 보이는 원인 파악
+- 점검 항목:
+  - FE 이미지 src 연결 여부
+  - `onError`가 과도하게 fallback으로 전환되는지
+  - `next/image` / `img` 캐시 문제
+  - content-type/image 응답 정상 여부
+  - avatar cache miss 후 stale fallback 유지 여부
+- 실제 파일 경로 재확인:
+  - `~/.openclaw/avatar.png`
+  - `~/.openclaw/avatar.jpg`
+  - `~/.openclaw/avatar.webp`
+
+### TASK-043: 아바타 UI 일관화
+- 대시보드, `/sisters`, `/sisters/[name]`, `/admin` 전부 같은 Avatar 컴포넌트 사용
+- 실제 이미지 우선 렌더
+- 실패 시에만 fallback (이니셜 or SVG)
+- 관리자 페이지에 남은 이모지 fallback 제거
+
+## 의존성
+- TASK-040 → TASK-041 순서 필수
+- TASK-042, TASK-043은 병렬 가능하나 최종적으로 Avatar 공통 컴포넌트로 수렴
+
+## 검증 기준
+- 프로젝트 진행률이 0% 고정이 아닌 실제 값으로 표시
+- Sprint 상세 상태가 실제 문서/QA 결과와 일치
+- 자매 프로필 사진이 실제 이미지로 표시
+- 관리자/자매/대시보드 전부 동일한 사진 표시 정책 사용
+- fallback은 이미지 실패 시에만 동작
+- npm run build 성공 + 테스트 통과
+- 외부 URL QA 필수

.qa/HOTFIX-002-review-1.md

@@ -0,0 +1,42 @@
+# HOTFIX-002 QA Review — Iteration 1
+
+- **검증일시:** 2026-04-04 18:35 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ✅ PASSED
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| npm install | ✅ |
+| prisma generate | ✅ |
+| npm test | ✅ 23/23 pass |
+| npm run build (BE) | ✅ |
+| npm run build (FE) | ✅ 16 routes |
+
+## Task 파싱 확인 (TASK-044)
+
+| 포맷 | 지원 |
+|------|------|
+| `### TASK-001: title` | ✅ |
+| `- [x] TASK-001: title` (done) | ✅ |
+| `- [ ] TASK-001: title` (pending) | ✅ |
+| `- TASK-001: title` | ✅ |
+| `TASK-001: title` | ✅ |
+| 중복 taskId 방지 (seen Set) | ✅ |
+
+## 완료 count 계산 (TASK-045)
+
+| 규칙 | 확인 |
+|------|------|
+| Sprint done → task (status 없으면) done fallback | ✅ |
+| `[x]` → done | ✅ |
+| `[ ]` → pending | ✅ |
+| 기존 done task 보호 | ✅ |
+| Task 테이블 upsert | ✅ |
+
+## Non-blocking
+
+| ID | 이슈 |
+|----|------|
+| NB1 | task assignee 하드코딩 'narang' — 문서 파싱으로 개선 권장 |

.qa/HOTFIX-003-review-1.md

@@ -0,0 +1,25 @@
+# HOTFIX-003 QA Review — Iteration 1
+
+- **검증일시:** 2026-04-04 19:48 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ✅ PASSED
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| npm test | ✅ 23/23 pass |
+| npm run build (BE) | ✅ |
+| npm run build (FE) | ✅ 16 routes |
+
+## 변경 확인
+
+### 프로필 hero (TASK-046/047)
+- ✅ SisterAvatar size=120 (기존 36px → 120px 확대)
+- ✅ 상단 프로필 hero 재디자인
+
+### Activity stderr 정리 (TASK-048)
+- ✅ `sanitizeActivityDetail()` 함수 추가
+- ✅ stderr/bash/command not found → 사용자 친화 메시지 변환
+- ✅ SSH 연결 실패 → "원격 노드 연결에 실패했어" 변환
+- ✅ log() + getFeed() + getProjectFeed() 전부 적용

.qa/SPRINT-008-review-1.md

@@ -0,0 +1,43 @@
+# SPRINT-008 QA Review — Iteration 1
+
+- **검증일시:** 2026-04-04 16:35 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ❌ FAILED (blocking 3건)
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| npm install | ✅ |
+| prisma generate | ✅ |
+| npm test | ✅ 26/26 pass |
+| npm run build (BE) | ✅ |
+| npm run build (FE) | ✅ 16 routes |
+
+## 🔴 Blocking
+
+### B1: SettingsController PUT body 미검증 — 임의 키 주입
+- **파일:** settings.controller.ts, settings.service.ts
+- **문제:** `Record<string, string>` 그대로 upsert → DEFAULT_SETTINGS에 없는 키도 DB에 삽입
+- **수정:** saveAll()에서 DEFAULT_SETTINGS 키만 필터링
+
+### B2: EventsScheduler + SistersScheduler 중복 — SSH 2배 호출
+- **파일:** events.module.ts, events.scheduler.ts, sisters.scheduler.ts
+- **문제:** 둘 다 providers에 등록, 둘 다 30초마다 broadcastSisterStatus() 실행
+- **수정:** EventsScheduler 제거 (SistersScheduler가 대체)
+
+### B3: SistersScheduler에 OnModuleDestroy 없음 — 메모리 누수
+- **파일:** sisters.scheduler.ts
+- **문제:** clearInterval 없음 → 서버 종료/HMR 시 좀비 타이머
+- **수정:** `implements OnModuleDestroy` + `clearInterval(this.timer)`
+
+## Non-blocking (9건)
+- N1: avatar @Res() → NotFoundException 대신 res.status(404)
+- N2: getSystemInfo null 반환 → 컨트롤러 null 체크 없음
+- N3: SSH 커넥션 풀링 없음 (30초×4자매=16개 핸드셰이크)
+- N4: top/free/df 파싱 환경 의존성 + disk % 미파싱
+- N5: sisters 페이지 15초 폴링 + WS 30초 브로드캐스트 중복
+- N6: avatar 캐시 사이즈 제한 없음
+- N7: DEFAULT_SETTINGS FE/BE 중복 정의
+- N8: sisterEmojis/sisterDisplayNames 여전히 3곳 중복
+- N9: SSH 4개 병렬 → 1개 연결 4개 명령으로 최적화 권장

.qa/SPRINT-008-review-2.md

@@ -0,0 +1,21 @@
+# SPRINT-008 QA Review — Iteration 2
+
+- **검증일시:** 2026-04-04 16:38 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ✅ PASSED
+
+## Blocking 수정 확인
+
+| ID | 이슈 | 수정 확인 |
+|----|------|----------|
+| B1 | Settings 키 필터링 | ✅ saveAll()에서 DEFAULT_SETTINGS 키만 allowed.includes 필터 |
+| B2 | Scheduler 중복 | ✅ SistersScheduler events.module에서 제거 → EventsScheduler만 동작 |
+| B3 | OnModuleDestroy 누락 | ✅ SistersScheduler 제거로 해소, EventsScheduler에 이미 clearInterval |
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| git fetch + reset | ✅ |
+| prisma generate | ✅ |
+| npm test | ✅ 26/26 pass |

.qa/SPRINT-009-review-1.md

@@ -0,0 +1,37 @@
+# SPRINT-009 QA Review — Iteration 1
+
+- **검증일시:** 2026-04-04 17:06 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ❌ FAILED (blocking 2건)
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| npm install | ✅ |
+| prisma generate | ✅ |
+| npm test | ✅ 23/23 pass |
+| npm run build (BE) | ✅ |
+| npm run build (FE) | ✅ 16 routes |
+
+## 🔴 Blocking
+
+### B1: repoUrl.split('/').pop() trailing slash 취약
+- **파일:** sprint-sync.service.ts:42, 51
+- **문제:** trailing slash URL → repoName 빈 문자열 → Gitea API 깨짐
+- **수정:** `.replace(/\/+$/, '').split('/').pop()`
+
+### B2: parseSprintMd status 전체 본문 키워드 검색 오탐
+- **파일:** sprint-sync.service.ts:22-24
+- **문제:** 본문에 "완료", "진행" 단어 포함 시 오탐 → DB status 부정확 → 진행률 계산 오류
+- **수정:** 명시적 섹션(## Status 등)만 파싱하도록 범위 제한
+
+## Non-blocking (8건)
+- NB1: syncAllProjectSprints 순차 처리
+- NB2: getRawFile ref='main' 하드코딩
+- NB3: getRepoTree 전체 tree fetch 비효율
+- NB4: /register redirect 방식은 적절 (OK)
+- NB5: login page dead import/styled component
+- NB6: auth spec mock 잔여
+- NB7: sprint update 조건 코멘트 부족
+- NB8: avatar onError display:none

.qa/SPRINT-009-review-2.md

@@ -0,0 +1,20 @@
+# SPRINT-009 QA Review — Iteration 2
+
+- **검증일시:** 2026-04-04 17:12 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ✅ PASSED
+
+## Blocking 수정 확인
+
+| ID | 이슈 | 수정 확인 |
+|----|------|----------|
+| B1 | repoUrl trailing slash | ✅ `.replace(/\/+$/, '').split('/').pop()` |
+| B2 | status 파싱 범위 | ✅ `Status: value` 명시 줄만 regex 파싱, 본문 전체 검색 제거 |
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| git fetch + reset | ✅ |
+| prisma generate | ✅ |
+| npm test | ✅ 23/23 pass |

.qa/SPRINT-010-review-1.md

@@ -0,0 +1,51 @@
+# SPRINT-010 QA Review — Iteration 1
+
+- **검증일시:** 2026-04-04 17:25 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ✅ PASSED
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| npm install | ✅ |
+| prisma generate | ✅ |
+| npm test | ✅ 23/23 pass |
+| npm run build (BE) | ✅ |
+| npm run build (FE) | ✅ 16 routes |
+
+## API Key 완전 제거 확인
+
+| 항목 | 결과 |
+|------|------|
+| api-key.strategy.ts 파일 삭제 | ✅ |
+| api-key.guard.ts 파일 삭제 | ✅ |
+| CompositeGuard 코드 0건 (grep) | ✅ |
+| ADMIN_API_KEYS 참조 0건 | ✅ |
+| hanarang_admin_key 참조 0건 | ✅ |
+| admin layout API Key UI 제거 | ✅ |
+| adminFetch JWT 전용 단순화 | ✅ |
+
+## JWT 전환 확인
+
+| Controller | Guard |
+|------------|-------|
+| AdminController | JwtGuard + RoleGuard ✅ |
+| CostsController | JwtGuard + RoleGuard ✅ |
+| GiteaSyncController | JwtGuard + RoleGuard ✅ |
+| SettingsController | JwtGuard + RoleGuard ✅ |
+
+## Dead Code 정리 확인
+
+| 항목 | 결과 |
+|------|------|
+| INVITE_CODE BE 코드 | ✅ 0건 |
+| register BE 엔드포인트 | ✅ 제거됨 |
+| PUBLIC_PATHS /register | ✅ 제거됨 |
+
+## 판정 근거
+- 코드 정리/제거 스프린트 — 새 기능 없이 기존 코드 축소
+- API Key 관련 파일/코드 완전 제거 확인 (grep 0건)
+- JWT 전환 일관 적용
+- 테스트/빌드 통과
+- blocking 0건

.qa/SPRINT-011-review-1.md

@@ -0,0 +1,37 @@
+# SPRINT-011 QA Review — Iteration 1
+
+- **검증일시:** 2026-04-04 17:45 KST
+- **검증자:** 다랑이 (Evaluator)
+- **결과:** ✅ PASSED
+
+## 검증 항목
+
+| 항목 | 결과 |
+|------|------|
+| npm install | ✅ |
+| prisma generate | ✅ |
+| npm test | ✅ 23/23 pass |
+| npm run build (BE) | ✅ |
+| npm run build (FE) | ✅ 16 routes |
+
+## 핵심 변경 확인
+
+### Sprint status 파싱 (TASK-040)
+- ✅ `.qa/SPRINT-XXX-review-*.md`에서 PASSED 여부로 status 결정
+- ✅ 본문 전체 키워드 검색 완전 제거
+- ✅ `inferStatusFromQaContent()`로 PASSED regex 체크
+- ✅ passedMap으로 Sprint number → boolean 매핑
+
+### 진행률 계산 (TASK-041)
+- ✅ `doneSprints / totalSprints * 100` — Sprint done 기반 진행률
+
+### SisterAvatar 공통 컴포넌트 (TASK-042/043)
+- ✅ `components/common/SisterAvatar.tsx` 생성
+- ✅ API URL → 이미지 로드 → onError → 이니셜 fallback
+- ✅ 대시보드(/) + 자매(/sisters) + 상세(/sisters/[name]) 전부 적용
+- ✅ 이모지 fallback 대신 이니셜 텍스트 fallback
+
+## 판정 근거
+- 자기야가 직접 지적한 2가지 문제(진행률 0%, 프로필 사진 미노출) 핵심 원인 수정됨
+- 테스트/빌드 전부 통과
+- blocking 0건

backend/prisma/schema.prisma

@@ -102,3 +102,10 @@ model User {
   createdAt DateTime @default(now())
   updatedAt DateTime @updatedAt
 }
+
+model SystemSettings {
+  id        Int      @id @default(autoincrement())
+  key       String   @unique
+  value     String   @db.Text
+  updatedAt DateTime @updatedAt
+}

backend/src/activity/activity.service.ts

@@ -9,6 +9,23 @@ export interface LogActivityDto {
   detail?: string;
 }
 
+function sanitizeActivityDetail(detail?: string | null): string | undefined {
+  if (!detail) return detail ?? undefined;
+
+  const raw = detail.trim();
+
+  // 내부 stderr/명령문 직접 노출 금지
+  if (/stderr:/i.test(raw) || /command not found/i.test(raw) || /bash:\s*line/i.test(raw)) {
+    return '내부 작업 중 오류가 발생했어. 자세한 시스템 로그는 관리자 로그에서 확인할 수 있어.';
+  }
+
+  if (/^ssh failed/i.test(raw) || /ssh connection failed/i.test(raw)) {
+    return '원격 노드 연결에 실패했어.';
+  }
+
+  return raw;
+}
+
 @Injectable()
 export class ActivityService {
   constructor(
@@ -18,14 +35,16 @@ export class ActivityService {
 
   async log(dto: LogActivityDto) {
     const record = await this.prisma.activityLog.create({
-      data: dto,
+      data: {
+        ...dto,
+        detail: sanitizeActivityDetail(dto.detail),
+      },
       include: {
         sister: { select: { name: true } },
         project: { select: { name: true } },
       },
     });
 
-    // 실시간 브로드캐스트 (gateway 사용 가능한 경우)
     if (this.events) {
       this.events.broadcastActivity(record);
     }
@@ -46,7 +65,12 @@ export class ActivityService {
       }),
       this.prisma.activityLog.count(),
     ]);
-    return { items, total, limit, offset };
+    return {
+      items: items.map((item) => ({ ...item, detail: sanitizeActivityDetail(item.detail) })),
+      total,
+      limit,
+      offset,
+    };
   }
 
   async getProjectFeed(projectId: number, limit = 30, offset = 0) {
@@ -62,6 +86,11 @@ export class ActivityService {
       }),
       this.prisma.activityLog.count({ where: { projectId } }),
     ]);
-    return { items, total, limit, offset };
+    return {
+      items: items.map((item) => ({ ...item, detail: sanitizeActivityDetail(item.detail) })),
+      total,
+      limit,
+      offset,
+    };
   }
 }

backend/src/admin/admin.controller.ts

@@ -9,7 +9,7 @@ import {
   UseGuards,
 } from '@nestjs/common';
 import { AdminService } from './admin.service';
-import { CompositeGuard } from '../auth/jwt.guard';
+import { JwtGuard } from '../auth/jwt.guard';
 import { RoleGuard, Roles } from '../auth/role.guard';
 import { SisterNamePipe } from '../common/sister-name.pipe';
 import type { SisterName } from '../common/sister-name.pipe';
@@ -24,7 +24,7 @@ class UpdateHarnessDto {
 }
 
 @Controller('api/admin')
-@UseGuards(CompositeGuard, RoleGuard)
+@UseGuards(JwtGuard, RoleGuard)
 @Roles('admin')
 export class AdminController {
   constructor(private readonly adminService: AdminService) {}

backend/src/app.module.ts

@@ -16,6 +16,7 @@ import { AdminModule } from './admin/admin.module';
 import { EventsModule } from './events/events.module';
 import { CostsModule } from './costs/costs.module';
 import { GiteaSyncModule } from './gitea-sync/gitea-sync.module';
+import { SettingsModule } from './settings/settings.module';
 
 @Module({
   imports: [
@@ -34,6 +35,7 @@ import { GiteaSyncModule } from './gitea-sync/gitea-sync.module';
     EventsModule,
     CostsModule,
     GiteaSyncModule,
+    SettingsModule,
   ],
   controllers: [AppController],
   providers: [AppService],

backend/src/auth/api-key.guard.ts

@@ -1,5 +0,0 @@
-import { Injectable } from '@nestjs/common';
-import { AuthGuard } from '@nestjs/passport';
-
-@Injectable()
-export class ApiKeyGuard extends AuthGuard('api-key') {}

backend/src/auth/api-key.strategy.ts

@@ -1,30 +0,0 @@
-import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { PassportStrategy } from '@nestjs/passport';
-import { Strategy } from 'passport-http-bearer';
-import { ConfigService } from '@nestjs/config';
-
-@Injectable()
-export class ApiKeyStrategy extends PassportStrategy(Strategy, 'api-key') {
-  private readonly validKeys: Set<string>;
-
-  constructor(config: ConfigService) {
-    super();
-    const raw = config.get<string>('ADMIN_API_KEYS') ?? '';
-    this.validKeys = new Set(
-      raw
-        .split(',')
-        .map((k) => k.trim())
-        .filter(Boolean),
-    );
-  }
-
-  validate(token: string): { role: string; username: string } {
-    if (!this.validKeys.size) {
-      throw new UnauthorizedException('ADMIN_API_KEYS not configured');
-    }
-    if (!this.validKeys.has(token)) {
-      throw new UnauthorizedException('Invalid API key');
-    }
-    return { role: "admin", username: "api-key" };
-  }
-}

backend/src/auth/auth.controller.ts

@@ -8,7 +8,7 @@ import {
   Request,
   BadRequestException,
 } from '@nestjs/common';
-import { AuthService, RegisterDto, LoginDto } from './auth.service';
+import { AuthService, LoginDto } from './auth.service';
 import { JwtGuard } from './jwt.guard';
 import { Throttle, ThrottlerGuard } from '@nestjs/throttler';
 
@@ -16,13 +16,6 @@ import { Throttle, ThrottlerGuard } from '@nestjs/throttler';
 export class AuthController {
   constructor(private readonly authService: AuthService) {}
 
-  @UseGuards(ThrottlerGuard)
-  @Throttle({ default: { limit: 3, ttl: 60000 } })
-  @Post('register')
-  register(@Body() dto: RegisterDto) {
-    return this.authService.register(dto);
-  }
-
   @UseGuards(ThrottlerGuard)
   @Throttle({ default: { limit: 5, ttl: 60000 } })
   @Post('login')

backend/src/auth/auth.module.ts

@@ -1,32 +1,35 @@
 import { Module } from '@nestjs/common';
-import { PassportModule } from '@nestjs/passport';
 import { JwtModule } from '@nestjs/jwt';
+import { PassportModule } from '@nestjs/passport';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
 import { JwtStrategy } from './jwt.strategy';
-import { ApiKeyStrategy } from './api-key.strategy';
+import { JwtGuard } from './jwt.guard';
-import { JwtGuard, CompositeGuard } from './jwt.guard';
-import { ApiKeyGuard } from './api-key.guard';
 import { RoleGuard } from './role.guard';
 import { PrismaModule } from '../prisma/prisma.module';
+import { ThrottlerModule } from '@nestjs/throttler';
 
 @Module({
   imports: [
+    PrismaModule,
     PassportModule,
     ConfigModule,
-    PrismaModule,
+    ThrottlerModule,
     JwtModule.registerAsync({
       imports: [ConfigModule],
       inject: [ConfigService],
       useFactory: (config: ConfigService) => ({
-        secret: (() => { const s = config.get<string>('JWT_SECRET'); if (!s) throw new Error('JWT_SECRET is not configured'); return s; })(),
+        secret: (() => {
-        signOptions: { expiresIn: '15m' },
+          const s = config.get<string>('JWT_SECRET');
+          if (!s) throw new Error('JWT_SECRET is not configured');
+          return s;
+        })(),
       }),
     }),
   ],
   controllers: [AuthController],
-  providers: [AuthService, JwtStrategy, ApiKeyStrategy, JwtGuard, CompositeGuard, ApiKeyGuard, RoleGuard],
+  providers: [AuthService, JwtStrategy, JwtGuard, RoleGuard],
-  exports: [JwtGuard, CompositeGuard, ApiKeyGuard, RoleGuard, AuthService],
+  exports: [JwtGuard, RoleGuard, AuthService, JwtModule],
 })
 export class AuthModule {}

backend/src/auth/auth.service.spec.ts

@@ -3,7 +3,7 @@ import { AuthService } from './auth.service';
 import { JwtService } from '@nestjs/jwt';
 import { ConfigService } from '@nestjs/config';
 import { PrismaService } from '../prisma/prisma.service';
-import { BadRequestException, ConflictException, UnauthorizedException } from '@nestjs/common';
+import { UnauthorizedException } from '@nestjs/common';
 
 describe('AuthService', () => {
   let service: AuthService;
@@ -23,7 +23,6 @@ describe('AuthService', () => {
   const mockConfig = {
     get: jest.fn().mockImplementation((key: string) => {
       if (key === 'JWT_SECRET') return 'test-secret';
-      if (key === 'INVITE_CODE') return 'VALID_CODE';
       return undefined;
     }),
   };
@@ -42,34 +41,6 @@ describe('AuthService', () => {
     jest.clearAllMocks();
   });
 
-  it('register: 잘못된 초대 코드 → BadRequestException', async () => {
-    await expect(
-      service.register({ username: 'test', password: 'password123', inviteCode: 'WRONG' }),
-    ).rejects.toThrow(BadRequestException);
-  });
-
-  it('register: 중복 username → ConflictException', async () => {
-    mockPrisma.user.findUnique.mockResolvedValue({ id: 1, username: 'test' });
-    await expect(
-      service.register({ username: 'test', password: 'password123', inviteCode: 'VALID_CODE' }),
-    ).rejects.toThrow(ConflictException);
-  });
-
-  it('register: 성공 시 토큰 반환', async () => {
-    mockPrisma.user.findUnique.mockResolvedValue(null);
-    mockPrisma.user.create.mockResolvedValue({ id: 1, username: 'newuser', role: 'admin' });
-
-    const result = await service.register({
-      username: 'newuser',
-      password: 'password123',
-      inviteCode: 'VALID_CODE',
-    });
-
-    expect(result).toHaveProperty('accessToken');
-    expect(result).toHaveProperty('refreshToken');
-    expect(result.username).toBe('newuser');
-  });
-
   it('login: 존재하지 않는 사용자 → UnauthorizedException', async () => {
     mockPrisma.user.findUnique.mockResolvedValue(null);
     await expect(

backend/src/auth/auth.service.ts

@@ -1,20 +1,9 @@
-import { Injectable, UnauthorizedException, BadRequestException, ConflictException } from '@nestjs/common';
+import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { JwtService } from '@nestjs/jwt';
 import { ConfigService } from '@nestjs/config';
 import { PrismaService } from '../prisma/prisma.service';
 import * as bcrypt from 'bcrypt';
-import { IsString, IsNotEmpty, MinLength, MaxLength } from 'class-validator';
+import { IsString, IsNotEmpty } from 'class-validator';
-
-export class RegisterDto {
-  @IsString() @IsNotEmpty() @MaxLength(32)
-  username!: string;
-
-  @IsString() @MinLength(8) @MaxLength(64)
-  password!: string;
-
-  @IsString() @IsNotEmpty()
-  inviteCode!: string;
-}
 
 export class LoginDto {
   @IsString() @IsNotEmpty()
@@ -32,22 +21,6 @@ export class AuthService {
     private readonly config: ConfigService,
   ) {}
 
-  async register(dto: RegisterDto) {
-    const inviteCode = this.config.get<string>('INVITE_CODE');
-    if (!inviteCode) throw new BadRequestException('Invite code not configured');
-    if (dto.inviteCode !== inviteCode) throw new BadRequestException('Invalid invite code');
-
-    const existing = await this.prisma.user.findUnique({ where: { username: dto.username } });
-    if (existing) throw new ConflictException('Username already taken');
-
-    const hash = await bcrypt.hash(dto.password, 12);
-    const user = await this.prisma.user.create({
-      data: { username: dto.username, password: hash },
-    });
-
-    return this.signTokens(user.id, user.username, user.role);
-  }
-
   async login(dto: LoginDto) {
     const user = await this.prisma.user.findUnique({ where: { username: dto.username } });
     if (!user) throw new UnauthorizedException('Invalid credentials');
@@ -86,15 +59,8 @@ export class AuthService {
     if (!secret) throw new Error('JWT_SECRET is not configured');
     const payload = { sub: userId, username, role };
 
-    const accessToken = this.jwt.sign(payload, {
+    const accessToken = this.jwt.sign(payload, { secret, expiresIn: '15m' });
-      secret,
+    const refreshToken = this.jwt.sign(payload, { secret: secret + '_refresh', expiresIn: '7d' });
-      expiresIn: '15m',
-    });
-
-    const refreshToken = this.jwt.sign(payload, {
-      secret: secret + '_refresh',
-      expiresIn: '7d',
-    });
 
     return { accessToken, refreshToken, username, role };
   }

backend/src/auth/jwt.guard.ts

@@ -1,22 +1,9 @@
-import { Injectable, ExecutionContext, UnauthorizedException } from '@nestjs/common';
+import { Injectable, ExecutionContext } from '@nestjs/common';
 import { AuthGuard } from '@nestjs/passport';
 
 @Injectable()
 export class JwtGuard extends AuthGuard('jwt') {
-  handleRequest<T>(err: Error, user: T): T {
+  canActivate(context: ExecutionContext) {
-    if (err || !user) throw new UnauthorizedException('JWT authentication required');
+    return super.canActivate(context);
-    return user;
-  }
-}
-
-/**
- * JWT 먼저 시도 → 실패 시 API Key fallback
- * Sprint 008까지 하위호환 유지
- */
-@Injectable()
-export class CompositeGuard extends AuthGuard(['jwt', 'api-key']) {
-  handleRequest<T>(err: Error, user: T): T {
-    if (err || !user) throw new UnauthorizedException('Authentication required');
-    return user;
   }
 }

backend/src/costs/costs.controller.ts

@@ -1,12 +1,12 @@
 import { Controller, Get, Post, Query, Param, UseGuards } from '@nestjs/common';
 import { CostsService, CostPeriod } from './costs.service';
-import { CompositeGuard } from '../auth/jwt.guard';
+import { JwtGuard } from '../auth/jwt.guard';
 import { RoleGuard, Roles } from '../auth/role.guard';
 import { SisterNamePipe } from '../common/sister-name.pipe';
 import type { SisterName } from '../common/sister-name.pipe';
 
 @Controller('api/admin/costs')
-@UseGuards(CompositeGuard, RoleGuard)
+@UseGuards(JwtGuard, RoleGuard)
 @Roles('admin')
 export class CostsController {
   constructor(private readonly costsService: CostsService) {}

backend/src/events/events.gateway.ts

@@ -86,6 +86,6 @@ export class EventsGateway
 
   /** 연결된 클라이언트 수 */
   getClientCount(): number {
-    return this.server.sockets.sockets.size;
+    return this.server?.sockets?.sockets?.size ?? 0;
   }
 }

backend/src/events/sisters.scheduler.ts

@@ -0,0 +1,26 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { SistersService } from '../sisters/sisters.service';
+import { EventsGateway } from './events.gateway';
+
+@Injectable()
+export class SistersScheduler {
+  private readonly logger = new Logger(SistersScheduler.name);
+  private timer: NodeJS.Timeout | null = null;
+
+  constructor(
+    private readonly sistersService: SistersService,
+    private readonly eventsGateway: EventsGateway,
+  ) {}
+
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(async () => {
+      try {
+        const sisters = await this.sistersService.getAllSistersStatus();
+        this.eventsGateway.broadcastSisterStatus(sisters);
+      } catch {
+        this.logger.warn('Failed to broadcast sisters update');
+      }
+    }, 30000);
+  }
+}

backend/src/gitea-sync/gitea-sync.controller.ts

@@ -1,10 +1,10 @@
 import { Controller, Post, Get, UseGuards } from '@nestjs/common';
 import { GiteaSyncService } from './gitea-sync.service';
-import { CompositeGuard } from '../auth/jwt.guard';
+import { JwtGuard } from '../auth/jwt.guard';
 import { RoleGuard, Roles } from '../auth/role.guard';
 
 @Controller('api/admin/gitea')
-@UseGuards(CompositeGuard, RoleGuard)
+@UseGuards(JwtGuard, RoleGuard)
 @Roles('admin')
 export class GiteaSyncController {
   constructor(private readonly giteaSyncService: GiteaSyncService) {}

backend/src/gitea-sync/gitea-sync.module.ts

@@ -5,9 +5,10 @@ import { PrismaModule } from '../prisma/prisma.module';
 import { GiteaModule } from '../gitea/gitea.module';
 import { ActivityModule } from '../activity/activity.module';
 import { AuthModule } from '../auth/auth.module';
+import { ProjectsModule } from '../projects/projects.module';
 
 @Module({
-  imports: [PrismaModule, GiteaModule, ActivityModule, AuthModule],
+  imports: [PrismaModule, GiteaModule, ActivityModule, AuthModule, ProjectsModule],
   controllers: [GiteaSyncController],
   providers: [GiteaSyncService],
   exports: [GiteaSyncService],

backend/src/gitea-sync/gitea-sync.service.ts

@@ -3,6 +3,7 @@ import { ConfigService } from '@nestjs/config';
 import { PrismaService } from '../prisma/prisma.service';
 import { GiteaService } from '../gitea/gitea.service';
 import { ActivityService } from '../activity/activity.service';
+import { SprintSyncService } from '../projects/sprint-sync.service';
 
 @Injectable()
 export class GiteaSyncService {
@@ -13,6 +14,7 @@ export class GiteaSyncService {
     private readonly prisma: PrismaService,
     private readonly gitea: GiteaService,
     private readonly activity: ActivityService,
+    private readonly sprintSync: SprintSyncService,
   ) {}
 
   async syncRepos(): Promise<{ synced: number; created: number; updated: number }> {
@@ -70,6 +72,12 @@ export class GiteaSyncService {
     }
 
     this.logger.log(`Gitea sync: ${repos.length} repos, ${created} new, ${updated} updated`);
+
+    // Sprint 동기화도 함께 수행
+    await this.sprintSync.syncAllProjectSprints().catch((e) => {
+      this.logger.warn(`Sprint sync failed: ${e.message}`);
+    });
+
     return { synced: repos.length, created, updated };
   }
 

backend/src/gitea/gitea.service.ts

@@ -145,4 +145,30 @@ export class GiteaService {
       return [];
     }
   }
+
+  async getRepoTree(repoName: string, treePath: string): Promise<string[]> {
+    if (!this.isAvailable()) return [];
+    try {
+      const { data } = await this.client.get<{ tree: { path: string; type: string }[] }>(
+        `/repos/${this.org}/${repoName}/git/trees/HEAD`,
+        { params: { recursive: true } },
+      );
+      return (data.tree ?? []).filter((e) => e.path.startsWith(treePath) && e.type === 'blob').map((e) => e.path);
+    } catch {
+      return [];
+    }
+  }
+
+  async getRawFile(repoName: string, filePath: string): Promise<string | null> {
+    if (!this.isAvailable()) return null;
+    try {
+      const { data } = await this.client.get<string>(
+        `/repos/${this.org}/${repoName}/raw/${filePath}`,
+        { params: { ref: 'main' }, responseType: 'text' },
+      );
+      return typeof data === 'string' ? data : null;
+    } catch {
+      return null;
+    }
+  }
 }

backend/src/projects/projects.controller.ts

@@ -1,11 +1,15 @@
 import { Controller, Get, Param, Query, ParseIntPipe, UseGuards, Post } from '@nestjs/common';
 import { ProjectsService } from './projects.service';
-import { CompositeGuard } from '../auth/jwt.guard';
+import { SprintSyncService } from './sprint-sync.service';
+import { JwtGuard } from '../auth/jwt.guard';
 import { RoleGuard, Roles } from '../auth/role.guard';
 
 @Controller('api/projects')
 export class ProjectsController {
-  constructor(private readonly projectsService: ProjectsService) {}
+  constructor(
+    private readonly projectsService: ProjectsService,
+    private readonly sprintSyncService: SprintSyncService,
+  ) {}
 
   @Get()
   getProjects() {
@@ -39,4 +43,18 @@ export class ProjectsController {
   ) {
     return this.projectsService.getProjectPulls(id, state ?? 'open');
   }
+
+  @Post(':id/sync-sprints')
+  @UseGuards(JwtGuard, RoleGuard)
+  @Roles('admin')
+  syncSprints(@Param('id', ParseIntPipe) id: number) {
+    return this.sprintSyncService.syncProjectSprints(id);
+  }
+
+  @Post('sync-all-sprints')
+  @UseGuards(JwtGuard, RoleGuard)
+  @Roles('admin')
+  syncAllSprints() {
+    return this.sprintSyncService.syncAllProjectSprints();
+  }
 }

backend/src/projects/projects.module.ts

@@ -1,13 +1,16 @@
 import { Module } from '@nestjs/common';
 import { ProjectsController } from './projects.controller';
 import { ProjectsService } from './projects.service';
+import { SprintSyncService } from './sprint-sync.service';
 import { PrismaModule } from '../prisma/prisma.module';
 import { GiteaModule } from '../gitea/gitea.module';
 import { ActivityModule } from '../activity/activity.module';
+import { AuthModule } from '../auth/auth.module';
 
 @Module({
-  imports: [PrismaModule, GiteaModule, ActivityModule],
+  imports: [PrismaModule, GiteaModule, ActivityModule, AuthModule],
   controllers: [ProjectsController],
-  providers: [ProjectsService],
+  providers: [ProjectsService, SprintSyncService],
+  exports: [ProjectsService, SprintSyncService],
 })
 export class ProjectsModule {}

backend/src/projects/projects.service.ts

@@ -34,8 +34,12 @@ export class ProjectsService {
     }
 
     return dbProjects.map((p) => {
-      const totalTasks = p.sprints.flatMap((s) => s.tasks).length;
+      // Sprint 기반 진행률 (백엔드 task 없어도 동작)
-      const doneTasks = p.sprints.flatMap((s) => s.tasks).filter((t) => t.status === 'done').length;
+      const totalSprints = p.sprints.length;
+      const doneSprints = p.sprints.filter((s) => s.status === 'done').length;
+      const inProgressSprint = p.sprints.find((s) => s.status === 'in_progress');
+
+      const progress = totalSprints > 0 ? Math.round((doneSprints / totalSprints) * 100) : 0;
       const gitea = giteaRepos[p.giteaId];
 
       return {
@@ -45,13 +49,13 @@ export class ProjectsService {
         repoUrl: p.repoUrl,
         description: p.description,
         status: p.status,
-        progress: totalTasks > 0 ? Math.round((doneTasks / totalTasks) * 100) : 0,
+        progress,
-        totalTasks,
+        totalSprints,
-        doneTasks,
+        doneSprints,
         openPRs: gitea?.openPRs ?? 0,
         updatedAt: gitea?.updatedAt ?? p.updatedAt.toISOString(),
-        sprintCount: p.sprints.length,
+        sprintCount: totalSprints,
-        currentSprint: p.sprints.find((s) => s.status === 'in_progress')?.name ?? null,
+        currentSprint: inProgressSprint?.name ?? (doneSprints === totalSprints && totalSprints > 0 ? 'COMPLETED' : null),
       };
     });
   }

backend/src/projects/sprint-sync.service.ts

@@ -0,0 +1,212 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { GiteaService } from '../gitea/gitea.service';
+
+interface ParsedSprint {
+  number: number;
+  name: string;
+  status: 'pending' | 'in_progress' | 'done';
+}
+
+interface ParsedTask {
+  taskId: string;
+  title: string;
+  status: 'pending' | 'done';
+}
+
+function parseSprintName(content: string, filename: string, number: number): string {
+  // 첫 번째 heading에서 이름 추출: # Sprint XXX — 이름 / # SPRINT-XXX: 이름
+  const headingMatch = content.match(/^#\s+(?:SPRINT-\d+|Sprint\s+\d+)[:\s—\-]+(.+)/m);
+  if (headingMatch) return headingMatch[1].trim();
+  return `SPRINT-${String(number).padStart(3, '0')}`;
+}
+
+function inferStatusFromQaContent(qaContent: string): 'done' | null {
+  // QA 파일에 "결과: ✅ PASSED" 또는 "PASSED" 포함 시 done
+  if (/PASSED/i.test(qaContent)) return 'done';
+  return null;
+}
+
+function parseTasks(content: string, sprintStatus: 'pending' | 'in_progress' | 'done'): ParsedTask[] {
+  const lines = content.split(/\r?\n/);
+  const seen = new Set<string>();
+  const tasks: ParsedTask[] = [];
+
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    let match: RegExpMatchArray | null = null;
+    let status: 'pending' | 'done' | null = null;
+
+    // ### TASK-001: title
+    match = line.match(/^#{2,6}\s+(TASK-\d+[A-Z]?)\s*:\s*(.+)$/i);
+    if (match) {
+      status = sprintStatus === 'done' ? 'done' : 'pending';
+    }
+
+    // - [x] TASK-001 title / - [ ] TASK-001 title
+    if (!match) {
+      match = line.match(/^-\s*\[([ xX])\]\s*(TASK-\d+[A-Z]?)\s*[:\-]?\s*(.+)$/i);
+      if (match) {
+        status = /x/i.test(match[1]) ? 'done' : 'pending';
+      }
+    }
+
+    // - TASK-001: title
+    if (!match) {
+      match = line.match(/^-\s*(TASK-\d+[A-Z]?)\s*:\s*(.+)$/i);
+      if (match) {
+        status = sprintStatus === 'done' ? 'done' : 'pending';
+      }
+    }
+
+    // TASK-001: title
+    if (!match) {
+      match = line.match(/^(TASK-\d+[A-Z]?)\s*:\s*(.+)$/i);
+      if (match) {
+        status = sprintStatus === 'done' ? 'done' : 'pending';
+      }
+    }
+
+    if (!match || !status) continue;
+
+    const taskId = (match[1] ?? match[2]).toUpperCase();
+    const title = (match[2] ?? match[3] ?? '').trim();
+    if (!taskId || seen.has(taskId)) continue;
+    seen.add(taskId);
+    tasks.push({ taskId, title: title || taskId, status });
+  }
+
+  return tasks;
+}
+
+@Injectable()
+export class SprintSyncService {
+  private readonly logger = new Logger(SprintSyncService.name);
+
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly gitea: GiteaService,
+  ) {}
+
+  async syncProjectSprints(projectId: number): Promise<{ synced: number; created: number; updated: number }> {
+    const project = await this.prisma.project.findUnique({ where: { id: projectId } });
+    if (!project) return { synced: 0, created: 0, updated: 0 };
+
+    const repoName = project.repoUrl.replace(/\/+$/, '').split('/').pop() ?? '';
+    return this.syncRepo(projectId, repoName);
+  }
+
+  async syncAllProjectSprints(): Promise<{ projects: number; synced: number }> {
+    const projects = await this.prisma.project.findMany({ select: { id: true, repoUrl: true } });
+    let totalSynced = 0;
+
+    for (const project of projects) {
+      const repoName = project.repoUrl.replace(/\/+$/, '').split('/').pop() ?? '';
+      const r = await this.syncRepo(project.id, repoName);
+      totalSynced += r.synced;
+    }
+
+    return { projects: projects.length, synced: totalSynced };
+  }
+
+  private async syncRepo(projectId: number, repoName: string): Promise<{ synced: number; created: number; updated: number }> {
+    const [sprintFilePaths, qaFilePaths] = await Promise.all([
+      this.gitea.getRepoTree(repoName, '.plans/sprints/'),
+      this.gitea.getRepoTree(repoName, '.qa/'),
+    ]);
+
+    const sprintFiles = sprintFilePaths.filter((f) => /SPRINT-\d+\.md$/i.test(f));
+    const qaFiles = qaFilePaths.filter((f) => /SPRINT-\d+-review-.*\.md$/i.test(f));
+
+    if (!sprintFiles.length) {
+      this.logger.warn(`No sprint files found in ${repoName}/.plans/sprints/`);
+      return { synced: 0, created: 0, updated: 0 };
+    }
+
+    // QA 파일에서 PASSED 여부 수집: number → boolean
+    const passedMap = new Map<number, boolean>();
+    for (const qaPath of qaFiles) {
+      const numMatch = qaPath.match(/SPRINT-(\d+)-review/i);
+      if (!numMatch) continue;
+      const num = parseInt(numMatch[1], 10);
+      if (passedMap.get(num)) continue; // 이미 통과 확인됨
+
+      const qaContent = await this.gitea.getRawFile(repoName, qaPath);
+      if (!qaContent) continue;
+      if (inferStatusFromQaContent(qaContent)) {
+        passedMap.set(num, true);
+      }
+    }
+
+    let created = 0;
+    let updated = 0;
+
+    for (const filePath of sprintFiles) {
+      const content = await this.gitea.getRawFile(repoName, filePath);
+      if (!content) continue;
+
+      const filename = filePath.split('/').pop() ?? '';
+      const numMatch = filename.match(/SPRINT-(\d+)/i);
+      if (!numMatch) continue;
+      const number = parseInt(numMatch[1], 10);
+      const name = parseSprintName(content, filename, number);
+
+      // QA 통과 여부로 status 결정 (본문 전체 키워드 검색 금지)
+      const status: 'pending' | 'done' = passedMap.get(number) ? 'done' : 'pending';
+      const parsedTasks = parseTasks(content, status);
+
+      const existing = await this.prisma.sprint.findFirst({
+        where: { projectId, number },
+      });
+
+      let sprintId: number;
+      if (!existing) {
+        const createdSprint = await this.prisma.sprint.create({
+          data: { projectId, number, name, status },
+        });
+        sprintId = createdSprint.id;
+        created++;
+      } else {
+        const updatedSprint = await this.prisma.sprint.update({
+          where: { id: existing.id },
+          data: {
+            name,
+            status: existing.status === 'done' ? 'done' : status,
+          },
+        });
+        sprintId = updatedSprint.id;
+        updated++;
+      }
+
+      // Sprint 문서 기준 Task upsert
+      for (const task of parsedTasks) {
+        const existingTask = await this.prisma.task.findFirst({
+          where: { sprintId, taskId: task.taskId },
+        });
+
+        if (!existingTask) {
+          await this.prisma.task.create({
+            data: {
+              sprintId,
+              taskId: task.taskId,
+              title: task.title,
+              assignee: 'narang',
+              status: task.status,
+            },
+          });
+        } else {
+          await this.prisma.task.update({
+            where: { id: existingTask.id },
+            data: {
+              title: task.title,
+              status: existingTask.status === 'done' ? 'done' : task.status,
+            },
+          });
+        }
+      }
+    }
+
+    this.logger.log(`${repoName}: ${sprintFiles.length} sprints, ${passedMap.size} QA passed → ${created} created, ${updated} updated`);
+    return { synced: sprintFiles.length, created, updated };
+  }
+}

backend/src/settings/settings.controller.ts

@@ -0,0 +1,26 @@
+import { Body, Controller, Get, Put, UseGuards } from '@nestjs/common';
+import { SettingsService } from './settings.service';
+import { JwtGuard } from '../auth/jwt.guard';
+import { RoleGuard, Roles } from '../auth/role.guard';
+
+@Controller('api/admin/settings')
+@UseGuards(JwtGuard, RoleGuard)
+@Roles('admin')
+export class SettingsController {
+  constructor(private readonly settingsService: SettingsService) {}
+
+  @Get()
+  getAll() {
+    return this.settingsService.getAll();
+  }
+
+  @Get('defaults')
+  getDefaults() {
+    return this.settingsService.getDefaults();
+  }
+
+  @Put()
+  saveAll(@Body() body: Record<string, string>) {
+    return this.settingsService.saveAll(body ?? {});
+  }
+}

backend/src/settings/settings.module.ts

@@ -0,0 +1,13 @@
+import { Module } from '@nestjs/common';
+import { SettingsController } from './settings.controller';
+import { SettingsService } from './settings.service';
+import { PrismaModule } from '../prisma/prisma.module';
+import { ActivityModule } from '../activity/activity.module';
+
+@Module({
+  imports: [PrismaModule, ActivityModule],
+  controllers: [SettingsController],
+  providers: [SettingsService],
+  exports: [SettingsService],
+})
+export class SettingsModule {}

backend/src/settings/settings.service.ts

@@ -0,0 +1,58 @@
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from '../prisma/prisma.service';
+import { ActivityService } from '../activity/activity.service';
+
+const DEFAULT_SETTINGS: Record<string, string> = {
+  force2fa: 'true',
+  sessionTimeoutMinutes: '15',
+  ipWhitelistEnabled: 'false',
+  autoBackupEnabled: 'true',
+  backupSchedule: '08:00',
+  retentionDays: '30',
+  queueWarningThreshold: '500',
+  autoScalingEnabled: 'true',
+  cpuThresholdPercent: '90',
+  latencyAlertMs: '250',
+  nodeOfflineAlertEnabled: 'true',
+};
+
+@Injectable()
+export class SettingsService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly activity: ActivityService,
+  ) {}
+
+  async getAll() {
+    const rows = await this.prisma.systemSettings.findMany({ orderBy: { key: 'asc' } });
+    const merged = { ...DEFAULT_SETTINGS };
+    for (const row of rows) merged[row.key] = row.value;
+    return merged;
+  }
+
+  async saveAll(payload: Record<string, string>) {
+    // DEFAULT_SETTINGS에 있는 키만 허용
+    const allowed = Object.keys(DEFAULT_SETTINGS);
+    const entries = Object.entries(payload).filter(([key]) => allowed.includes(key));
+    await this.prisma.$transaction(
+      entries.map(([key, value]) =>
+        this.prisma.systemSettings.upsert({
+          where: { key },
+          update: { value: String(value) },
+          create: { key, value: String(value) },
+        }),
+      ),
+    );
+
+    await this.activity.log({
+      action: 'settings_updated',
+      detail: `System settings updated: ${entries.length} keys`,
+    });
+
+    return this.getAll();
+  }
+
+  getDefaults() {
+    return { ...DEFAULT_SETTINGS };
+  }
+}

backend/src/sisters/avatar.service.ts

@@ -0,0 +1,77 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { SshService } from './ssh.service';
+
+interface AvatarCacheItem {
+  expiresAt: number;
+  contentType: string;
+  data: Buffer;
+}
+
+@Injectable()
+export class AvatarService {
+  private readonly logger = new Logger(AvatarService.name);
+  private readonly cache = new Map<string, AvatarCacheItem>();
+  private readonly ttlMs = 5 * 60 * 1000;
+
+  constructor(
+    private readonly ssh: SshService,
+    private readonly config: ConfigService,
+  ) {}
+
+  async getAvatar(sister: { name: string; ip: string; user: string }) {
+    const cached = this.cache.get(sister.name);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached;
+    }
+
+    const sshKeyPath = this.config.get<string>('SSH_KEY_PATH');
+    if (!sshKeyPath) {
+      return this.getFallback(sister.name);
+    }
+
+    const files = [
+      { path: '~/.openclaw/avatar.png', type: 'image/png' },
+      { path: '~/.openclaw/avatar.jpg', type: 'image/jpeg' },
+      { path: '~/.openclaw/avatar.jpeg', type: 'image/jpeg' },
+      { path: '~/.openclaw/avatar.webp', type: 'image/webp' },
+    ];
+
+    for (const file of files) {
+      try {
+        const result = await this.ssh.executeCommand(
+          sister.ip,
+          sister.user,
+          sshKeyPath,
+          `if [ -f ${file.path} ]; then base64 -w0 ${file.path}; fi`,
+        );
+
+        if (result.stdout.trim()) {
+          const item = {
+            contentType: file.type,
+            data: Buffer.from(result.stdout.trim(), 'base64'),
+            expiresAt: Date.now() + this.ttlMs,
+          };
+          this.cache.set(sister.name, item);
+          return item;
+        }
+      } catch {
+        this.logger.warn(`Avatar fetch failed for ${sister.name}`);
+        // 실패 시 오래된 캐시 삭제 (다음 요청에서 재시도)
+        this.cache.delete(sister.name);
+      }
+    }
+
+    return this.getFallback(sister.name);
+  }
+
+  private getFallback(name: string) {
+    const initial = name.slice(0, 1).toUpperCase();
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="128" height="128"><rect width="100%" height="100%" fill="#111"/><text x="50%" y="54%" dominant-baseline="middle" text-anchor="middle" font-family="Arial" font-size="56" fill="#f5f5f5">${initial}</text></svg>`;
+    return {
+      contentType: 'image/svg+xml',
+      data: Buffer.from(svg),
+      expiresAt: Date.now() + this.ttlMs,
+    };
+  }
+}

backend/src/sisters/sisters.controller.ts

@@ -1,14 +1,17 @@
-import { Controller, Get, Param } from '@nestjs/common';
+import { Controller, Get, Param, Res } from '@nestjs/common';
+import type { Response } from 'express';
 import { SistersService } from './sisters.service';
 import { SisterDetailService } from './sister-detail.service';
 import { SisterNamePipe } from '../common/sister-name.pipe';
 import type { SisterName } from '../common/sister-name.pipe';
+import { AvatarService } from './avatar.service';
 
 @Controller('api/sisters')
 export class SistersController {
   constructor(
     private readonly sistersService: SistersService,
     private readonly sisterDetail: SisterDetailService,
+    private readonly avatarService: AvatarService,
   ) {}
 
   @Get()
@@ -16,6 +19,27 @@ export class SistersController {
     return this.sistersService.getAllSistersStatus();
   }
 
+  @Get(':name/system')
+  async getSystemInfo(@Param('name', SisterNamePipe) name: SisterName) {
+    return this.sistersService.getSystemInfo(name as SisterName);
+  }
+
+  @Get(':name/avatar')
+  async getAvatar(
+    @Param('name', SisterNamePipe) name: SisterName,
+    @Res() res: Response,
+  ) {
+    const sister = await this.sistersService.findByName(name as SisterName);
+    if (!sister) {
+      return res.status(404).json({ message: 'Sister not found' });
+    }
+
+    const avatar = await this.avatarService.getAvatar(sister);
+    res.setHeader('Content-Type', avatar.contentType);
+    res.setHeader('Cache-Control', 'public, max-age=300');
+    return res.send(avatar.data);
+  }
+
   @Get(':name/config')
   async getSisterConfig(@Param('name', SisterNamePipe) name: SisterName) {
     return this.sisterDetail.getSisterConfig(name as SisterName);

backend/src/sisters/sisters.module.ts

@@ -4,11 +4,13 @@ import { SistersService } from './sisters.service';
 import { SisterDetailService } from './sister-detail.service';
 import { SshService } from './ssh.service';
 import { PrismaModule } from '../prisma/prisma.module';
+import { ConfigModule } from '@nestjs/config';
+import { AvatarService } from './avatar.service';
 
 @Module({
-  imports: [PrismaModule],
+  imports: [PrismaModule, ConfigModule],
   controllers: [SistersController],
-  providers: [SistersService, SisterDetailService, SshService],
+  providers: [SistersService, SisterDetailService, SshService, AvatarService],
-  exports: [SistersService, SisterDetailService, SshService],
+  exports: [SistersService, SisterDetailService, SshService, AvatarService],
 })
 export class SistersModule {}

backend/src/sisters/sisters.service.ts

@@ -48,7 +48,6 @@ export class SistersService {
       if (result.status === 'fulfilled') {
         return result.value;
       }
-      // graceful fallback
       const sister = sisters[index];
       return {
         id: sister.id,
@@ -63,6 +62,31 @@ export class SistersService {
     });
   }
 
+  async findByName(name: string) {
+    return this.prisma.sisterConfig.findUnique({ where: { name } });
+  }
+
+  async getSystemInfo(name: string) {
+    const sister = await this.prisma.sisterConfig.findUnique({ where: { name } });
+    if (!sister) return null;
+    const sshKeyPath = this.config.get<string>('SSH_KEY_PATH');
+    if (!sshKeyPath) return null;
+
+    const [uptimeRes, cpuRes, memRes, diskRes] = await Promise.all([
+      this.ssh.executeCommand(sister.ip, sister.user, sshKeyPath, 'cat /proc/uptime 2>/dev/null || echo "0 0"').catch(() => ({ stdout: '0 0', stderr: '', code: 0 })),
+      this.ssh.executeCommand(sister.ip, sister.user, sshKeyPath, "top -bn1 | grep Cpu || echo '%Cpu(s): 0.0 us, 0.0 sy, 100.0 id'").catch(() => ({ stdout: '%Cpu(s): 0.0 us, 0.0 sy, 100.0 id', stderr: '', code: 0 })),
+      this.ssh.executeCommand(sister.ip, sister.user, sshKeyPath, 'free -m | grep Mem || echo "Mem: 0 0 0 0 0 0"').catch(() => ({ stdout: 'Mem: 0 0 0 0 0 0', stderr: '', code: 0 })),
+      this.ssh.executeCommand(sister.ip, sister.user, sshKeyPath, "df -h / | tail -1 || echo '/dev/root 0G 0G 0G 0% /'").catch(() => ({ stdout: '/dev/root 0G 0G 0G 0% /', stderr: '', code: 0 })),
+    ]);
+
+    return {
+      uptime: this.parseUptime(uptimeRes.stdout),
+      cpu: this.parseCpu(cpuRes.stdout),
+      memory: this.parseMemory(memRes.stdout),
+      disk: this.parseDisk(diskRes.stdout),
+    };
+  }
+
   private async checkSisterStatus(
     sister: { id: number; name: string; ip: string; user: string; lxcId: number; lastSeen: Date | null; status: string },
     sshKeyPath: string,
@@ -77,22 +101,20 @@ export class SistersService {
 
       const isActive = result.stdout.trim() === 'active';
       const status: 'online' | 'offline' = isActive ? 'online' : 'offline';
-
-      if (isActive) {
-        // 온라인이면 lastSeen 업데이트 + 상태 변경 감지
       const prevStatus = sister.status;
+      const now = new Date();
+
       await this.prisma.sisterConfig.update({
         where: { id: sister.id },
-          data: { lastSeen: new Date(), status },
+        data: { lastSeen: isActive ? now : sister.lastSeen, status },
       });
-        // 상태 변경 시 ActivityLog 기록
+
       if (prevStatus !== status && this.activity) {
         await this.activity.log({
           sisterId: sister.id,
           action: 'status_changed',
           detail: `[${sister.name}] status: ${prevStatus} → ${status}`,
-          }).catch(() => {}); // 비동기 오류 무시
+        }).catch(() => {});
-        }
       }
 
       return {
@@ -102,7 +124,7 @@ export class SistersService {
         lxcId: sister.lxcId,
         role: SISTER_ROLES[sister.name] ?? 'Unknown',
         status,
-        lastSeen: isActive ? new Date() : sister.lastSeen,
+        lastSeen: isActive ? now : sister.lastSeen,
         currentTask: null,
       };
     } catch {
@@ -119,4 +141,30 @@ export class SistersService {
       };
     }
   }
+
+  private parseUptime(stdout: string) {
+    const sec = Math.floor(parseFloat(stdout.split(' ')[0] || '0'));
+    const h = Math.floor(sec / 3600);
+    const m = Math.floor((sec % 3600) / 60);
+    const s = sec % 60;
+    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(s).padStart(2, '0')}`;
+  }
+
+  private parseCpu(stdout: string) {
+    const idleMatch = stdout.match(/([0-9]+(?:\.[0-9]+)?)\s*id/);
+    const idle = idleMatch ? parseFloat(idleMatch[1]) : 100;
+    return Math.max(0, Math.min(100, Number((100 - idle).toFixed(1))));
+  }
+
+  private parseMemory(stdout: string) {
+    const parts = stdout.trim().split(/\s+/);
+    const total = parseInt(parts[1] || '0', 10);
+    const used = parseInt(parts[2] || '0', 10);
+    return { used, total };
+  }
+
+  private parseDisk(stdout: string) {
+    const parts = stdout.trim().split(/\s+/);
+    return { used: parts[2] || '0G', total: parts[1] || '0G' };
+  }
 }

frontend/app/admin/layout.tsx

@@ -1,10 +1,9 @@
 'use client';
 
-import React, { useState, useEffect } from 'react';
+import React from 'react';
 import styled from 'styled-components';
 import Link from 'next/link';
 import { usePathname } from 'next/navigation';
-import { LabelMeta, SectionTitle } from '@/components/ui/base';
 
 const ADMIN_TABS = [
   { href: '/admin', label: '자매 관리' },
@@ -39,46 +38,11 @@ const TabLink = styled(Link)<{ $active: boolean }>`
   padding: var(--space-sm) 0;
   border-bottom: 1px solid ${({ $active }) => $active ? 'var(--text-primary)' : 'transparent'};
   transition: color 0.15s, border-color 0.15s;
-
   &:hover { color: var(--text-primary); }
 `;
 
-const ApiKeyRow = styled.div`
-  display: flex;
-  align-items: center;
-  gap: var(--space-sm);
-  font-family: var(--font-mono);
-  font-size: 12px;
-  color: var(--text-secondary);
-`;
-
-const ApiKeyInput = styled.input`
-  background: transparent;
-  border: none;
-  border-bottom: 1px solid var(--border-color);
-  color: var(--text-primary);
-  font-family: var(--font-mono);
-  font-size: 12px;
-  outline: none;
-  flex: 1;
-  max-width: 300px;
-  padding: 2px 0;
-
-  &:focus { border-bottom-color: var(--text-primary); }
-`;
-
 export default function AdminLayout({ children }: { children: React.ReactNode }) {
   const pathname = usePathname();
-  const [apiKey, setApiKey] = useState('');
-
-  useEffect(() => {
-    setApiKey(localStorage.getItem('hanarang_admin_key') ?? '');
-  }, []);
-
-  const saveKey = (v: string) => {
-    setApiKey(v);
-    localStorage.setItem('hanarang_admin_key', v);
-  };
 
   return (
     <Wrapper>
@@ -94,18 +58,6 @@ export default function AdminLayout({ children }: { children: React.ReactNode })
           ))}
         </TabNav>
       </AdminHeader>
-
-      <ApiKeyRow>
-        <span>KEY [</span>
-        <ApiKeyInput
-          type="password"
-          placeholder="ADMIN_API_KEY"
-          value={apiKey}
-          onChange={(e) => saveKey(e.target.value)}
-        />
-        <span>]</span>
-      </ApiKeyRow>
-
       {children}
     </Wrapper>
   );

frontend/app/login/page.tsx

@@ -2,7 +2,6 @@
 
 import React, { useState } from 'react';
 import styled from 'styled-components';
-import Link from 'next/link';
 import { useAuth } from '@/lib/AuthContext';
 import { useRouter } from 'next/navigation';
 
@@ -111,16 +110,6 @@ const ErrorMsg = styled.div`
   background: rgba(255,95,95,0.05);
 `;
 
-const FooterLink = styled.div`
-  margin-top: var(--space-lg);
-  font-size: 12px;
-  color: var(--text-secondary);
-  font-family: var(--font-mono);
-  text-align: center;
-
-  a { color: var(--text-primary); text-decoration: none;
-    &:hover { text-decoration: underline; } }
-`;
 
 export default function LoginPage() {
   const [username, setUsername] = useState('');
@@ -180,9 +169,6 @@ export default function LoginPage() {
           </SubmitBtn>
         </Form>
 
-        <FooterLink>
-          계정 없음? <Link href="/register">REGISTER</Link>
-        </FooterLink>
               </Box>
     </Page>
   );

frontend/app/page.tsx

@@ -1,7 +1,7 @@
 'use client';
 
 import React, { useEffect, useState, useCallback } from 'react';
-import styled from 'styled-components';
+import styled, { keyframes } from 'styled-components';
 import Link from 'next/link';
 import {
   PageHeader, PageTitle, Card, BracketValue, LabelMeta,
@@ -10,249 +10,95 @@ import {
 } from '@/components/ui/base';
 import { API_URL, POLL_INTERVAL_MS } from '@/lib/config';
 import { useSocket } from '@/lib/useSocket';
+import SisterAvatar from '@/components/common/SisterAvatar';
 
-// ─── Styled ───
+const pulse = keyframes`0%{opacity:.35}50%{opacity:.7}100%{opacity:.35}`;
-const StatusGrid = styled.section`
+const StatusGrid = styled.section`display:grid;grid-template-columns:repeat(4,1fr);gap:var(--space-lg);@media (min-width:768px) and (max-width:1199px){grid-template-columns:repeat(2,1fr)}@media (max-width:767px){grid-template-columns:repeat(2,1fr);gap:var(--space-md)}`;
-  display: grid;
+const DataColumns = styled.div`display:grid;grid-template-columns:1.5fr 1fr;gap:var(--space-xxl);align-items:start;@media (max-width:1199px){grid-template-columns:1fr;gap:var(--space-xl)}}`;
-  grid-template-columns: repeat(4, 1fr);
+const ProjectList = styled.div`display:flex;flex-direction:column;`;
-  gap: var(--space-lg);
+const ProjectRow = styled(Link)`display:grid;grid-template-columns:40px 1fr auto;gap:var(--space-md);padding:var(--space-md) 0;border-bottom:1px solid #222;align-items:center;text-decoration:none;transition:opacity .15s;&:last-child{border-bottom:none}&:hover{opacity:.8}`;
+const Avatar = styled.div`width:32px;height:32px;border-radius:50%;background-color:#333;overflow:hidden;filter:grayscale(100%) contrast(120%);flex-shrink:0;display:flex;align-items:center;justify-content:center;font-size:14px;`;
+const ProjectDetails = styled.div`display:flex;flex-direction:column;gap:2px;min-width:0;`;
+const ProjectName = styled.div`font-size:15px;font-weight:500;color:var(--text-primary);white-space:nowrap;overflow:hidden;text-overflow:ellipsis;`;
+const ProjectDesc = styled.div`font-size:13px;color:var(--text-secondary);line-height:1.4;white-space:nowrap;overflow:hidden;text-overflow:ellipsis;`;
+const WsIndicator = styled.span<{ $on:boolean }>`font-size:11px;font-family:var(--font-mono);color:${({$on})=>$on?'var(--text-secondary)':'#333'};margin-left:var(--space-md);`;
+const SkeletonCard = styled.div`height:142px;border:1px solid var(--border-color);background:#111;animation:${pulse} 1.4s ease-in-out infinite;`;
+const SkeletonLine = styled.div`height:14px;background:#111;animation:${pulse} 1.4s ease-in-out infinite;margin:10px 0;`;
+const ErrorBox = styled.div`padding:var(--space-md);border:1px solid #5a2a2a;color:#ff9b9b;font-size:13px;margin-bottom:var(--space-lg);`;
 
-  @media (min-width: 768px) and (max-width: 1199px) {
+const SISTER_SHORT: Record<string, string> = { harang: '하랑', narang: '나랑', darang: '다랑', erang: '이랑' };
-    grid-template-columns: repeat(2, 1fr);
+function sisterBracketValue(s: any): string { if (s.status === 'online') return '[ON]'; if (s.status === 'working') return '[RUN]'; if (s.status === 'offline') return '[--]'; return '[??]'; }
-  }
+function sisterBarWidth(s: any): number { if (typeof s.cpu === 'number') return Math.max(0, Math.min(100, s.cpu)); if (s.status === 'online') return 100; if (s.status === 'working') return 84; if (s.status === 'offline') return 0; return 12; }
-
+function sisterSubLabel(s: any): string { if (s.uptime) return `Uptime ${s.uptime}`; return s.status; }
-  @media (max-width: 767px) {
+function formatTimestamp(iso: string): string { const d = new Date(iso); return d.toLocaleTimeString('ko-KR', { hour12: false }) + ' GMT+9'; }
-    grid-template-columns: repeat(2, 1fr);
-    gap: var(--space-md);
-  }
-`;
-
-const DataColumns = styled.div`
-  display: grid;
-  grid-template-columns: 1.5fr 1fr;
-  gap: var(--space-xxl);
-  align-items: start;
-
-  @media (max-width: 1199px) {
-    grid-template-columns: 1fr;
-    gap: var(--space-xl);
-  }
-`;
-
-const ProjectList = styled.div`
-  display: flex;
-  flex-direction: column;
-`;
-
-const ProjectRow = styled(Link)`
-  display: grid;
-  grid-template-columns: 40px 1fr auto;
-  gap: var(--space-md);
-  padding: var(--space-md) 0;
-  border-bottom: 1px solid #222;
-  align-items: center;
-  text-decoration: none;
-  transition: opacity 0.15s;
-
-  &:last-child { border-bottom: none; }
-  &:hover { opacity: 0.8; }
-`;
-
-const Avatar = styled.div`
-  width: 32px;
-  height: 32px;
-  border-radius: 50%;
-  background-color: #333;
-  overflow: hidden;
-  filter: grayscale(100%) contrast(120%);
-  flex-shrink: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  font-size: 14px;
-`;
-
-const ProjectDetails = styled.div`
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-  min-width: 0;
-`;
-
-const ProjectName = styled.div`
-  font-size: 15px;
-  font-weight: 500;
-  color: var(--text-primary);
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-`;
-
-const ProjectDesc = styled.div`
-  font-size: 13px;
-  color: var(--text-secondary);
-  line-height: 1.4;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-`;
-
-const WsIndicator = styled.span<{ $on: boolean }>`
-  font-size: 11px;
-  font-family: var(--font-mono);
-  color: ${({ $on }) => $on ? 'var(--text-secondary)' : '#333'};
-  margin-left: var(--space-md);
-`;
-
-// ─── Helpers ───
-const SISTER_SHORT: Record<string, string> = {
-  harang: '하랑', narang: '나랑', darang: '다랑', erang: '이랑',
-};
-
-const SISTER_SUB_LABEL: Record<string, string> = {
-  harang: 'Active Node',
-  narang: 'Capacity %',
-  darang: 'Standby',
-  erang: 'Sync Queue',
-};
-
-function sisterBracketValue(s: any): string {
-  if (s.status === 'online') return '[ON]';
-  if (s.status === 'working') return '[RUN]';
-  if (s.status === 'offline') return '[--]';
-  return '[??]';
-}
-
-function sisterBarWidth(s: any): number {
-  if (s.status === 'online') return 100;
-  if (s.status === 'working') return 84;
-  if (s.status === 'offline') return 0;
-  return 12;
-}
-
-function formatTimestamp(iso: string): string {
-  const d = new Date(iso);
-  return d.toLocaleTimeString('ko-KR', { hour12: false }) + ' GMT+9';
-}
-
-const MOCK_SISTERS = [
-  { id: 1, name: 'harang', status: 'online', lastSeen: null, currentTask: null },
-  { id: 2, name: 'narang', status: 'working', lastSeen: null, currentTask: null },
-  { id: 3, name: 'darang', status: 'offline', lastSeen: null, currentTask: null },
-  { id: 4, name: 'erang', status: 'online', lastSeen: null, currentTask: null },
-];
 
 export default function DashboardPage() {
-  const [sisters, setSisters] = useState<any[]>(MOCK_SISTERS);
+  const [sisters, setSisters] = useState<any[]>([]);
   const [projects, setProjects] = useState<any[]>([]);
   const [activityItems, setActivityItems] = useState<any[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
 
   const handleSistersUpdate = useCallback((s: any[]) => setSisters(s), []);
-  const handleActivityNew = useCallback((item: any) => {
+  const handleActivityNew = useCallback((item: any) => setActivityItems((prev) => [item, ...prev].slice(0, 10)), []);
-    setActivityItems((prev) => [item, ...prev].slice(0, 10));
-  }, []);
   const { connected } = useSocket({ onSistersUpdate: handleSistersUpdate, onActivityNew: handleActivityNew });
 
   useEffect(() => {
-    const fetch_ = async () => {
+    let active = true;
+    const fetchAll = async () => {
       try {
         const [sRes, pRes, aRes] = await Promise.allSettled([
           fetch(`${API_URL}/api/sisters`),
           fetch(`${API_URL}/api/projects`),
           fetch(`${API_URL}/api/activity?limit=8`),
         ]);
+        if (!active) return;
         if (sRes.status === 'fulfilled' && sRes.value.ok) setSisters(await sRes.value.json());
         if (pRes.status === 'fulfilled' && pRes.value.ok) setProjects(await pRes.value.json());
-        if (aRes.status === 'fulfilled' && aRes.value.ok) {
+        if (aRes.status === 'fulfilled' && aRes.value.ok) setActivityItems((await aRes.value.json()).items ?? []);
-          const d = await aRes.value.json();
+        setError(null);
-          setActivityItems(d.items ?? []);
+      } catch {
+        if (active) setError('데이터를 불러올 수 없습니다');
+      } finally {
+        if (active) setLoading(false);
       }
-      } catch { /* silent */ }
     };
-    fetch_();
+    fetchAll();
-    const iv = setInterval(fetch_, POLL_INTERVAL_MS);
+    const iv = setInterval(fetchAll, POLL_INTERVAL_MS);
-    return () => clearInterval(iv);
+    return () => { active = false; clearInterval(iv); };
   }, []);
 
   return (
     <>
-      <PageHeader>
+      <PageHeader><PageTitle>하나랑 대시보드<WsIndicator $on={connected}>● {connected ? 'LIVE' : 'POLL'}</WsIndicator></PageTitle></PageHeader>
-        <PageTitle>
+      {error && <ErrorBox>{error}</ErrorBox>}
-          하나랑 대시보드
-          <WsIndicator $on={connected}>● {connected ? 'LIVE' : 'POLL'}</WsIndicator>
-        </PageTitle>
-      </PageHeader>
-
-      {/* 상태 카드 */}
       <StatusGrid>
-        {sisters.map((s) => (
+        {loading ? Array.from({ length: 4 }).map((_, i) => <SkeletonCard key={i} />) : sisters.map((s) => (
           <Card key={s.id ?? s.name} as={Link} href={`/sisters/${s.name}`} style={{ textDecoration: 'none' }}>
-            <div style={{ display: 'flex', justifyContent: 'space-between' }}>
+            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
               <LabelMeta><span>SYS:</span>{SISTER_SHORT[s.name] ?? s.name}</LabelMeta>
+              <SisterAvatar name={s.name} size={24} />
             </div>
-            <div style={{ display: 'flex', flexDirection: 'column', gap: 'var(--space-xs)' }}>
+            <div style={{ display: 'flex', flexDirection: 'column', gap: 'var(--space-xs)' }}><BracketValue $dimmed={s.status === 'offline'}>{sisterBracketValue(s)}</BracketValue><LabelMeta>{sisterSubLabel(s)}</LabelMeta></div>
-              <BracketValue $dimmed={s.status === 'offline'}>
+            <TechBar><TechBarFill $width={sisterBarWidth(s)} /></TechBar>
-                {sisterBracketValue(s)}
-              </BracketValue>
-              <LabelMeta>{SISTER_SUB_LABEL[s.name] ?? s.status}</LabelMeta>
-            </div>
-            <TechBar>
-              <TechBarFill $width={sisterBarWidth(s)} />
-            </TechBar>
           </Card>
         ))}
       </StatusGrid>
-
-      {/* 하단 2열 */}
       <DataColumns>
-        {/* ONGOING PROJECTS */}
         <section>
-          <SectionTitle>
+          <SectionTitle><span>ONGOING PROJECTS</span><LabelMeta>VOL: {String(projects.length).padStart(2, '0')}</LabelMeta></SectionTitle>
-            <span>ONGOING PROJECTS</span>
-            <LabelMeta>VOL: {String(projects.length).padStart(2, '0')}</LabelMeta>
-          </SectionTitle>
           <ProjectList>
-            {projects.length === 0 ? (
+            {loading ? Array.from({ length: 4 }).map((_, i) => <SkeletonLine key={i} />) : projects.length === 0 ? <div style={{ color: 'var(--text-secondary)', fontSize: '13px', padding: 'var(--space-md) 0' }}>등록된 프로젝트 없음</div> : projects.map((p) => (
-              <div style={{ color: 'var(--text-secondary)', fontSize: '13px', padding: 'var(--space-md) 0' }}>
+              <ProjectRow key={p.id} href={`/projects/${p.id}`}><Avatar>📁</Avatar><ProjectDetails><ProjectName>{p.name}</ProjectName><ProjectDesc>{p.description ?? p.currentSprint ?? ''}</ProjectDesc></ProjectDetails><LabelMeta>{p.currentSprint ?? p.status?.toUpperCase() ?? 'ACTIVE'}</LabelMeta></ProjectRow>
-                등록된 프로젝트 없음
+            ))}
-              </div>
-            ) : (
-              projects.map((p) => (
-                <ProjectRow key={p.id} href={`/projects/${p.id}`}>
-                  <Avatar>📁</Avatar>
-                  <ProjectDetails>
-                    <ProjectName>{p.name}</ProjectName>
-                    <ProjectDesc>{p.description ?? p.currentSprint ?? ''}</ProjectDesc>
-                  </ProjectDetails>
-                  <LabelMeta>{p.currentSprint ?? p.status?.toUpperCase() ?? 'ACTIVE'}</LabelMeta>
-                </ProjectRow>
-              ))
-            )}
           </ProjectList>
         </section>
-
-        {/* ACTIVITY FEED */}
         <section>
-          <SectionTitle>
+          <SectionTitle><span>ACTIVITY FEED</span><LabelMeta>{connected ? 'LIVE' : 'FEED'}</LabelMeta></SectionTitle>
-            <span>ACTIVITY FEED</span>
-            <LabelMeta>{connected ? 'LIVE' : 'FEED'}</LabelMeta>
-          </SectionTitle>
           <Timeline>
-            {activityItems.length === 0 ? (
+            {loading ? Array.from({ length: 5 }).map((_, i) => <SkeletonLine key={i} />) : activityItems.length === 0 ? <div style={{ color: 'var(--text-secondary)', fontSize: '13px', paddingLeft: 'var(--space-lg)' }}>활동 기록 없음</div> : activityItems.map((item) => (
-              <div style={{ color: 'var(--text-secondary)', fontSize: '13px', paddingLeft: 'var(--space-lg)' }}>
+              <TimelineItem key={item.id}><TimeStamp>{formatTimestamp(item.createdAt)}</TimeStamp><TimelineContent>{item.sister && <strong>{item.sister.name} </strong>}{item.detail ?? item.action}</TimelineContent></TimelineItem>
-                활동 기록 없음
+            ))}
-              </div>
-            ) : (
-              activityItems.map((item) => (
-                <TimelineItem key={item.id}>
-                  <TimeStamp>{formatTimestamp(item.createdAt)}</TimeStamp>
-                  <TimelineContent>
-                    {item.sister && <strong>{item.sister.name} </strong>}
-                    {item.detail ?? item.action}
-                  </TimelineContent>
-                </TimelineItem>
-              ))
-            )}
           </Timeline>
         </section>
       </DataColumns>

frontend/app/projects/page.tsx

@@ -104,7 +104,7 @@ export default function ProjectsPage() {
     try {
       const res = await adminFetch('/api/admin/gitea/sync', { method: 'POST' });
       const d = await res.json();
-      setSyncResult(`sync: ${d.created ?? 0} created, ${d.updated ?? 0} updated`);
+      setSyncResult(`sync: ${d.created ?? 0} new, ${d.updated ?? 0} updated`);
       loadProjects();
     } catch (e) {
       setSyncResult('sync failed');
@@ -113,6 +113,21 @@ export default function ProjectsPage() {
     }
   };
 
+  const handleSprintSync = async () => {
+    setSyncing(true);
+    setSyncResult(null);
+    try {
+      const res = await adminFetch('/api/projects/sync-all-sprints', { method: 'POST' });
+      const d = await res.json();
+      setSyncResult(`sprint sync: ${d.synced ?? 0} synced across ${d.projects ?? 0} projects`);
+      loadProjects();
+    } catch (e) {
+      setSyncResult('sprint sync failed');
+    } finally {
+      setSyncing(false);
+    }
+  };
+
   useEffect(() => { loadProjects(); }, []);
 
   return (
@@ -129,6 +144,9 @@ export default function ProjectsPage() {
           <Btn onClick={handleSync} disabled={syncing}>
             {syncing ? 'SYNCING...' : '↻ GITEA SYNC'}
           </Btn>
+          <Btn onClick={handleSprintSync} disabled={syncing}>
+            {syncing ? '...' : '↻ SPRINT SYNC'}
+          </Btn>
         </div>
       </div>
 

frontend/app/register/page.tsx

@@ -1,215 +1,9 @@
 'use client';
-
+import { useEffect } from 'react';
-import React, { useState } from 'react';
-import styled from 'styled-components';
-import Link from 'next/link';
 import { useRouter } from 'next/navigation';
-import { API_URL } from '@/lib/config';
-
-const Page = styled.div`
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  min-height: 100vh;
-  background: var(--bg-main);
-`;
-
-const Box = styled.div`
-  width: 100%;
-  max-width: 360px;
-  padding: var(--space-xl);
-`;
-
-const Logo = styled.div`
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  margin-bottom: var(--space-xxl);
-`;
-
-const CircleFull = styled.div`
-  width: 20px; height: 20px;
-  background: var(--text-primary);
-  border-radius: 50%;
-`;
-
-const CircleHalf = styled.div`
-  width: 10px; height: 20px;
-  background: var(--text-primary);
-  border-radius: 0 20px 20px 0;
-`;
-
-const Title = styled.h1`
-  font-size: 20px;
-  font-weight: 600;
-  color: var(--text-primary);
-  margin-bottom: var(--space-xs);
-  letter-spacing: -0.02em;
-`;
-
-const Subtitle = styled.p`
-  font-size: 12px;
-  color: var(--text-secondary);
-  font-family: var(--font-mono);
-  margin-bottom: var(--space-xl);
-`;
-
-const Form = styled.form`
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-md);
-`;
-
-const FieldLabel = styled.label`
-  font-size: 11px;
-  font-weight: 700;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-  color: var(--text-secondary);
-  margin-bottom: var(--space-xs);
-  display: block;
-`;
-
-const Input = styled.input`
-  width: 100%;
-  background: var(--bg-input);
-  border: 1px solid var(--border-color);
-  color: var(--text-primary);
-  padding: 10px 12px;
-  font-family: var(--font-mono);
-  font-size: 13px;
-  outline: none;
-  transition: border-color 0.15s;
-
-  &:focus { border-color: var(--border-hover); }
-  &::placeholder { color: var(--text-secondary); opacity: 0.5; }
-`;
-
-const SubmitBtn = styled.button`
-  background: var(--text-primary);
-  border: 1px solid var(--text-primary);
-  color: #000;
-  font-size: 12px;
-  font-weight: 700;
-  text-transform: uppercase;
-  letter-spacing: 0.05em;
-  padding: 12px;
-  cursor: pointer;
-  transition: all 0.15s;
-  margin-top: var(--space-sm);
-
-  &:hover { background: transparent; color: var(--text-primary); }
-  &:disabled { opacity: 0.5; cursor: not-allowed; }
-`;
-
-const ErrorMsg = styled.div`
-  font-family: var(--font-mono);
-  font-size: 11px;
-  color: #ff5f5f;
-  padding: var(--space-sm);
-  border: 1px solid #ff5f5f44;
-  background: rgba(255,95,95,0.05);
-`;
-
-const SuccessMsg = styled.div`
-  font-family: var(--font-mono);
-  font-size: 11px;
-  color: #00FF00;
-  padding: var(--space-sm);
-  border: 1px solid rgba(0,255,0,0.3);
-  background: rgba(0,255,0,0.03);
-`;
-
-const FooterLink = styled.div`
-  margin-top: var(--space-lg);
-  font-size: 12px;
-  color: var(--text-secondary);
-  font-family: var(--font-mono);
-  text-align: center;
-
-  a { color: var(--text-primary); text-decoration: none;
-    &:hover { text-decoration: underline; } }
-`;
-
-const InviteNote = styled.div`
-  font-family: var(--font-mono);
-  font-size: 10px;
-  color: var(--text-secondary);
-  opacity: 0.6;
-  margin-top: 4px;
-`;
 
 export default function RegisterPage() {
-  const [form, setForm] = useState({ username: '', password: '', inviteCode: '' });
-  const [error, setError] = useState('');
-  const [success, setSuccess] = useState('');
-  const [loading, setLoading] = useState(false);
   const router = useRouter();
-
+  useEffect(() => { router.replace('/login'); }, [router]);
-  const handleSubmit = async (e: React.FormEvent) => {
+  return null;
-    e.preventDefault();
-    setError('');
-    setSuccess('');
-    setLoading(true);
-
-    try {
-      const res = await fetch(`${API_URL}/api/auth/register`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(form),
-      });
-
-      const d = await res.json();
-      if (!res.ok) {
-        setError(Array.isArray(d.message) ? d.message[0] : (d.message ?? '등록 실패'));
-        return;
-      }
-
-      localStorage.setItem('hanarang_access_token', d.accessToken);
-      setSuccess('등록 완료. 대시보드로 이동...');
-      setTimeout(() => router.push('/'), 1000);
-    } catch (err) {
-      setError((err as Error).message);
-    } finally {
-      setLoading(false);
-    }
-  };
-
-  const set = (key: string) => (e: React.ChangeEvent<HTMLInputElement>) =>
-    setForm((p) => ({ ...p, [key]: e.target.value }));
-
-  return (
-    <Page>
-      <Box>
-        <Logo><CircleFull /><CircleHalf /></Logo>
-        <Title>계정 등록</Title>
-        <Subtitle>SYSTEM_ACCESS // REGISTER_NEW_NODE</Subtitle>
-
-        <Form onSubmit={handleSubmit}>
-          <div>
-            <FieldLabel>USERNAME</FieldLabel>
-            <Input type="text" placeholder="username" value={form.username} onChange={set('username')} required />
-          </div>
-          <div>
-            <FieldLabel>PASSWORD</FieldLabel>
-            <Input type="password" placeholder="•••••••• (8자 이상)" value={form.password} onChange={set('password')} required minLength={8} />
-          </div>
-          <div>
-            <FieldLabel>INVITE CODE</FieldLabel>
-            <Input type="text" placeholder="초대 코드" value={form.inviteCode} onChange={set('inviteCode')} required />
-            <InviteNote>관리자에게 초대 코드를 요청하세요</InviteNote>
-          </div>
-          {error && <ErrorMsg>ERR: {error}</ErrorMsg>}
-          {success && <SuccessMsg>✓ {success}</SuccessMsg>}
-          <SubmitBtn type="submit" disabled={loading}>
-            {loading ? 'REGISTERING...' : 'REGISTER'}
-          </SubmitBtn>
-        </Form>
-
-        <FooterLink>
-          이미 계정 있음? <Link href="/login">LOGIN</Link>
-        </FooterLink>
-      </Box>
-    </Page>
-  );
 }

frontend/app/settings/page.tsx

@@ -1,23 +1,37 @@
 'use client';
 
-import React, { useState } from 'react';
+import React, { useEffect, useState } from 'react';
-import styled from 'styled-components';
+import styled, { keyframes } from 'styled-components';
 import { PageTitle, LabelMeta, SectionTitle, Btn, BtnPrimary } from '@/components/ui/base';
+import { adminFetch } from '@/lib/adminFetch';
+
+const DEFAULT_SETTINGS = {
+  force2fa: 'true',
+  sessionTimeoutMinutes: '15',
+  ipWhitelistEnabled: 'false',
+  autoBackupEnabled: 'true',
+  backupSchedule: '08:00',
+  retentionDays: '30',
+  queueWarningThreshold: '500',
+  autoScalingEnabled: 'true',
+  cpuThresholdPercent: '90',
+  latencyAlertMs: '250',
+  nodeOfflineAlertEnabled: 'true',
+};
+
+const pulse = keyframes`
+  0% { opacity: 0.35; }
+  50% { opacity: 0.7; }
+  100% { opacity: 0.35; }
+`;
 
-// ─── Styled ───
 const SettingsGrid = styled.div`
   display: grid;
   grid-template-columns: 1fr 1fr;
   gap: var(--space-xl);
-
+  @media (max-width: 767px) { grid-template-columns: 1fr; gap: var(--space-lg); }
-  @media (max-width: 767px) {
-    grid-template-columns: 1fr;
-    gap: var(--space-lg);
-  }
 `;
-
 const SettingsSection = styled.section``;
-
 const SettingsRow = styled.div`
   display: flex;
   justify-content: space-between;
@@ -25,257 +39,112 @@ const SettingsRow = styled.div`
   gap: var(--space-lg);
   padding: var(--space-md) 0;
   border-bottom: 1px solid #1f1f1f;
-
   &:last-child { border-bottom: none; }
 `;
-
+const SettingInfo = styled.div`flex: 1; min-width: 0;`;
-const SettingInfo = styled.div`
+const SettingLabel = styled.div`font-size: 14px; font-weight: 500; color: var(--text-primary); margin-bottom: 2px;`;
-  flex: 1;
+const SettingDesc = styled.div`font-size: 12px; color: var(--text-secondary); line-height: 1.4;`;
-  min-width: 0;
+const SwitchWrapper = styled.label`position: relative; display: inline-block; width: 34px; height: 18px; flex-shrink: 0; cursor: pointer;`;
-`;
+const SwitchInput = styled.input`opacity: 0; width: 0; height: 0; position: absolute;`;
-
-const SettingLabel = styled.div`
-  font-size: 14px;
-  font-weight: 500;
-  color: var(--text-primary);
-  margin-bottom: 2px;
-`;
-
-const SettingDesc = styled.div`
-  font-size: 12px;
-  color: var(--text-secondary);
-  line-height: 1.4;
-`;
-
-// Toggle Switch
-const SwitchWrapper = styled.label`
-  position: relative;
-  display: inline-block;
-  width: 34px;
-  height: 18px;
-  flex-shrink: 0;
-  cursor: pointer;
-`;
-
-const SwitchInput = styled.input`
-  opacity: 0;
-  width: 0;
-  height: 0;
-  position: absolute;
-`;
-
 const Slider = styled.span<{ $checked: boolean }>`
-  position: absolute;
+  position: absolute; inset: 0;
-  inset: 0;
   border: 1px solid ${({ $checked }) => $checked ? 'var(--text-primary)' : 'var(--border-color)'};
-  background: transparent;
+  background: transparent; transition: border-color 0.2s; cursor: pointer;
-  transition: border-color 0.2s;
-  cursor: pointer;
-
   &::after {
-    content: '';
+    content: ''; position: absolute; left: ${({ $checked }) => $checked ? '16px' : '2px'}; top: 2px;
-    position: absolute;
+    width: 12px; height: 12px; background: ${({ $checked }) => $checked ? 'var(--text-primary)' : 'var(--text-secondary)'};
-    left: ${({ $checked }) => $checked ? '16px' : '2px'};
-    top: 2px;
-    width: 12px;
-    height: 12px;
-    background: ${({ $checked }) => $checked ? 'var(--text-primary)' : 'var(--text-secondary)'};
     transition: left 0.2s, background 0.2s;
   }
 `;
-
+const BracketInputGroup = styled.div`display: flex; align-items: center; gap: 4px; font-family: var(--font-mono); font-size: 14px; color: var(--text-secondary); flex-shrink: 0;`;
-const BracketInputGroup = styled.div`
-  display: flex;
-  align-items: center;
-  gap: 4px;
-  font-family: var(--font-mono);
-  font-size: 14px;
-  color: var(--text-secondary);
-  flex-shrink: 0;
-`;
-
 const BracketInput = styled.input`
-  background: transparent;
+  background: transparent; border: none; color: var(--text-primary); font-family: var(--font-mono); font-size: 14px; text-align: center;
-  border: none;
+  width: 72px; outline: none; padding: 2px 0; border-bottom: 1px solid var(--border-color);
-  color: var(--text-primary);
-  font-family: var(--font-mono);
-  font-size: 14px;
-  text-align: center;
-  width: 60px;
-  outline: none;
-  padding: 2px 0;
-  border-bottom: 1px solid var(--border-color);
-
   &:focus { border-bottom-color: var(--text-primary); }
 `;
-
+const ActionBar = styled.div`display: flex; justify-content: flex-end; gap: var(--space-md); padding-top: var(--space-xl); border-top: 1px solid var(--border-color);`;
-const ActionBar = styled.div`
+const Toast = styled.div`margin-bottom: var(--space-lg); padding: var(--space-sm) var(--space-md); border: 1px solid var(--border-color); color: var(--text-secondary); font-size: 12px; font-family: var(--font-mono);`;
-  display: flex;
+const ErrorBox = styled.div`padding: var(--space-lg); border: 1px solid #5a2a2a; color: #ff9b9b; font-size: 13px; margin-bottom: var(--space-lg);`;
-  justify-content: flex-end;
+const SkeletonBox = styled.div`height: 16px; background: #1a1a1a; animation: ${pulse} 1.4s ease-in-out infinite;`;
-  gap: var(--space-md);
-  padding-top: var(--space-xl);
-  border-top: 1px solid var(--border-color);
-`;
 
 function Toggle({ checked, onChange }: { checked: boolean; onChange: () => void }) {
-  return (
+  return <SwitchWrapper onClick={onChange}><SwitchInput type="checkbox" checked={checked} onChange={() => {}} /><Slider $checked={checked} /></SwitchWrapper>;
-    <SwitchWrapper onClick={onChange}>
-      <SwitchInput type="checkbox" checked={checked} onChange={() => {}} />
-      <Slider $checked={checked} />
-    </SwitchWrapper>
-  );
 }
-
 function BInput({ value, onChange }: { value: string; onChange: (v: string) => void }) {
-  return (
+  return <BracketInputGroup>[<BracketInput value={value} onChange={(e) => onChange(e.target.value)} />]</BracketInputGroup>;
-    <BracketInputGroup>
-      [<BracketInput value={value} onChange={(e) => onChange(e.target.value)} />]
-    </BracketInputGroup>
-  );
 }
 
 export default function SettingsPage() {
-  const [settings, setSettings] = useState({
+  const [settings, setSettings] = useState<Record<string, string>>(DEFAULT_SETTINGS);
-    twofa: true,
+  const [loading, setLoading] = useState(true);
-    sessionTimeout: '15',
+  const [saving, setSaving] = useState(false);
-    ipWhitelist: false,
+  const [toast, setToast] = useState<string | null>(null);
-    autoBackup: true,
+  const [error, setError] = useState<string | null>(null);
-    backupInterval: '08:00',
-    backupRetention: '30',
-    queueThreshold: '500',
-    autoScaling: true,
-    cpuThreshold: '90',
-    latencyThreshold: '250',
-    nodeOfflineAlert: true,
-  });
 
-  const toggle = (key: keyof typeof settings) =>
+  useEffect(() => {
-    setSettings((p) => ({ ...p, [key]: !p[key] }));
+    let active = true;
-  const setVal = (key: keyof typeof settings, val: string) =>
+    adminFetch('/api/admin/settings')
-    setSettings((p) => ({ ...p, [key]: val }));
+      .then((r) => r.ok ? r.json() : Promise.reject(new Error('load failed')))
+      .then((d) => { if (active) setSettings({ ...DEFAULT_SETTINGS, ...d }); })
+      .catch(() => { if (active) setError('데이터를 불러올 수 없습니다'); })
+      .finally(() => { if (active) setLoading(false); });
+    return () => { active = false; };
+  }, []);
+
+  const toggle = (key: string) => setSettings((p) => ({ ...p, [key]: p[key] === 'true' ? 'false' : 'true' }));
+  const setVal = (key: string, val: string) => setSettings((p) => ({ ...p, [key]: val }));
+  const save = async () => {
+    setSaving(true); setToast(null);
+    try {
+      const res = await adminFetch('/api/admin/settings', { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(settings) });
+      if (!res.ok) throw new Error();
+      const d = await res.json();
+      setSettings(d);
+      setToast('설정 저장됨');
+    } catch {
+      setError('저장 실패');
+    } finally { setSaving(false); }
+  };
+  const reset = () => { setSettings(DEFAULT_SETTINGS); setToast('기본값 복원'); };
 
   return (
     <>
       <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'flex-end', marginBottom: 'var(--space-lg)' }}>
         <PageTitle>시스템 설정</PageTitle>
-        <LabelMeta><span>CONFIG:</span>v2.0.4-STABLE</LabelMeta>
+        <LabelMeta><span>CONFIG:</span>DB-LIVE</LabelMeta>
       </div>
+      {toast && <Toast>{toast}</Toast>}
+      {error && <ErrorBox>{error}</ErrorBox>}
 
+      {loading ? (
+        <SettingsGrid>
+          <SettingsSection><SectionTitle><span>LOADING</span></SectionTitle><SkeletonBox /><div style={{ height: 12 }} /><SkeletonBox /><div style={{ height: 12 }} /><SkeletonBox /></SettingsSection>
+          <SettingsSection><SectionTitle><span>LOADING</span></SectionTitle><SkeletonBox /><div style={{ height: 12 }} /><SkeletonBox /><div style={{ height: 12 }} /><SkeletonBox /></SettingsSection>
+        </SettingsGrid>
+      ) : (
+        <>
           <SettingsGrid>
-        {/* SEC 01 */}
             <SettingsSection>
-          <SectionTitle>
+              <SectionTitle><span>ADMIN PROTOCOL RULES</span><LabelMeta>SEC: 01</LabelMeta></SectionTitle>
-            <span>ADMIN PROTOCOL RULES</span>
+              <SettingsRow><SettingInfo><SettingLabel>강제 2단계 인증 (2FA)</SettingLabel><SettingDesc>모든 관리자 계정에 대해 추가 인증 요구.</SettingDesc></SettingInfo><Toggle checked={settings.force2fa === 'true'} onChange={() => toggle('force2fa')} /></SettingsRow>
-            <LabelMeta>SEC: 01</LabelMeta>
+              <SettingsRow><SettingInfo><SettingLabel>세션 유효 시간</SettingLabel><SettingDesc>비활동 시 자동 로그아웃 시간(분).</SettingDesc></SettingInfo><BInput value={settings.sessionTimeoutMinutes} onChange={(v) => setVal('sessionTimeoutMinutes', v)} /></SettingsRow>
-          </SectionTitle>
+              <SettingsRow><SettingInfo><SettingLabel>IP 화이트리스트</SettingLabel><SettingDesc>지정 대역만 관리자 접근 허용.</SettingDesc></SettingInfo><Toggle checked={settings.ipWhitelistEnabled === 'true'} onChange={() => toggle('ipWhitelistEnabled')} /></SettingsRow>
-          <SettingsRow>
+              <SettingsRow><SettingInfo><SettingLabel>노드 오프라인 알림</SettingLabel><SettingDesc>자매 노드 오프라인 시 즉시 알림.</SettingDesc></SettingInfo><Toggle checked={settings.nodeOfflineAlertEnabled === 'true'} onChange={() => toggle('nodeOfflineAlertEnabled')} /></SettingsRow>
-            <SettingInfo>
-              <SettingLabel>강제 2단계 인증 (2FA)</SettingLabel>
-              <SettingDesc>모든 관리자 계정에 대해 생체 인식 또는 하드웨어 키 요구.</SettingDesc>
-            </SettingInfo>
-            <Toggle checked={settings.twofa} onChange={() => toggle('twofa')} />
-          </SettingsRow>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>세션 유효 시간</SettingLabel>
-              <SettingDesc>비활동 시 관리 콘솔 자동 로그아웃 시간(분).</SettingDesc>
-            </SettingInfo>
-            <BInput value={settings.sessionTimeout} onChange={(v) => setVal('sessionTimeout', v)} />
-          </SettingsRow>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>IP 화이트리스트</SettingLabel>
-              <SettingDesc>지정된 대역에서만 관리자 권한 접근 허용.</SettingDesc>
-            </SettingInfo>
-            <Toggle checked={settings.ipWhitelist} onChange={() => toggle('ipWhitelist')} />
-          </SettingsRow>
             </SettingsSection>
-
-        {/* SEC 02 */}
             <SettingsSection>
-          <SectionTitle>
+              <SectionTitle><span>BACKUP & THRESHOLDS</span><LabelMeta>SEC: 02</LabelMeta></SectionTitle>
-            <span>BACKUP &amp; REDUNDANCY</span>
+              <SettingsRow><SettingInfo><SettingLabel>자동 백업</SettingLabel><SettingDesc>주기적 스냅샷 생성.</SettingDesc></SettingInfo><Toggle checked={settings.autoBackupEnabled === 'true'} onChange={() => toggle('autoBackupEnabled')} /></SettingsRow>
-            <LabelMeta>SEC: 02</LabelMeta>
+              <SettingsRow><SettingInfo><SettingLabel>백업 주기</SettingLabel><SettingDesc>백업 실행 시간(HH:mm).</SettingDesc></SettingInfo><BInput value={settings.backupSchedule} onChange={(v) => setVal('backupSchedule', v)} /></SettingsRow>
-          </SectionTitle>
+              <SettingsRow><SettingInfo><SettingLabel>보관 주기</SettingLabel><SettingDesc>백업 보관 일수.</SettingDesc></SettingInfo><BInput value={settings.retentionDays} onChange={(v) => setVal('retentionDays', v)} /></SettingsRow>
-          <SettingsRow>
+              <SettingsRow><SettingInfo><SettingLabel>대기열 경고 임계값</SettingLabel><SettingDesc>경고 발생 기준.</SettingDesc></SettingInfo><BInput value={settings.queueWarningThreshold} onChange={(v) => setVal('queueWarningThreshold', v)} /></SettingsRow>
-            <SettingInfo>
+              <SettingsRow><SettingInfo><SettingLabel>자동 스케일링</SettingLabel><SettingDesc>CPU 부하 시 임시 리소스 확장.</SettingDesc></SettingInfo><Toggle checked={settings.autoScalingEnabled === 'true'} onChange={() => toggle('autoScalingEnabled')} /></SettingsRow>
-              <SettingLabel>자동 백업 활성화</SettingLabel>
+              <SettingsRow><SettingInfo><SettingLabel>CPU 임계값</SettingLabel><SettingDesc>스케일링 기준 CPU %.</SettingDesc></SettingInfo><BInput value={settings.cpuThresholdPercent} onChange={(v) => setVal('cpuThresholdPercent', v)} /></SettingsRow>
-              <SettingDesc>전체 시스템 상태의 주기적인 스냅샷 생성.</SettingDesc>
+              <SettingsRow><SettingInfo><SettingLabel>레이턴시 경보</SettingLabel><SettingDesc>경보 발생 기준 ms.</SettingDesc></SettingInfo><BInput value={settings.latencyAlertMs} onChange={(v) => setVal('latencyAlertMs', v)} /></SettingsRow>
-            </SettingInfo>
-            <Toggle checked={settings.autoBackup} onChange={() => toggle('autoBackup')} />
-          </SettingsRow>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>백업 주기 (시간)</SettingLabel>
-              <SettingDesc>스냅샷 생성 간격 설정.</SettingDesc>
-            </SettingInfo>
-            <BInput value={settings.backupInterval} onChange={(v) => setVal('backupInterval', v)} />
-          </SettingsRow>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>보관 주기 (일)</SettingLabel>
-              <SettingDesc>백업 데이터 자동 삭제 전 유지 기간.</SettingDesc>
-            </SettingInfo>
-            <BInput value={settings.backupRetention} onChange={(v) => setVal('backupRetention', v)} />
-          </SettingsRow>
-        </SettingsSection>
-
-        {/* SEC 03 */}
-        <SettingsSection>
-          <SectionTitle>
-            <span>SYNC QUEUE THRESHOLDS</span>
-            <LabelMeta>SEC: 03</LabelMeta>
-          </SectionTitle>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>대기열 경고 임계값</SettingLabel>
-              <SettingDesc>동기화 대기 항목이 설정치를 초과할 시 경보 발생.</SettingDesc>
-            </SettingInfo>
-            <BInput value={settings.queueThreshold} onChange={(v) => setVal('queueThreshold', v)} />
-          </SettingsRow>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>자동 스케일링</SettingLabel>
-              <SettingDesc>부하 증가 시 임시 노드 리소스 할당.</SettingDesc>
-            </SettingInfo>
-            <Toggle checked={settings.autoScaling} onChange={() => toggle('autoScaling')} />
-          </SettingsRow>
-        </SettingsSection>
-
-        {/* SEC 04 */}
-        <SettingsSection>
-          <SectionTitle>
-            <span>NODE ALERT TRIGGERS</span>
-            <LabelMeta>SEC: 04</LabelMeta>
-          </SectionTitle>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>CPU 사용량 임계값 (%)</SettingLabel>
-              <SettingDesc>시스템 부하 경고 기준점.</SettingDesc>
-            </SettingInfo>
-            <BInput value={settings.cpuThreshold} onChange={(v) => setVal('cpuThreshold', v)} />
-          </SettingsRow>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>레이턴시 경보 (ms)</SettingLabel>
-              <SettingDesc>응답 속도 지연에 대한 임계값 설정.</SettingDesc>
-            </SettingInfo>
-            <BInput value={settings.latencyThreshold} onChange={(v) => setVal('latencyThreshold', v)} />
-          </SettingsRow>
-          <SettingsRow>
-            <SettingInfo>
-              <SettingLabel>노드 오프라인 알림</SettingLabel>
-              <SettingDesc>활성 노드 연결 해제 시 즉시 알림.</SettingDesc>
-            </SettingInfo>
-            <Toggle checked={settings.nodeOfflineAlert} onChange={() => toggle('nodeOfflineAlert')} />
-          </SettingsRow>
             </SettingsSection>
           </SettingsGrid>
-
+          <ActionBar><Btn onClick={reset}>초기화</Btn><BtnPrimary onClick={save} disabled={saving}>{saving ? '저장 중...' : '설정 저장'}</BtnPrimary></ActionBar>
-      <ActionBar>
+        </>
-        <Btn onClick={() => setSettings((p) => ({ ...p }))}>초기화</Btn>
+      )}
-        <BtnPrimary>설정 저장</BtnPrimary>
-      </ActionBar>
     </>
   );
 }

frontend/app/sisters/[name]/page.tsx

@@ -4,8 +4,9 @@ import React, { useEffect, useState } from 'react';
 import { useParams } from 'next/navigation';
 import styled from 'styled-components';
 import Link from 'next/link';
-import { PageTitle, LabelMeta, SectionTitle, TechBar, TechBarFill, Timeline, TimelineItem, TimeStamp, TimelineContent } from '@/components/ui/base';
+import { LabelMeta, SectionTitle, TechBar, TechBarFill, Timeline, TimelineItem, TimeStamp, TimelineContent } from '@/components/ui/base';
 import { API_URL } from '@/lib/config';
+import SisterAvatar from '@/components/common/SisterAvatar';
 import { SISTER_ROLES } from '@/lib/sisters';
 
 const Breadcrumb = styled.div`
@@ -16,9 +17,87 @@ const Breadcrumb = styled.div`
   a { color: var(--text-secondary); text-decoration: none; &:hover { color: var(--text-primary); } }
 `;
 
+const Hero = styled.section`
+  display: grid;
+  grid-template-columns: 128px 1fr;
+  gap: var(--space-xl);
+  align-items: center;
+  padding: var(--space-xl);
+  border: 1px solid var(--border-color);
+  margin-bottom: var(--space-xl);
+
+  @media (max-width: 767px) {
+    grid-template-columns: 1fr;
+    justify-items: start;
+  }
+`;
+
+const HeroMeta = styled.div`
+  display: flex;
+  flex-direction: column;
+  gap: var(--space-sm);
+`;
+
+const HeroName = styled.div`
+  font-size: 36px;
+  font-weight: 700;
+  letter-spacing: -0.03em;
+  color: var(--text-primary);
+`;
+
+const HeroRole = styled.div`
+  font-size: 14px;
+  color: var(--text-secondary);
+  font-family: var(--font-mono);
+`;
+
+const HeroStatus = styled.div`
+  display: flex;
+  align-items: center;
+  gap: var(--space-sm);
+  margin-top: var(--space-sm);
+`;
+
+const StatusDot = styled.div<{ $on: boolean }>`
+  width: 10px;
+  height: 10px;
+  border-radius: 50%;
+  background: ${({ $on }) => $on ? '#FFF' : '#555'};
+  ${({ $on }) => $on && `box-shadow: 0 0 8px rgba(255,255,255,0.3);`}
+`;
+
+const HeroStats = styled.div`
+  display: grid;
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+  gap: var(--space-md);
+  margin-top: var(--space-lg);
+
+  @media (max-width: 767px) {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+`;
+
+const StatCard = styled.div`
+  border: 1px solid var(--border-color);
+  padding: var(--space-md);
+`;
+
+const StatLabel = styled.div`
+  font-size: 10px;
+  color: var(--text-secondary);
+  font-family: var(--font-mono);
+  margin-bottom: 6px;
+`;
+
+const StatValue = styled.div`
+  font-size: 18px;
+  color: var(--text-primary);
+  font-family: var(--font-mono);
+`;
+
 const DetailGrid = styled.div`
   display: grid;
-  grid-template-columns: 280px 1fr;
+  grid-template-columns: 320px 1fr;
   gap: var(--space-xxl);
   align-items: start;
 
@@ -39,20 +118,6 @@ const MetaCard = styled.div`
   padding: var(--space-lg);
 `;
 
-const StatusRow = styled.div`
-  display: flex;
-  align-items: center;
-  gap: var(--space-sm);
-`;
-
-const StatusDot = styled.div<{ $on: boolean }>`
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  background: ${({ $on }) => $on ? '#FFF' : '#555'};
-  ${({ $on }) => $on && `box-shadow: 0 0 8px rgba(255,255,255,0.3);`}
-`;
-
 const ConfigPre = styled.pre`
   background: #0d0d0d;
   border: 1px solid var(--border-color);
@@ -84,7 +149,6 @@ const TabBtn = styled.button<{ $active: boolean }>`
   padding: var(--space-sm) 0;
   cursor: pointer;
   transition: color 0.15s, border-color 0.15s;
-
   &:hover { color: var(--text-primary); }
 `;
 
@@ -95,6 +159,7 @@ const SISTER_DISPLAY: Record<string, string> = {
 export default function SisterDetailPage() {
   const { name } = useParams<{ name: string }>();
   const [sisterInfo, setSisterInfo] = useState<any>(null);
+  const [systemInfo, setSystemInfo] = useState<any>(null);
   const [configData, setConfigData] = useState<any>(null);
   const [activity, setActivity] = useState<any[]>([]);
   const [tab, setTab] = useState('overview');
@@ -105,7 +170,8 @@ export default function SisterDetailPage() {
       fetch(`${API_URL}/api/sisters`),
       fetch(`${API_URL}/api/sisters/${name}/config`),
       fetch(`${API_URL}/api/sisters/${name}/activity`),
-    ]).then(([sRes, cRes, aRes]) => {
+      fetch(`${API_URL}/api/sisters/${name}/system`),
+    ]).then(([sRes, cRes, aRes, syRes]) => {
       if (sRes.status === 'fulfilled' && sRes.value.ok) {
         sRes.value.json().then((d: any[]) => setSisterInfo(d.find((s) => s.name === name)));
       }
@@ -113,6 +179,7 @@ export default function SisterDetailPage() {
       if (aRes.status === 'fulfilled' && aRes.value.ok) {
         aRes.value.json().then((d: any) => setActivity(d.items ?? []));
       }
+      if (syRes.status === 'fulfilled' && syRes.value.ok) syRes.value.json().then(setSystemInfo);
     }).finally(() => setLoading(false));
   }, [name]);
 
@@ -123,30 +190,39 @@ export default function SisterDetailPage() {
       <Breadcrumb>
         <Link href="/sisters">자매 노드 관리</Link> / {SISTER_DISPLAY[name] ?? name}
       </Breadcrumb>
-      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 'var(--space-xl)' }}>
-        <PageTitle>
-          {SISTER_DISPLAY[name] ?? name}
-          <span style={{ fontSize: '16px', color: 'var(--text-secondary)', fontWeight: 400, marginLeft: 'var(--space-sm)' }}>
-            / {SISTER_ROLES[name] ?? 'UNKNOWN'}
-          </span>
-        </PageTitle>
-        <LabelMeta><span>STATUS:</span>{sisterInfo?.status?.toUpperCase() ?? 'UNKNOWN'}</LabelMeta>
-      </div>
 
       {loading ? (
         <div style={{ color: 'var(--text-secondary)', fontSize: '13px', fontFamily: 'var(--font-mono)' }}>LOADING...</div>
       ) : (
+        <>
+          <Hero>
+            <SisterAvatar name={name} size={120} />
+            <HeroMeta>
+              <HeroName>{SISTER_DISPLAY[name] ?? name}</HeroName>
+              <HeroRole>{SISTER_ROLES[name] ?? 'UNKNOWN'}</HeroRole>
+              <HeroStatus>
+                <StatusDot $on={isActive} />
+                <LabelMeta>{isActive ? 'ACTIVE' : 'STANDBY'}</LabelMeta>
+                <LabelMeta><span>LXC:</span>{sisterInfo?.lxcId ?? '--'}</LabelMeta>
+              </HeroStatus>
+              <HeroStats>
+                <StatCard><StatLabel>UPTIME</StatLabel><StatValue>{systemInfo?.uptime ?? '--:--:--'}</StatValue></StatCard>
+                <StatCard><StatLabel>CPU</StatLabel><StatValue>{systemInfo?.cpu?.toFixed?.(1) ?? '0.0'}%</StatValue></StatCard>
+                <StatCard><StatLabel>MEM</StatLabel><StatValue>{systemInfo?.memory?.used ?? 0}/{systemInfo?.memory?.total ?? 0}MB</StatValue></StatCard>
+                <StatCard><StatLabel>DISK</StatLabel><StatValue>{systemInfo?.disk?.used ?? '0G'}/{systemInfo?.disk?.total ?? '0G'}</StatValue></StatCard>
+              </HeroStats>
+            </HeroMeta>
+          </Hero>
+
           <DetailGrid>
             <MetaPanel>
               <MetaCard>
-              <StatusRow>
+                <LabelMeta style={{ marginBottom: 'var(--space-sm)', display: 'block' }}>SYSTEM SUMMARY</LabelMeta>
-                <StatusDot $on={isActive} />
+                <div style={{ margin: 'var(--space-md) 0', fontFamily: 'var(--font-mono)', fontSize: '11px', color: 'var(--text-secondary)', lineHeight: 1.8 }}>
-                <LabelMeta>{isActive ? 'ACTIVE' : 'STANDBY'}</LabelMeta>
-              </StatusRow>
-              <div style={{ margin: 'var(--space-md) 0', fontFamily: 'var(--font-mono)', fontSize: '11px', color: 'var(--text-secondary)', lineHeight: 1.6 }}>
-                LXC: {sisterInfo?.lxcId ?? '--'}<br />
                   LAST_SEEN: {sisterInfo?.lastSeen ? new Date(sisterInfo.lastSeen).toLocaleString() : '--'}<br />
-                ROLE: {SISTER_ROLES[name] ?? '--'}
+                  ROLE: {SISTER_ROLES[name] ?? '--'}<br />
+                  STATUS: {String(sisterInfo?.status ?? 'unknown').toUpperCase()}<br />
+                  HOST_USER: {sisterInfo?.user ?? '--'}
                 </div>
                 <TechBar>
                   <TechBarFill $width={isActive ? 100 : 0} />
@@ -205,6 +281,7 @@ export default function SisterDetailPage() {
               )}
             </div>
           </DetailGrid>
+        </>
       )}
     </>
   );

frontend/app/sisters/page.tsx

@@ -1,191 +1,63 @@
 'use client';
 
 import React, { useEffect, useState } from 'react';
-import styled from 'styled-components';
+import styled, { keyframes } from 'styled-components';
 import Link from 'next/link';
 import { PageTitle, LabelMeta, BtnToggle } from '@/components/ui/base';
 import { API_URL } from '@/lib/config';
+import SisterAvatar from '@/components/common/SisterAvatar';
 
-const SISTER_ROLES: Record<string, string> = {
+const pulse = keyframes`0%{opacity:.35}50%{opacity:.7}100%{opacity:.35}`;
-  harang: 'Primary',
+const SISTER_ROLES: Record<string, string> = { harang: 'Primary', narang: 'Secondary', darang: 'Standby', erang: 'Sync' };
-  narang: 'Secondary',
+const NodeGrid = styled.section`display:flex;flex-direction:column;gap:var(--space-lg);`;
-  darang: 'Standby',
+const NodeEntry = styled.div`display:grid;grid-template-columns:220px 1fr 160px;gap:0;border:1px solid var(--border-color);transition:border-color .2s;&:hover{border-color:var(--border-hover)}@media (max-width:1199px){grid-template-columns:200px 1fr}@media (max-width:767px){grid-template-columns:1fr}`;
-  erang: 'Sync',
+const NodeInfo = styled.div`border-right:1px solid var(--border-color);padding:var(--space-lg);display:flex;flex-direction:column;gap:var(--space-md);@media (max-width:767px){border-right:none;border-bottom:1px solid var(--border-color)}`;
-};
+const NodeName = styled(Link)`display:flex;align-items:center;gap:var(--space-sm);font-size:16px;font-weight:600;color:var(--text-primary);text-decoration:none;transition:color .15s;&:hover{color:var(--accent-hover)}`;
+const StatusIndicator = styled.div<{ $active: boolean }>`width:8px;height:8px;border-radius:50%;background:${({$active})=>$active?'#FFF':'#555'};flex-shrink:0;${({$active})=>$active&&`box-shadow:0 0 8px rgba(255,255,255,.3);`}`;
+const MetaPair = styled.div`display:flex;flex-direction:column;gap:2px;`;
+const MetaVal = styled.div`font-size:13px;color:var(--text-primary);font-family:var(--font-mono);`;
+const NodeControls = styled.div`display:flex;gap:var(--space-sm);flex-wrap:wrap;`;
+const CapacitySection = styled.div`border-right:1px solid var(--border-color);padding:var(--space-lg);display:flex;flex-direction:column;gap:var(--space-md);@media (max-width:1199px){border-right:none}@media (max-width:767px){border-bottom:1px solid var(--border-color)}`;
+const BarWrap = styled.div`display:flex;flex-direction:column;gap:8px;`;
+const BarRow = styled.div`display:flex;align-items:center;gap:8px;font-family:var(--font-mono);font-size:11px;color:var(--text-secondary);`;
+const Bar = styled.div`flex:1;height:8px;background:#151515;border:1px solid #222;`;
+const Fill = styled.div<{ $width:number }>`height:100%;width:${({$width})=>$width}%;background:var(--text-primary);`;
+const SyncHistory = styled.div`padding:var(--space-lg);display:flex;flex-direction:column;gap:var(--space-sm);@media (max-width:1199px){display:none}`;
+const SyncRow = styled.div`display:flex;justify-content:space-between;font-family:var(--font-mono);font-size:11px;color:var(--text-secondary);padding:2px 0;`;
+const Skeleton = styled.div`height:120px;border:1px solid var(--border-color);background:#111;animation:${pulse} 1.4s ease-in-out infinite;`;
+const ErrorBox = styled.div`padding:var(--space-lg);border:1px solid #5a2a2a;color:#ff9b9b;`;
 
-const GRAPH_BARS: Record<string, number[]> = {
+function getNodeStatus(s: any): boolean { return s.status === 'online' || s.status === 'working'; }
-  harang: [40, 45, 60, 55, 70, 85, 92, 84],
+function getStatusBtns(s: any): [string, string] { if (s.status === 'offline') return ['STANDBY', 'ACTIVATE']; return ['ACTIVE', 'REBOOT']; }
-  narang: [30, 32, 35, 40, 38, 45, 50, 48],
-  darang: [10, 10, 5, 5, 5, 5, 2, 2],
-  erang: [20, 25, 15, 30, 40, 35, 20, 15],
-};
-
-const NodeGrid = styled.section`
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-lg);
-`;
-
-const NodeEntry = styled.div`
-  display: grid;
-  grid-template-columns: 220px 1fr 160px;
-  gap: 0;
-  border: 1px solid var(--border-color);
-  transition: border-color 0.2s;
-
-  &:hover { border-color: var(--border-hover); }
-
-  @media (max-width: 1199px) {
-    grid-template-columns: 200px 1fr;
-  }
-
-  @media (max-width: 767px) {
-    grid-template-columns: 1fr;
-  }
-`;
-
-const NodeInfo = styled.div`
-  border-right: 1px solid var(--border-color);
-  padding: var(--space-lg);
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-md);
-
-  @media (max-width: 767px) {
-    border-right: none;
-    border-bottom: 1px solid var(--border-color);
-  }
-`;
-
-const NodeName = styled(Link)`
-  display: flex;
-  align-items: center;
-  gap: var(--space-sm);
-  font-size: 16px;
-  font-weight: 600;
-  color: var(--text-primary);
-  text-decoration: none;
-  transition: color 0.15s;
-
-  &:hover { color: var(--accent-hover); }
-`;
-
-const StatusIndicator = styled.div<{ $active: boolean }>`
-  width: 8px;
-  height: 8px;
-  border-radius: 50%;
-  background: ${({ $active }) => $active ? '#FFF' : '#555'};
-  flex-shrink: 0;
-  ${({ $active }) => $active && `box-shadow: 0 0 8px rgba(255,255,255,0.3);`}
-`;
-
-const MetaPair = styled.div`
-  display: flex;
-  flex-direction: column;
-  gap: 2px;
-`;
-
-const MetaVal = styled.div`
-  font-size: 13px;
-  color: var(--text-primary);
-  font-family: var(--font-mono);
-`;
-
-const NodeControls = styled.div`
-  display: flex;
-  gap: var(--space-sm);
-  flex-wrap: wrap;
-`;
-
-const CapacitySection = styled.div`
-  border-right: 1px solid var(--border-color);
-  padding: var(--space-lg);
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-md);
-
-  @media (max-width: 1199px) {
-    border-right: none;
-  }
-
-  @media (max-width: 767px) {
-    border-bottom: 1px solid var(--border-color);
-  }
-`;
-
-const GraphContainer = styled.div`
-  display: flex;
-  align-items: flex-end;
-  gap: 3px;
-  height: 48px;
-`;
-
-const GraphBar = styled.div<{ $height: number; $highlight?: boolean }>`
-  flex: 1;
-  height: ${({ $height }) => $height}%;
-  min-height: 2px;
-  background: ${({ $highlight }) => $highlight ? 'var(--text-primary)' : 'var(--border-hover)'};
-  transition: height 0.3s;
-`;
-
-const SyncRow = styled.div`
-  display: flex;
-  justify-content: space-between;
-  font-family: var(--font-mono);
-  font-size: 11px;
-  color: var(--text-secondary);
-  padding: 2px 0;
-`;
-
-const SyncHistory = styled.div`
-  padding: var(--space-lg);
-  display: flex;
-  flex-direction: column;
-  gap: var(--space-sm);
-
-  @media (max-width: 1199px) {
-    display: none;
-  }
-`;
-
-function getNodeStatus(s: any): boolean {
-  return s.status === 'online' || s.status === 'working';
-}
-
-function getStatusBtns(s: any): [string, string] {
-  if (s.status === 'offline') return ['STANDBY', 'ACTIVATE'];
-  if (s.status === 'working') return ['ACTIVE', 'REBOOT'];
-  return ['ACTIVE', 'REBOOT'];
-}
-
-function formatLastSeen(lastSeen: string | null): string {
-  if (!lastSeen) return '—';
-  const diff = Date.now() - new Date(lastSeen).getTime();
-  const h = Math.floor(diff / 3600000);
-  const m = Math.floor((diff % 3600000) / 60000);
-  const s = Math.floor((diff % 60000) / 1000);
-  return `${String(h).padStart(2,'0')}:${String(m).padStart(2,'0')}:${String(s).padStart(2,'0')} ago`;
-}
-
-const MOCK_SISTERS = [
-  { id: 1, name: 'harang', status: 'online', lastSeen: new Date(Date.now() - 3600000).toISOString() },
-  { id: 2, name: 'narang', status: 'working', lastSeen: new Date(Date.now() - 1800000).toISOString() },
-  { id: 3, name: 'darang', status: 'offline', lastSeen: new Date(Date.now() - 7200000).toISOString() },
-  { id: 4, name: 'erang', status: 'online', lastSeen: new Date(Date.now() - 900000).toISOString() },
-];
 
 export default function SistersPage() {
-  const [sisters, setSisters] = useState<any[]>(MOCK_SISTERS);
+  const [sisters, setSisters] = useState<any[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
 
   useEffect(() => {
-    fetch(`${API_URL}/api/sisters`)
+    let active = true;
-      .then((r) => r.json())
+    const load = async () => {
-      .then(setSisters)
+      try {
-      .catch(() => {});
+        const base = await fetch(`${API_URL}/api/sisters`).then((r) => r.ok ? r.json() : Promise.reject());
-    const iv = setInterval(() => {
+        const withSystem = await Promise.all(base.map(async (s: any) => {
-      fetch(`${API_URL}/api/sisters`).then((r) => r.json()).then(setSisters).catch(() => {});
+          try {
-    }, 15000);
+            const system = await fetch(`${API_URL}/api/sisters/${s.name}/system`).then((r) => r.ok ? r.json() : null);
-    return () => clearInterval(iv);
+            return { ...s, ...(system ?? {}) };
+          } catch {
+            return { ...s, uptime: '00:00:00', cpu: 0, memory: { used: 0, total: 0 }, disk: { used: '0G', total: '0G' } };
+          }
+        }));
+        if (active) { setSisters(withSystem); setError(null); }
+      } catch {
+        if (active) setError('데이터를 불러올 수 없습니다');
+      } finally {
+        if (active) setLoading(false);
+      }
+    };
+    load();
+    const iv = setInterval(load, 15000);
+    return () => { active = false; clearInterval(iv); };
   }, []);
 
   return (
@@ -194,66 +66,35 @@ export default function SistersPage() {
         <PageTitle>자매 노드 관리</PageTitle>
         <LabelMeta><span>TOTAL NODES:</span> {String(sisters.length).padStart(2, '0')}</LabelMeta>
       </div>
-
+      {error && <ErrorBox>{error}</ErrorBox>}
       <NodeGrid>
-        {sisters.map((s) => {
+        {loading ? Array.from({ length: 4 }).map((_, i) => <Skeleton key={i} />) : sisters.map((s) => {
           const isActive = getNodeStatus(s);
           const [btn1, btn2] = getStatusBtns(s);
-          const bars = GRAPH_BARS[s.name] ?? [5, 5, 5, 5, 5, 5, 5, 5];
-          const loadIndex = isActive
-            ? `${(bars[bars.length - 1]).toFixed(1)}%`
-            : '0.0%';
-          const metaLabel = s.status === 'offline' ? 'Last Active' : s.name === 'erang' ? 'Queue Depth' : 'Uptime';
-          const metaVal = s.status === 'offline'
-            ? formatLastSeen(s.lastSeen)
-            : s.name === 'erang' ? '12 PKTS'
-            : formatLastSeen(s.lastSeen).replace(' ago', '');
-
           return (
             <NodeEntry key={s.id ?? s.name}>
               <NodeInfo>
                 <NodeName href={`/sisters/${s.name}`}>
                   <StatusIndicator $active={isActive} />
-                  {s.name === 'harang' ? '하랑' : s.name === 'narang' ? '나랑' : s.name === 'darang' ? '다랑' : '이랑'}{' '}
+                  <SisterAvatar name={s.name} size={28} />
-                  ({SISTER_ROLES[s.name] ?? s.name})
+                  {s.name === 'harang' ? '하랑' : s.name === 'narang' ? '나랑' : s.name === 'darang' ? '다랑' : '이랑'} ({SISTER_ROLES[s.name] ?? s.name})
                 </NodeName>
-                <MetaPair>
+                <MetaPair><LabelMeta>Uptime</LabelMeta><MetaVal>{s.uptime ?? '00:00:00'}</MetaVal></MetaPair>
-                  <LabelMeta>{metaLabel}</LabelMeta>
+                <MetaPair><LabelMeta>Last Seen</LabelMeta><MetaVal>{s.lastSeen ? new Date(s.lastSeen).toLocaleString('ko-KR') : '—'}</MetaVal></MetaPair>
-                  <MetaVal>{metaVal}</MetaVal>
+                <NodeControls><BtnToggle>{btn1}</BtnToggle><BtnToggle>{btn2}</BtnToggle></NodeControls>
-                </MetaPair>
-                <NodeControls>
-                  <BtnToggle $active>{btn1}</BtnToggle>
-                  <BtnToggle>{btn2}</BtnToggle>
-                </NodeControls>
               </NodeInfo>
-
               <CapacitySection>
-                <LabelMeta>CAPACITY HISTORY (24H)</LabelMeta>
+                <BarWrap>
-                <GraphContainer>
+                  <BarRow><span>CPU</span><span>{s.cpu?.toFixed?.(1) ?? '0.0'}%</span><Bar><Fill $width={Math.max(0, Math.min(100, Number(s.cpu ?? 0)))} /></Bar></BarRow>
-                  {bars.map((h, i) => (
+                  <BarRow><span>MEM</span><span>{s.memory?.used ?? 0}/{s.memory?.total ?? 0}MB</span><Bar><Fill $width={s.memory?.total ? (s.memory.used / s.memory.total) * 100 : 0} /></Bar></BarRow>
-                    <GraphBar key={i} $height={h} $highlight={i >= bars.length - 2} />
+                  <BarRow><span>DSK</span><span>{s.disk?.used ?? '0G'}/{s.disk?.total ?? '0G'}</span><Bar><Fill $width={0} /></Bar></BarRow>
-                  ))}
+                </BarWrap>
-                </GraphContainer>
-                <SyncRow>
-                  <span>LOAD INDEX</span>
-                  <span>{loadIndex}</span>
-                </SyncRow>
               </CapacitySection>
-
               <SyncHistory>
-                <LabelMeta>SYNC LOG</LabelMeta>
+                <SyncRow><span>STATUS</span><span>{String(s.status).toUpperCase()}</span></SyncRow>
-                {[
+                <SyncRow><span>CPU</span><span>{s.cpu?.toFixed?.(1) ?? '0.0'}%</span></SyncRow>
-                  { time: '14:05:22', status: isActive ? 'SUCCESS' : 'IDLE' },
+                <SyncRow><span>MEMORY</span><span>{s.memory?.used ?? 0}/{s.memory?.total ?? 0}MB</span></SyncRow>
-                  { time: '13:55:01', status: isActive ? 'SUCCESS' : 'IDLE' },
+                <SyncRow><span>DISK</span><span>{s.disk?.used ?? '0G'} / {s.disk?.total ?? '0G'}</span></SyncRow>
-                  { time: '13:44:10', status: isActive ? 'SUCCESS' : 'IDLE' },
-                ].map((row) => (
-                  <SyncRow key={row.time}>
-                    <span>{row.time}</span>
-                    <span style={{ color: row.status === 'SUCCESS' ? '#00FF00' : 'var(--text-secondary)' }}>
-                      {row.status}
-                    </span>
-                  </SyncRow>
-                ))}
               </SyncHistory>
             </NodeEntry>
           );

frontend/components/common/AppShell.tsx

@@ -5,7 +5,7 @@ import { useRouter, usePathname } from 'next/navigation';
 import { AuthProvider, useAuth } from '@/lib/AuthContext';
 import LayoutShell from './LayoutShell';
 
-const PUBLIC_PATHS = ['/login', '/register'];
+const PUBLIC_PATHS = ['/login'];
 
 function AuthGate({ children }: { children: React.ReactNode }) {
   const { isAuthenticated, loading } = useAuth();

frontend/components/common/SisterAvatar.tsx

@@ -0,0 +1,66 @@
+'use client';
+
+import React, { useState } from 'react';
+import styled from 'styled-components';
+import { API_URL } from '@/lib/config';
+
+const SISTER_INITIALS: Record<string, string> = {
+  harang: '하',
+  narang: '나',
+  darang: '다',
+  erang: '이',
+};
+
+const ImgEl = styled.img<{ $size: number }>`
+  width: ${({ $size }) => $size}px;
+  height: ${({ $size }) => $size}px;
+  border-radius: 50%;
+  object-fit: cover;
+  border: 1px solid var(--border-color);
+  background: #111;
+  display: block;
+  flex-shrink: 0;
+`;
+
+const Fallback = styled.div<{ $size: number }>`
+  width: ${({ $size }) => $size}px;
+  height: ${({ $size }) => $size}px;
+  border-radius: 50%;
+  background: #222;
+  border: 1px solid var(--border-color);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  font-family: var(--font-mono);
+  font-size: ${({ $size }) => Math.round($size * 0.4)}px;
+  color: var(--text-secondary);
+  flex-shrink: 0;
+  user-select: none;
+`;
+
+interface SisterAvatarProps {
+  name: string;
+  size?: number;
+  className?: string;
+  style?: React.CSSProperties;
+}
+
+export default function SisterAvatar({ name, size = 32, className, style }: SisterAvatarProps) {
+  const [failed, setFailed] = useState(false);
+  const initial = SISTER_INITIALS[name] ?? name.slice(0, 1).toUpperCase();
+
+  if (failed) {
+    return <Fallback $size={size} className={className} style={style}>{initial}</Fallback>;
+  }
+
+  return (
+    <ImgEl
+      $size={size}
+      src={`${API_URL}/api/sisters/${name}/avatar`}
+      alt={name}
+      className={className}
+      style={style}
+      onError={() => setFailed(true)}
+    />
+  );
+}

frontend/lib/adminFetch.ts

@@ -1,21 +1,15 @@
 /**
- * 관리자 API 호출 유틸.
+ * 관리자 API 호출 유틸 — JWT 전용.
- * - CSR: 상대경로 /api/... → Next.js rewrites → BE
+ * 로그인 후 localStorage의 access token을 Authorization 헤더에 설정한다.
- * - JWT access token (우선) 또는 API Key fallback으로 Authorization 헤더 설정
  */
 export function getAdminToken(): string {
   if (typeof window === 'undefined') return '';
-  return (
+  return localStorage.getItem('hanarang_access_token') ?? '';
-    localStorage.getItem('hanarang_access_token') ??
-    localStorage.getItem('hanarang_admin_key') ??
-    ''
-  );
 }
 
 export function adminFetch(path: string, options?: RequestInit) {
   const token = getAdminToken();
 
-  // Authorization: options?.headers보다 우선 (덮어쓰기 방지)
   const headers: Record<string, string> = {
     'Content-Type': 'application/json',
     ...(options?.headers as Record<string, string> ?? {}),