@elyun/bylane 1.21.0 → 1.23.0

package/CLAUDE.md

@@ -21,6 +21,15 @@ node -e "import('./src/state.js').then(({writeState})=>writeState('code-agent',{
 
 # 에이전트별 모델 확인
 node -e "import('./src/config.js').then(({loadConfig,getAgentModel})=>{const c=loadConfig();['orchestrator','code-agent','review-agent'].forEach(a=>console.log(a,getAgentModel(c,a)))})"
+
+# Loop 관리
+npx @elyun/bylane loop start   # review-loop + respond-loop 시작 (tmux 또는 process)
+npx @elyun/bylane loop stop    # loop 종료
+npx @elyun/bylane loop status  # 실행 상태 확인
+
+# issueMemory 확인
+npx @elyun/bylane memory list
+npx @elyun/bylane memory read 123
 ```
 
 ## 아키텍처
@@ -28,9 +37,11 @@ node -e "import('./src/config.js').then(({loadConfig,getAgentModel})=>{const c=l
 - `src/state.js` — `.bylane/state/*.json` 읽기/쓰기 유틸 (writeState, readState, clearState, listStates, appendLog)
 - `src/config.js` — `.bylane/bylane.json` 로드/저장/검증 (loadConfig, saveConfig, validateConfig, getAgentModel, DEFAULT_CONFIG)
 - `src/branch.js` — 브랜치명 패턴 엔진 (buildBranchName, buildBranchNameFromConfig)
-- `src/cli.js` — npx 설치 CLI (install, --symlink 옵션, 기존 파일 .bak 백업)
-- `src/review-loop.js` — 5분 주기 review 요청 PR 폴러 → `.bylane/state/review-queue.json`
-- `src/respond-loop.js` — 5분 주기 내 PR 리뷰/코멘트 폴러 → `.bylane/state/respond-queue.json`
+- `src/memory.js` — 이슈별 컨텍스트 메모리 유틸 (readIssueMemory, appendIssueMemory, listIssueMemories)
+- `src/cli.js` — npx 설치 CLI (install, loop, --symlink 옵션, 기존 파일 .bak 백업)
+- `src/loop-utils.js` — 루프 공통 유틸 (killExistingLoop, tmux 세션 관리, createAbsoluteTimer, resolveLoopMode)
+- `src/review-loop.js` — review 요청 PR 폴러 → `.bylane/state/review-queue.json` (절대시간 기반 폴링)
+- `src/respond-loop.js` — 내 PR 리뷰/코멘트 폴러 → `.bylane/state/respond-queue.json` (절대시간 기반 폴링)
 - `src/monitor/` — blessed 기반 TUI 대시보드 (2열 그리드, 1초 폴링, fullUnicode)
 - `skills/` — Claude Code 에이전트 skill 파일들
 - `hooks/` — 외부 이벤트 자동 감지 훅
@@ -46,12 +57,31 @@ orchestrator → issue-agent → code-agent → test-agent → commit-agent
             → pr-agent → review-agent → respond-agent → notify-agent
 
 analyze-agent (독립: 프로젝트 분석 → .claude/instructions/ 생성)
-review-loop   (독립: 5분 주기 review 요청 감지)
-respond-loop  (독립: 5분 주기 리뷰 코멘트 감지)
+review-loop   (독립: 설정 주기로 review 요청 감지, 절대시간 기반 폴링)
+respond-loop  (독립: 설정 주기로 리뷰 코멘트 감지, 절대시간 기반 폴링)
 ```
 
 각 에이전트는 `.bylane/state/{name}.json`에 상태 기록. 모니터가 1초마다 폴링.
 
+## Loop 실행
+
+`bylane loop start` / `bylane loop stop` / `bylane loop status`
+
+두 가지 모드 (`config.loop.mode`):
+
+| 모드 | 설명 | 해결하는 문제 |
+|------|------|-------------|
+| `tmux` (기본) | tmux 세션에서 백그라운드 실행 | 터미널 종료, SSH 끊김 시 프로세스 유지 |
+| `process` | 현재 프로세스에서 직접 실행 | tmux 미설치 환경 대응 |
+
+두 모드 모두 **절대시간 기반 폴링** 사용:
+- 10초마다 "마지막 폴링 후 intervalMs 경과 여부" 체크
+- macOS 잠자기 모드 동안은 CPU 정지로 실행 불가 (OS 제약)
+- 잠자기 해제 직후 경과 시간 감지 → 즉시 폴링 실행
+- preflight에서 tmux 미설치 감지 시 자동으로 process 모드 fallback
+
+설정: `config.loop.intervalMs` (기본 300000 = 5분), `config.loop.sessionName` (기본 `bylane-loops`)
+
 ## 상태 파일 스키마
 
 ```json
@@ -92,6 +122,8 @@ tests/
 ## 주의사항
 
 - `.bylane/state/`는 .gitignore로 제외됨 (런타임 상태)
+- `.bylane/memory/`는 .gitignore로 제외됨 (issueMemory 로컬 파일)
 - `.bylane/bylane.json`은 추적됨 (프로젝트 설정)
 - `docs/`는 .gitignore로 제외됨 (내부 설계 문서)
 - pre-commit 훅: `npm install` 시 자동 등록 (`prepare` 스크립트)
+- issueMemory: 루프 비활성 시 로컬 파일, 루프 실행 중 GitHub 이슈 코멘트로 기록

package/README.md

@@ -11,6 +11,7 @@ GitHub Issues에서 시작해 코드 구현, 테스트, 커밋, PR 생성, 리
 | 기능 | 설명 |
 |------|------|
 | **전체 워크플로우** | 자연어 한 줄로 이슈 → 코드 → 테스트 → 커밋 → PR 자동화 |
+| **issueMemory** | 이슈별 작업 컨텍스트(아키텍처 결정, 트러블슈팅 등) 자동 기록 및 재활용 |
 | **프로젝트 분석** | 코드 스타일·디자인 토큰·아키텍처 자동 분석, `.claude/instructions/` 생성 |
 | **인라인 코드 리뷰** | 변경 라인마다 개별 코멘트 + GitHub suggestion 블록 자동 등록 |
 | **자동 리뷰 루프** | 5분 주기로 review 요청된 PR을 자동 감지 → 리뷰 실행 |
@@ -110,6 +111,60 @@ npx @elyun/bylane preflight
 /bylane 리뷰 #45 반영해줘
 ```
 
+### 효과적인 지시 방법
+
+byLane은 지시 내용을 바탕으로 코드베이스를 분석하고 사용자와 문답을 거쳐 이슈를 작성합니다.
+지시가 구체적일수록 문답 횟수가 줄고 이슈 품질이 높아집니다.
+
+#### 신규 기능
+
+목적과 UI 힌트를 함께 제공하면 좋습니다:
+
+```
+/bylane 헤더 우측에 다크모드 토글 버튼 추가해줘. 상태는 localStorage에 저장하고 시스템 설정도 따라가게 해줘.
+```
+
+Figma 링크가 있으면 포함하세요:
+
+```
+/bylane 결제 흐름 추가해줘. 디자인은 https://figma.com/... 참고해줘.
+```
+
+#### 버그 수정
+
+재현 조건과 기대 동작을 함께 적으면 분석 범위가 좁아집니다:
+
+```
+/bylane 로그인 후 새로고침하면 세션이 풀리는 버그 수정해줘. 토큰 갱신 로직 쪽 문제인 것 같아.
+```
+
+#### 기존 기능 개선
+
+현재 상태의 어느 부분이 문제인지 지적하면 최소 변경으로 진행됩니다:
+
+```
+/bylane 상품 목록 API 호출이 매번 발생해서 느린데, 캐싱 넣어줘. SWR 이미 쓰고 있어.
+```
+
+#### 이슈 번호로 구현
+
+이미 작성된 이슈를 그대로 구현할 때:
+
+```
+/bylane issue #42 구현해줘
+```
+
+issue-agent가 이슈 본문의 "구현 방향"과 "관련 파일" 섹션을 읽어 code-agent에 전달합니다.
+이슈 본문에 배경, 접근 방법, 영향 범위가 잘 정리되어 있을수록 추가 문답 없이 바로 구현합니다.
+
+#### 피해야 할 패턴
+
+| 지시 | 문제 | 개선 |
+|------|------|------|
+| `/bylane 버그 고쳐줘` | 어떤 버그인지 불명확 → 문답 증가 | `/bylane 장바구니 수량 변경 시 합계가 안 바뀌는 버그 수정해줘` |
+| `/bylane 리팩토링해줘` | 범위 불명확 → 전체 분석 필요 | `/bylane useCart hook이 너무 커서 상태 관리 부분만 분리해줘` |
+| `/bylane 성능 개선` | 측정 기준 없음 | `/bylane 홈 화면 LCP가 4초 넘는데 이미지 lazy loading 추가해줘` |
+
 ### 개별 에이전트 실행
 
 ```
@@ -266,6 +321,48 @@ auto 모드에서는 실행 전 요약을 먼저 보여주고 확인을 받습
 
 ---
 
+## issueMemory
+
+이슈 단위로 작업 컨텍스트를 자동으로 기록하고, 다음 세션에서 재활용합니다.
+
+### 동작 방식
+
+- **루프 비활성 시** — `.bylane/memory/issues/{이슈번호}.md` 로컬 파일에 기록
+- **루프 실행 중** — GitHub 이슈 코멘트로 기록 (팀 전체가 볼 수 있도록)
+
+기록 내용: 작업 요약, 변경 파일, 아키텍처 결정, 트러블슈팅 내역
+
+### 자동 기록
+
+issue-agent와 code-agent가 작업 완료 후 자동으로 기록합니다. 별도 설정 불필요.
+
+code-agent는 작업 시작 시 이전 세션의 메모리를 불러와 일관된 아키텍처 결정을 유지합니다.
+
+### 수동 사용
+
+```bash
+npx @elyun/bylane memory read 123       # 이슈 #123 메모리 조회
+npx @elyun/bylane memory list           # 메모리가 있는 이슈 목록
+npx @elyun/bylane memory append 123 code-agent "메모 내용"  # 직접 추가
+```
+
+### 설정
+
+`.bylane/bylane.json`:
+
+```json
+{
+  "memory": {
+    "enabled": true,
+    "dir": ".bylane/memory"
+  }
+}
+```
+
+`enabled: false`로 비활성화할 수 있습니다.
+
+---
+
 ## 프로젝트 분석
 
 `/bylane analyze` 실행 시 현재 프로젝트를 자동 분석하여 Claude Code가 참조할 instruction 파일을 생성합니다.
@@ -355,6 +452,10 @@ respond-loop    독립: 5분 주기 리뷰 코멘트 감지
     "templateFile": "",
     "footer": "{model} · {date}"
   },
+  "memory": {
+    "enabled": true,
+    "dir": ".bylane/memory"
+  },
   "extensions": {
     "figma": { "enabled": false, "useAt": "issue-analysis" }
   }

package/commands/bylane-code-agent.md

@@ -1,13 +1,38 @@
 ---
 name: bylane-code-agent
-description: issue-agent의 스펙을 기반으로 프론트엔드 코드를 구현한다.
+description: issue-agent의 전략 스펙을 기반으로 코드를 구현한다.
 ---
 
 # Code Agent
 
-## 입력
+## 입력 읽기
 
-`.bylane/state/issue-agent.json`에서 `spec` 읽기. 없으면 사용자에게 스펙 텍스트 직접 입력 요청.
+### 1. issue-agent 상태에서 spec 로드
+
+`.bylane/state/issue-agent.json`에서 다음 필드를 읽는다:
+
+| 필드 | 용도 |
+|------|------|
+| `spec.title` | 작업 제목 |
+| `spec.approach` | 채택된 구현 방향 |
+| `spec.affectedFiles` | 수정/추가할 파일 목록 |
+| `spec.checklist` | 구현 체크리스트 |
+| `spec.figmaSpec` | Figma 컬러토큰·컴포넌트 구조 |
+| `issueType` | `new-feature` / `bug` / `improvement` / `chore` |
+
+없으면 GitHub 이슈 본문을 직접 로드하여 "구현 방향", "관련 파일 및 영향 범위", "구현 체크리스트" 섹션을 파싱한다.
+
+### 2. issueMemory 로드
+
+이슈 번호를 알고 있으면 이전 세션 컨텍스트를 확인한다:
+
+```bash
+npx @elyun/bylane memory read ISSUE_NUMBER
+```
+
+아키텍처 결정이나 트러블슈팅 기록이 있으면 구현에 반영한다.
+
+---
 
 ## 실행 전 상태 기록
 
@@ -15,30 +40,69 @@ description: issue-agent의 스펙을 기반으로 프론트엔드 코드를 구
 npx @elyun/bylane state write code-agent '{"status":"in_progress","startedAt":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","progress":0,"currentTask":"코드 구현 시작","retries":0,"log":[]}'
 ```
 
+---
+
 ## 실행 흐름
 
-1. `.bylane/state/issue-agent.json` 로드하여 `spec` 추출
-2. `spec.checklist` 항목을 순서대로 구현
-3. Figma 스펙이 있으면 (`spec.figmaSpec.enabled === true`):
-   - `colorTokens`를 CSS 변수 또는 Tailwind config 값으로 변환
-   - 컴포넌트 구조를 Figma 계층에 맞게 구현
-4. 기존 코드베이스 패턴 파악 후 동일 스타일로 작성 (TypeScript, 테스트 파일 위치 등)
-5. 각 파일 구현 후 `appendLog` 호출:
+### issueType별 접근 전략
+
+#### `new-feature`
+- `spec.affectedFiles`의 신규 파일부터 생성
+- 유사 구현 패턴(이슈 본문 "코드 패턴 참고" 섹션) 따르기
+- Figma 스펙이 있으면 컬러토큰 → CSS 변수/Tailwind config 변환
+
+#### `bug`
+- 이슈 본문의 "문제 지점" 파일부터 열기
+- 원인 파악 후 최소 변경으로 수정
+- 재현 케이스를 테스트로 먼저 작성 (TDD)
+
+#### `improvement`
+- 기존 구현 파악 후 변경 범위 최소화
+- 사이드 이펙트 발생 가능 파일은 이슈 본문 "영향 범위" 기준으로 확인
+
+#### `chore`
+- 기능 변경 없음 확인 후 진행
+- 설정 파일 변경 시 기존 동작 보존 여부 체크
+
+### 구현 순서
+
+1. `spec.checklist` 항목을 순서대로 처리
+2. 각 파일 구현 완료 시 상태 로그 기록:
    ```bash
    npx @elyun/bylane state append code-agent "FILENAME 구현 완료"
    ```
-6. 구현 완료 후 상태 업데이트:
-   ```bash
-   npx @elyun/bylane state write code-agent '{"status":"completed","progress":100,"currentTask":"구현 완료","retries":0,"changedFiles":CHANGED_FILES_ARRAY}'
-   ```
+3. 코드베이스 기존 패턴과 동일한 스타일 유지 (TypeScript, 테스트 위치, import 방식 등)
 
-## 코딩 원칙
+### 코딩 원칙
 
 - 함수형 컴포넌트 + hooks 우선
 - 파일당 단일 책임
 - 200줄 초과 시 분리 고려
 - 불변성 패턴 유지 (객체 직접 수정 금지)
 
+---
+
+## 완료 처리
+
+```bash
+npx @elyun/bylane state write code-agent '{"status":"completed","progress":100,"currentTask":"구현 완료","retries":0,"changedFiles":CHANGED_FILES_ARRAY}'
+```
+
+---
+
+## issueMemory 기록
+
+```bash
+npx @elyun/bylane memory append ISSUE_NUMBER code-agent "구현 요약: SUMMARY
+변경 파일: CHANGED_FILES
+아키텍처 결정: DECISIONS
+트러블슈팅: ISSUES_FACED"
+```
+
+`memory.enabled: false`이면 생략.
+
+---
+
 ## 출력
 
 `.bylane/state/code-agent.json`의 `changedFiles`: 변경된 파일 경로 배열

package/commands/bylane-issue-agent.md

@@ -1,13 +1,18 @@
 ---
 name: bylane-issue-agent
-description: GitHub Issue 생성 및 분석. Figma 링크 감지 시 스펙 추출.
+description: 코드베이스 분석 + 사용자 문답으로 전략을 수립하고 GitHub 이슈를 작성한다.
 ---
 
 # Issue Agent
 
+## 역할
+
+코드베이스를 병렬로 분석하고, 사용자와 문답을 거쳐 이슈 유형을 분류한 뒤,
+code-agent가 방향을 명확하게 읽을 수 있는 구조화된 이슈를 작성한다.
+
 ## GitHub 접근 방법
 
-`.bylane/bylane.json`의 `github.method` 확인:
+`.bylane/bylane.json`의 `github.method`:
 
 | 값 | 동작 |
 |----|------|
@@ -16,69 +21,195 @@ description: GitHub Issue 생성 및 분석. Figma 링크 감지 시 스펙 추
 | `"api"` | REST API + `$GITHUB_TOKEN` |
 | `"auto"` (기본) | MCP → CLI → API 순서로 시도 |
 
-## 입력
+## 상태 기록 (시작 시)
+
+```bash
+npx @elyun/bylane state write issue-agent '{"status":"in_progress","startedAt":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","progress":0,"currentTask":"전략 수립 중","retries":0,"log":[]}'
+```
 
-- 자유 텍스트 (새 이슈 생성용) OR GitHub Issue 번호 (#N)
+---
 
 ## 실행 흐름
 
-### 새 이슈 생성 모드 (텍스트 입력)
+### Phase 0 — issueMemory 로드 (이슈 번호가 있는 경우)
+
+기존 이슈 번호가 입력되었으면 이전 작업 컨텍스트를 불러온다:
+
+```bash
+npx @elyun/bylane memory read ISSUE_NUMBER
+```
+
+출력된 내용(이전 아키텍처 결정, 트러블슈팅 기록)을 이후 분석에 반영한다.
+
+---
+
+### Phase 1 — 이슈 유형 1차 분류
+
+입력 텍스트 또는 기존 이슈 본문을 분석하여 유형을 예비 분류:
+
+| 유형 | 판단 기준 |
+|------|-----------|
+| `new-feature` | 신규 컴포넌트/페이지/기능 추가 |
+| `bug` | 오류, 크래시, 잘못된 동작 |
+| `improvement` | 기존 기능 수정·개선·리팩토링 |
+| `chore` | 설정, 의존성, 빌드, 문서 |
+
+---
+
+### Phase 2 — 코드베이스 병렬 분석
+
+서브에이전트 3개를 **동시에** 실행한다. 각 에이전트는 아래 질문에 답한다.
+
+#### 서브에이전트 A — 관련 파일 탐색
+- 입력 의도와 관련된 파일·폴더를 DFS로 탐색
+- 관련 컴포넌트, hook, util, 타입 정의 목록화
+- 현재 구현 방식 요약 (있는 경우)
+
+#### 서브에이전트 B — 코드 패턴 분석
+- 유사 기능의 구현 패턴 샘플링 (컴포넌트 구조, 상태 관리, API 호출 방식)
+- 네이밍 컨벤션, 파일 분리 방식
+- 테스트 파일 위치 및 작성 패턴
+
+#### 서브에이전트 C — 의존성 및 영향 범위
+- 변경 시 영향받는 파일·모듈 목록
+- 공유 컴포넌트/훅 여부 확인
+- `bug` / `improvement` 유형이면 해당 코드의 현재 상태와 문제 지점 파악
+
+**`extensions.figma.enabled === true`이고 Figma URL이 있는 경우:**
+서브에이전트 A와 병렬로 Figma MCP 분석도 실행:
+- `get_file` / `get_node`로 프레임/컴포넌트 구조 추출
+- 컬러 토큰, 타이포그래피, 레이아웃 정보 추출
+- 실패 시 경고 로그 후 텍스트 기반 스펙으로 fallback
+
+---
+
+### Phase 3 — 사용자 문답 (방향 확정)
+
+병렬 분석 결과를 요약하여 사용자에게 제시하고, **핵심 결정 사항만** 질문한다.
+
+질문 예시 (유형에 따라 선택):
+
+**new-feature:**
+```
+분석 결과:
+- 관련 파일: src/components/theme/, src/hooks/useTheme.ts
+- 유사 구현: ColorPicker 컴포넌트 (src/components/ColorPicker/)
+
+결정이 필요한 사항:
+1. 토글 위치: 헤더 우측 / 사이드바 하단 / 플로팅 버튼?
+2. 상태 저장: localStorage / 서버 동기화?
+```
+
+**bug:**
+```
+분석 결과:
+- 문제 지점: src/hooks/useAuth.ts:47 — 토큰 만료 시 갱신 로직 누락
+- 영향 범위: useAuth를 사용하는 12개 컴포넌트
+
+확인 사항:
+1. 재현 조건이 있으신가요? (특정 브라우저, 로그인 상태 등)
+2. 임시 수정 vs 근본 해결 중 어느 방향으로 진행할까요?
+```
+
+문답은 **1~3개 질문**으로 제한. 명확한 경우 생략 가능.
+
+---
+
+### Phase 4 — 이슈 작성
+
+문답 결과와 분석 내용을 바탕으로 GitHub 이슈를 작성한다.
+
+#### 이슈 본문 구조
+
+```markdown
+## 개요
+
+[한 줄 요약 — 무엇을, 왜]
+
+**유형:** `new-feature` | `bug` | `improvement` | `chore`
+
+---
+
+## 배경 및 목적
+
+[사용자 의도 + 분석으로 파악한 현재 상태]
+
+---
+
+## 구현 방향
+
+[Phase 3 문답에서 확정된 전략적 방향]
+
+- 접근 방법: ...
+- 채택 이유: ...
+- 제외한 대안: ... (이유)
+
+---
+
+## 관련 파일 및 영향 범위
+
+| 파일/모듈 | 역할 | 변경 필요 여부 |
+|-----------|------|--------------|
+| `src/hooks/useTheme.ts` | 테마 상태 관리 | 수정 |
+| `src/components/Header/` | 토글 위치 | 추가 |
+
+---
+
+## 코드 패턴 참고
 
-1. 입력 텍스트에서 추출:
-   - 제목 (50자 이내), 상세 설명, 구현 체크리스트, Figma URL
+[서브에이전트 B가 발견한 유사 구현 패턴 요약]
 
-2. 이슈 생성:
+```typescript
+// 유사 구현 예시 (src/components/ColorPicker/index.tsx 참조)
+```
+
+---
 
-   **MCP:**
-   → GitHub MCP `create_issue` 도구 사용
+## Figma 스펙 (해당 시)
 
-   **CLI:**
-   ```bash
-   gh issue create \
-     --title "TITLE" \
-     --body "BODY" \
-     --label "bylane-auto"
-   ```
+- 컴포넌트: [컴포넌트명]
+- 컬러 토큰: `--color-primary: #3B82F6`
+- 레이아웃: [설명]
 
-   **API:**
-   ```bash
-   curl -s -X POST \
-     -H "Authorization: Bearer $GITHUB_TOKEN" \
-     -H "Content-Type: application/json" \
-     https://api.github.com/repos/OWNER/REPO/issues \
-     -d '{"title":"TITLE","body":"BODY","labels":["bylane-auto"]}'
-   ```
+---
 
-3. Figma MCP 활성화 여부 확인 (`extensions.figma.enabled`):
-   - `true`이고 Figma URL 있으면 → Figma 분석 단계 실행
-   - `false` → 텍스트 기반 스펙만 생성
+## 구현 체크리스트
 
-### 기존 이슈 분석 모드 (Issue 번호 입력)
+- [ ] [첫 번째 구현 단위]
+- [ ] [두 번째 구현 단위]
+- [ ] 테스트 작성
+- [ ] 기존 테스트 통과 확인
 
-1. 이슈 내용 로드:
+---
 
-   **MCP:**
-   → GitHub MCP `get_issue` 도구 사용
+## 주의사항
 
-   **CLI:**
-   ```bash
-   gh issue view NUMBER --json title,body,labels
-   ```
+[영향 범위, 사이드 이펙트, 알려진 제약]
+```
 
-   **API:**
-   ```bash
-   curl -s \
-     -H "Authorization: Bearer $GITHUB_TOKEN" \
-     https://api.github.com/repos/OWNER/REPO/issues/NUMBER
-   ```
+#### 이슈 생성
 
-2. 본문에서 Figma URL 추출 시도 후 스펙 생성
+**MCP:**
+→ GitHub MCP `create_issue` 도구 사용
 
-### Figma 분석 (활성화된 경우)
+**CLI:**
+```bash
+gh issue create \
+  --title "TITLE" \
+  --body "BODY" \
+  --label "bylane-auto"
+```
 
-Figma MCP `get_file` 또는 `get_node` 도구로 프레임/컴포넌트 분석.
+**API:**
+```bash
+curl -s -X POST \
+  -H "Authorization: Bearer $GITHUB_TOKEN" \
+  -H "Content-Type: application/json" \
+  https://api.github.com/repos/OWNER/REPO/issues \
+  -d '{"title":"TITLE","body":"BODY","labels":["bylane-auto"]}'
+```
 
-**실패 시 fallback:** 경고 로그 후 텍스트 기반 스펙 사용
+---
 
 ## 출력
 
@@ -91,20 +222,35 @@ Figma MCP `get_file` 또는 `get_node` 도구로 프레임/컴포넌트 분석.
   "progress": 100,
   "issueNumber": 123,
   "issueUrl": "https://github.com/...",
+  "issueType": "new-feature",
   "spec": {
     "title": "다크모드 토글 버튼 추가",
     "description": "...",
-    "checklist": ["ThemeToggle 컴포넌트 생성", "useTheme hook 구현"],
+    "approach": "localStorage 기반 useTheme hook 확장",
+    "affectedFiles": ["src/hooks/useTheme.ts", "src/components/Header/"],
+    "checklist": ["ThemeToggle 컴포넌트 생성", "useTheme hook 수정", "테스트 작성"],
     "figmaSpec": { "enabled": false, "components": [], "colorTokens": {} }
   }
 }
 ```
 
-상태 기록:
+---
+
+## issueMemory 기록
+
+작업 완료 후:
+
 ```bash
-npx @elyun/bylane state write issue-agent '{"status":"in_progress","startedAt":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","progress":0,"retries":0}'
+npx @elyun/bylane memory append ISSUE_NUMBER issue-agent "유형: ISSUE_TYPE
+방향: APPROACH
+관련 파일: AFFECTED_FILES
+특이사항: NOTES"
 ```
 
+`memory.enabled: false`이면 생략.
+
+---
+
 ## 수동 실행
 
 `/bylane issue #123` 또는 `/bylane issue 다크모드 토글 추가해줘`

package/commands/bylane-orchestrator.md

@@ -1,57 +1,62 @@
 ---
 name: bylane-orchestrator
-description: byLane 메인 오케스트레이터. 자연어 의도를 파싱해 에이전트 파이프라인을 실행한다.
+description: byLane 메인 오케스트레이터. 전략 수립 후 에이전트 파이프라인을 실행한다.
 ---
 
 # byLane Orchestrator
 
 ## 역할
 
-사용자의 자연어 입력을 파싱하여 어떤 에이전트를 어떤 순서로 실행할지 결정한다.
+사용자 의도를 파싱하고, issue-agent를 통해 전략을 수립한 뒤 에이전트 파이프라인을 실행한다.
 
 ## 실행 전 체크
 
-1. 사전 점검 실행:
+1. 사전 점검:
    ```bash
    npx @elyun/bylane preflight
    ```
-   - 점검 실패 시 안내 메시지를 출력하고 워크플로우를 **중단**한다.
-   - `.bylane/bylane.json` 없으면 즉시 `bylane-setup` 스킬 실행.
+   실패 시 안내 메시지 출력 후 **중단**. `.bylane/bylane.json` 없으면 즉시 `bylane-setup` 스킬 실행.
 
 2. `.bylane/state/` 디렉토리 확인. 없으면 생성.
 
 ## 에이전트별 모델 결정
 
-각 에이전트 실행 전 사용할 모델을 config에서 읽는다:
-
 ```bash
 npx @elyun/bylane models
 ```
 
-출력 형식: `AGENT_NAME=MODEL_ID` (한 줄씩)
-
-에이전트 호출 시 해당 모델을 `model` 파라미터로 전달한다.
+출력 형식: `AGENT_NAME=MODEL_ID` (한 줄씩). 에이전트 호출 시 `model` 파라미터로 전달.
 
 ## 의도 파싱 규칙
 
-입력을 분석하여 아래 중 하나로 분류:
-
-| 패턴 | 실행할 에이전트 체인 |
+| 패턴 | 실행 흐름 |
 |---|---|
-| "구현", "만들어", "추가해", 이슈 없음 | issue-agent → code-agent → test-agent → commit-agent → pr-agent → review-agent → notify-agent |
-| "issue #N 구현", "이슈 #N 작업" | issue-agent(분석) → code-agent → test-agent → commit-agent → pr-agent → review-agent → notify-agent |
+| "구현", "만들어", "추가해", 이슈 없음 | **전략 수립** → issue-agent → code-agent → test-agent → commit-agent → pr-agent → review-agent → notify-agent |
+| "issue #N 구현", "이슈 #N 작업" | **전략 수립(기존 이슈 분석)** → code-agent → test-agent → commit-agent → pr-agent → review-agent → notify-agent |
 | "PR #N 리뷰", "리뷰해줘" | review-agent(PR번호 전달) |
-| "리뷰 #N 반영", "리뷰 수락" | respond-agent(PR번호, 모드=accept 전달) |
-| "리뷰 #N 반박" | respond-agent(PR번호, 모드=rebut 전달) |
+| "리뷰 #N 반영", "리뷰 수락" | respond-agent(PR번호, 모드=accept) |
+| "리뷰 #N 반박" | respond-agent(PR번호, 모드=rebut) |
 | "커밋해줘" | commit-agent |
 | "PR 만들어줘" | pr-agent |
 | "테스트해줘" | test-agent |
-| "프로젝트 분석", "analyze", "코드스타일 분석", "디자인토큰 분석" | analyze-agent |
+| "프로젝트 분석", "analyze" | analyze-agent |
+
+## 전략 수립 단계 (새 기능 / 이슈 구현 시 필수)
+
+`리뷰`, `커밋`, `PR`, `테스트` 단독 요청이 아닌 경우 반드시 전략 수립 후 진행.
+
+issue-agent를 `model` 파라미터와 함께 호출한다. issue-agent 내부에서 다음을 수행:
+
+1. 코드베이스 병렬 분석 (서브에이전트)
+2. 사용자 문답
+3. 이슈 분류 및 작성
+
+상세 로직은 `bylane-issue-agent` 참조.
 
 ## 에이전트 실행 방법
 
-각 에이전트를 순서대로 Agent 도구로 호출한다. 이전 에이전트의 출력을 다음 에이전트의 입력으로 전달한다.
-**config에서 읽은 모델을 `model` 파라미터로 반드시 전달한다.**
+각 에이전트를 순서대로 Agent 도구로 호출. 이전 출력을 다음 입력으로 전달.
+**config에서 읽은 모델을 `model` 파라미터로 반드시 전달.**
 
 상태 기록 (각 에이전트 시작 전):
 ```bash
@@ -60,17 +65,15 @@ npx @elyun/bylane state write AGENT_NAME '{"status":"in_progress","startedAt":"'
 
 ## 피드백 루프
 
-test-agent가 FAIL을 반환하면:
+test-agent가 FAIL 반환 시:
 1. `.bylane/state/test-agent.json`에서 `failureDetails` 읽기
-2. `.bylane/state/orchestrator.json`에서 `retries` 값 읽기
-3. `retries < config.workflow.maxRetries`이면 code-agent를 재실행 (실패 피드백 포함, retries+1)
-4. `retries >= maxRetries`이면 notify-agent에 "개입 필요" 메시지 전송 후 중단
+2. `retries < config.workflow.maxRetries` → code-agent 재실행 (실패 피드백 포함, retries+1)
+3. `retries >= maxRetries` → notify-agent에 "개입 필요" 메시지 후 중단
 
-respond-agent가 "수정 필요"를 반환하면 동일 로직 적용.
+respond-agent가 "수정 필요" 반환 시 동일 로직 적용.
 
 ## 완료 처리
 
-모든 에이전트 완료 후:
 1. 각 에이전트 state를 `status: "completed"`로 업데이트
 2. notify-agent 실행하여 최종 결과 전송
 

package/commands/bylane-setup.md

@@ -6,7 +6,7 @@ description: byLane 하네스 최초 설치 및 설정 위자드. /bylane setup
 # byLane Setup Wizard
 
 사용자에게 단계별로 질문하여 `.bylane/bylane.json`을 생성한다.
-ALWAYS complete all 6 steps before saving. NEVER skip steps.
+ALWAYS complete all 8 steps before saving. NEVER skip steps.
 
 ## 실행 전 준비
 
@@ -83,7 +83,32 @@ Linear API Key는 환경변수명(`LINEAR_API_KEY`)으로 저장. 실제 키값
 
 `permissions.scope`에 저장.
 
-## Step 5/6 — 고급 설정
+## Step 5/8 — Loop 실행 모드
+
+> Loop 실행 모드를 선택하세요:
+> 1. tmux  — tmux 세션에서 백그라운드 실행 (터미널 종료 후에도 유지, 권장)
+> 2. process — 현재 프로세스에서 직접 실행 (잠자기 모드 대응 포함)
+
+- `1` → `loop.mode = "tmux"`, `loop.sessionName` 입력 (Enter = `bylane-loops`)
+- `2` → `loop.mode = "process"`
+
+tmux 선택 시 `which tmux`로 설치 여부를 자동 확인한다:
+- 설치됨 → `tmux` 모드 확정
+- 미설치 → 안내 후 `process` 모드로 자동 전환:
+  > tmux가 설치되어 있지 않습니다. process 모드로 설정합니다.
+  > tmux 설치: `brew install tmux`
+
+폴링 주기 입력 (Enter = 5분):
+- `loop.intervalMs`에 저장 (밀리초)
+
+loop 시작/종료 명령 안내:
+```
+bylane loop start   # loop 시작
+bylane loop stop    # loop 종료
+bylane loop status  # 상태 확인
+```
+
+## Step 6/8 — 고급 설정
 
 > 고급 설정을 변경하시겠습니까? (Enter = 기본값 사용)
 
@@ -92,7 +117,7 @@ Linear API Key는 환경변수명(`LINEAR_API_KEY`)으로 저장. 실제 키값
 - `loopTimeoutMinutes` (기본: 30): 루프 타임아웃 (분)
 - Figma MCP 활성화? (y/n, 기본: n)
 
-## Step 6/6 — 브랜치 네이밍
+## Step 7/8 — 브랜치 네이밍
 
 > 브랜치 네이밍 패턴을 선택하세요:
 > 1. {tracker}-{issue-number}              예) issues-32
@@ -107,7 +132,7 @@ Linear API Key는 환경변수명(`LINEAR_API_KEY`)으로 저장. 실제 키값
 직접 입력 시 사용 가능한 토큰 목록 안내:
 `{tracker}`, `{type}`, `{issue-number}`, `{custom-id}`, `{title-slug}`, `{date}`, `{username}`
 
-## Step 7/7 — 에이전트 모델 설정
+## Step 8/8 — 에이전트 모델 설정
 
 > 각 에이전트에 사용할 AI 모델을 설정하시겠습니까? (Enter = 기본값 사용)
 
@@ -147,3 +172,9 @@ Linear API Key는 환경변수명(`LINEAR_API_KEY`)으로 저장. 실제 키값
    모니터 대시보드: npm run monitor (byLane 디렉토리에서)
    또는: /bylane monitor
    ```
+5. Loop 실행 안내:
+   ```
+   Loop 시작: npx @elyun/bylane loop start
+   Loop 종료: npx @elyun/bylane loop stop
+   Loop 상태: npx @elyun/bylane loop status
+   ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyun/bylane",
-  "version": "1.21.0",
+  "version": "1.23.0",
   "description": "Frontend development harness for Claude Code",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -185,6 +185,107 @@ if (command === 'install') {
   const result = runCleanup()
   console.log(formatCleanupResult(result))
   console.log('\n  완료.\n')
+} else if (command === 'memory') {
+  // memory read ISSUE_NUMBER
+  // memory append ISSUE_NUMBER AGENT_NAME "content"
+  // memory list
+  const subCmd = args[1]
+  const { loadConfig } = await import('./config.js')
+  const { readIssueMemory, appendIssueMemory, listIssueMemories } = await import('./memory.js')
+  const config = loadConfig()
+
+  if (subCmd === 'read') {
+    const issueNumber = args[2]
+    if (!issueNumber) { console.error('사용법: bylane memory read <issueNumber>'); process.exit(1) }
+    const content = readIssueMemory(issueNumber, config)
+    console.log(content ?? '(메모리 없음)')
+  } else if (subCmd === 'append') {
+    const issueNumber = args[2]
+    const agentName = args[3]
+    const content = args[4]
+    if (!issueNumber || !agentName || !content) {
+      console.error('사용법: bylane memory append <issueNumber> <agentName> "content"')
+      process.exit(1)
+    }
+    appendIssueMemory(issueNumber, agentName, content, config)
+    console.log(`  + Issue #${issueNumber} 메모리 기록 완료`)
+  } else if (subCmd === 'list') {
+    const issues = listIssueMemories(config)
+    if (issues.length === 0) {
+      console.log('  (기록된 이슈 메모리 없음)')
+    } else {
+      console.log('  기록된 이슈 메모리:')
+      issues.forEach(n => console.log(`  - Issue #${n}`))
+    }
+  } else {
+    console.error('사용법: bylane memory <read|append|list> [issueNumber] [agentName] [content]')
+    process.exit(1)
+  }
+} else if (command === 'loop') {
+  const subCmd = args[1] || 'start'
+  const { resolveLoopMode, startTmuxLoops, stopTmuxLoops, isTmuxSessionAlive } = await import('./loop-utils.js')
+  const { loadConfig } = await import('./config.js')
+  const config = loadConfig()
+  const sessionName = config.loop?.sessionName ?? 'bylane-loops'
+
+  if (subCmd === 'start') {
+    const mode = resolveLoopMode()
+
+    if (mode === 'tmux') {
+      startTmuxLoops(sessionName)
+      console.log(`\n  tmux 세션에 접속하려면: tmux attach -t ${sessionName}\n`)
+    } else {
+      // process 모드: 현재 프로세스에서 직접 실행
+      console.log('\n  process 모드: review-loop + respond-loop 실행\n')
+      const { spawn } = await import('child_process')
+      const review = spawn(process.execPath, ['src/review-loop.js'], { stdio: 'inherit', detached: false })
+      const respond = spawn(process.execPath, ['src/respond-loop.js'], { stdio: 'inherit', detached: false })
+
+      function shutdownAll() {
+        review.kill('SIGTERM')
+        respond.kill('SIGTERM')
+        process.exit(0)
+      }
+      process.on('SIGINT', shutdownAll)
+      process.on('SIGTERM', shutdownAll)
+
+      // 자식 프로세스가 모두 종료되면 부모도 종료
+      let exited = 0
+      const onExit = () => { if (++exited >= 2) process.exit(0) }
+      review.on('exit', onExit)
+      respond.on('exit', onExit)
+    }
+  } else if (subCmd === 'stop') {
+    const mode = resolveLoopMode()
+    if (mode === 'tmux') {
+      stopTmuxLoops(sessionName)
+    } else {
+      // process 모드: state에서 PID를 읽어 종료
+      const { readState } = await import('./state.js')
+      for (const loopName of ['review-loop', 'respond-loop']) {
+        const state = readState(loopName)
+        if (state?.pid) {
+          try {
+            process.kill(state.pid, 'SIGTERM')
+            console.log(`  ${loopName} (PID: ${state.pid}) 종료`)
+          } catch {
+            console.log(`  ${loopName} (PID: ${state.pid}) 이미 종료됨`)
+          }
+        }
+      }
+    }
+  } else if (subCmd === 'status') {
+    const alive = isTmuxSessionAlive(sessionName)
+    const { readState } = await import('./state.js')
+    const reviewState = readState('review-loop')
+    const respondState = readState('respond-loop')
+    console.log(`\n  tmux 세션 (${sessionName}): ${alive ? '실행 중' : '없음'}`)
+    console.log(`  review-loop: ${reviewState?.status ?? 'unknown'}`)
+    console.log(`  respond-loop: ${respondState?.status ?? 'unknown'}\n`)
+  } else {
+    console.error('사용법: bylane loop <start|stop|status>')
+    process.exit(1)
+  }
 } else if (command === 'monitor') {
   // 항상 현재 패키지의 모니터 실행 (버전 일치 보장)
   const monitorPath = join(__dirname, 'monitor', 'index.js')
@@ -193,6 +294,6 @@ if (command === 'install') {
   child.on('exit', code => process.exit(code ?? 0))
 } else {
   console.error(`알 수 없는 명령: ${command}`)
-  console.error('사용법: npx @elyun/bylane [install|monitor] [--symlink]')
+  console.error('사용법: npx @elyun/bylane [install|loop|monitor|preflight|state|memory|cleanup] [--symlink]')
   process.exit(1)
 }

package/src/config.js

@@ -40,6 +40,10 @@ export const DEFAULT_CONFIG = {
     owner: '',
     repo: ''
   },
+  memory: {
+    enabled: true,
+    dir: '.bylane/memory'
+  },
   models: {
     default: 'claude-sonnet-4-6',
     orchestrator: 'claude-opus-4-6',
@@ -53,6 +57,11 @@ export const DEFAULT_CONFIG = {
     'notify-agent': 'claude-haiku-4-5-20251001',
     'analyze-agent': 'claude-opus-4-6'
   },
+  loop: {
+    mode: 'tmux',
+    intervalMs: 300000,
+    sessionName: 'bylane-loops'
+  },
   review: {
     model: 'claude-sonnet-4-6',
     language: 'ko',

package/src/loop-utils.js

@@ -4,6 +4,7 @@
  */
 import { execSync } from 'child_process'
 import { readState, writeState } from './state.js'
+import { loadConfig } from './config.js'
 
 /**
  * 동일 루프가 이미 실행 중이면 기존 프로세스를 종료하고 기다린다.
@@ -45,3 +46,104 @@ export function killExistingLoop(loopName, stateDir = '.bylane/state') {
     }
   }
 }
+
+/**
+ * tmux 세션이 살아있는지 확인
+ * @param {string} sessionName
+ * @returns {boolean}
+ */
+export function isTmuxSessionAlive(sessionName) {
+  try {
+    execSync(`tmux has-session -t ${sessionName}`, { stdio: ['pipe', 'pipe', 'pipe'] })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * tmux 세션에서 review-loop + respond-loop을 실행
+ * @param {string} sessionName
+ */
+export function startTmuxLoops(sessionName = 'bylane-loops') {
+  if (isTmuxSessionAlive(sessionName)) {
+    console.log(`[tmux] 세션 '${sessionName}'이 이미 실행 중입니다.`)
+    return { started: false, reason: 'already_running' }
+  }
+
+  // 첫 번째 윈도우: review-loop
+  execSync(
+    `tmux new-session -d -s ${sessionName} -n review 'node src/review-loop.js'`,
+    { stdio: 'inherit' }
+  )
+  // 두 번째 윈도우: respond-loop
+  execSync(
+    `tmux new-window -t ${sessionName} -n respond 'node src/respond-loop.js'`,
+    { stdio: 'inherit' }
+  )
+
+  console.log(`[tmux] 세션 '${sessionName}' 시작 완료 (review-loop + respond-loop)`)
+  return { started: true, sessionName }
+}
+
+/**
+ * tmux 세션 종료
+ * @param {string} sessionName
+ */
+export function stopTmuxLoops(sessionName = 'bylane-loops') {
+  if (!isTmuxSessionAlive(sessionName)) {
+    console.log(`[tmux] 세션 '${sessionName}'이 존재하지 않습니다.`)
+    return { stopped: false, reason: 'not_running' }
+  }
+
+  execSync(`tmux kill-session -t ${sessionName}`, { stdio: 'inherit' })
+  console.log(`[tmux] 세션 '${sessionName}' 종료 완료`)
+  return { stopped: true, sessionName }
+}
+
+/**
+ * 절대 시간 기반 폴링 타이머.
+ * setInterval과 달리 잠자기 모드 후 깨어났을 때 즉시 보정한다.
+ * @param {() => void | Promise<void>} fn  폴링 콜백
+ * @param {number} intervalMs  폴링 간격 (ms)
+ * @param {number} [checkMs=10000]  체크 주기 (ms)
+ * @returns {{ timer: NodeJS.Timeout, stop: () => void }}
+ */
+export function createAbsoluteTimer(fn, intervalMs, checkMs = 10000) {
+  let lastRun = Date.now()
+
+  const timer = setInterval(async () => {
+    const now = Date.now()
+    if (now - lastRun >= intervalMs) {
+      lastRun = now
+      await fn()
+    }
+  }, checkMs)
+
+  return {
+    timer,
+    stop() { clearInterval(timer) }
+  }
+}
+
+/**
+ * 현재 설정에서 loop 모드를 결정한다.
+ * tmux 모드인데 tmux가 없으면 process로 fallback.
+ * @returns {'tmux' | 'process'}
+ */
+export function resolveLoopMode() {
+  const config = loadConfig()
+  const mode = config.loop?.mode ?? 'tmux'
+
+  if (mode === 'tmux') {
+    try {
+      execSync('which tmux', { stdio: ['pipe', 'pipe', 'pipe'] })
+      return 'tmux'
+    } catch {
+      console.log('[loop] tmux 미설치 — process 모드로 fallback합니다.')
+      return 'process'
+    }
+  }
+
+  return 'process'
+}

package/src/memory.js

@@ -0,0 +1,93 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from 'fs'
+import { join } from 'path'
+import { execSync } from 'child_process'
+
+// 현재 실행 중인 루프가 있는지 확인 (review-loop, respond-loop)
+function isAnyLoopActive(stateDir = '.bylane/state') {
+  if (!existsSync(stateDir)) return false
+  try {
+    return readdirSync(stateDir)
+      .filter(f => f.endsWith('-loop.json'))
+      .some(f => {
+        try {
+          const s = JSON.parse(readFileSync(join(stateDir, f), 'utf8'))
+          return s.status === 'running'
+        } catch { return false }
+      })
+  } catch { return false }
+}
+
+function getIssueMemoryPath(issueNumber, config) {
+  const dir = config?.memory?.dir ?? '.bylane/memory'
+  return join(dir, 'issues', `${issueNumber}.md`)
+}
+
+export function readIssueMemory(issueNumber, config = {}) {
+  const path = getIssueMemoryPath(issueNumber, config)
+  if (!existsSync(path)) return null
+  try { return readFileSync(path, 'utf8') } catch { return null }
+}
+
+export function appendIssueMemory(issueNumber, agentName, content, config = {}) {
+  if (config?.memory?.enabled === false) return
+
+  const timestamp = new Date().toISOString()
+  const entry = `\n## [${agentName}] ${timestamp}\n\n${content}\n`
+
+  if (isAnyLoopActive()) {
+    // 루프 실행 중 → GitHub 이슈 코멘트에 기록
+    postGitHubComment(issueNumber, entry, config)
+  } else {
+    // 루프 없음 → 로컬 파일에 기록
+    const path = getIssueMemoryPath(issueNumber, config)
+    const memDir = join(config?.memory?.dir ?? '.bylane/memory', 'issues')
+    mkdirSync(memDir, { recursive: true })
+
+    const existing = existsSync(path) ? readFileSync(path, 'utf8') : `# Issue #${issueNumber} Memory\n`
+    writeFileSync(path, existing + entry)
+  }
+}
+
+function postGitHubComment(issueNumber, content, config) {
+  try {
+    const method = config?.github?.method ?? 'auto'
+    const owner = config?.github?.owner ?? ''
+    const repo = config?.github?.repo ?? ''
+
+    if ((method === 'auto' || method === 'cli') && isCommandAvailable('gh')) {
+      const repoFlag = owner && repo ? `--repo ${owner}/${repo}` : ''
+      execSync(`gh issue comment ${issueNumber} ${repoFlag} --body ${JSON.stringify(content)}`, { stdio: 'ignore' })
+      return
+    }
+
+    if ((method === 'auto' || method === 'api') && process.env.GITHUB_TOKEN) {
+      const url = `https://api.github.com/repos/${owner}/${repo}/issues/${issueNumber}/comments`
+      execSync(
+        `curl -s -X POST -H "Authorization: Bearer ${process.env.GITHUB_TOKEN}" -H "Content-Type: application/json" ${url} -d ${JSON.stringify(JSON.stringify({ body: content }))}`,
+        { stdio: 'ignore' }
+      )
+    }
+  } catch {
+    // GitHub 코멘트 실패 시 로컬 파일에 fallback
+    const path = getIssueMemoryPath(issueNumber, config)
+    const memDir = join(config?.memory?.dir ?? '.bylane/memory', 'issues')
+    mkdirSync(memDir, { recursive: true })
+    const existing = existsSync(path) ? readFileSync(path, 'utf8') : `# Issue #${issueNumber} Memory\n`
+    writeFileSync(path, existing + content)
+  }
+}
+
+function isCommandAvailable(cmd) {
+  try { execSync(`which ${cmd}`, { stdio: 'ignore' }); return true } catch { return false }
+}
+
+export function listIssueMemories(config = {}) {
+  const dir = join(config?.memory?.dir ?? '.bylane/memory', 'issues')
+  if (!existsSync(dir)) return []
+  try {
+    return readdirSync(dir)
+      .filter(f => f.endsWith('.md'))
+      .map(f => f.replace('.md', ''))
+      .sort((a, b) => Number(a) - Number(b))
+  } catch { return [] }
+}

package/src/monitor/index.js

@@ -97,6 +97,14 @@ screen.key('s', () => {
   list.focus()
   screen.render()
 
+  // 명시적 키 바인딩 (screen-level 핸들러와 충돌 방지)
+  list.key(['up', 'k'], () => { list.up(1); screen.render() })
+  list.key(['down', 'j'], () => { list.down(1); screen.render() })
+  list.key('enter', () => {
+    const idx = list.selected
+    list.emit('select', list.items[idx], idx)
+  })
+
   list.on('select', (item, idx) => {
     const target = items[idx]
     if (!target) { screen.remove(list); screen.render(); return }

package/src/preflight.js

@@ -17,6 +17,12 @@ function run(cmd) {
   }
 }
 
+export function checkTmux() {
+  const which = run('which tmux')
+  if (!which.ok) return { ok: false, reason: 'tmux 미설치 — loop을 process 모드로 실행합니다', fix: 'brew install tmux  # 또는 https://github.com/tmux/tmux' }
+  return { ok: true, detail: which.out }
+}
+
 function checkGhCli() {
   const which = run('which gh')
   if (!which.ok) return { ok: false, reason: 'gh CLI 미설치', fix: 'brew install gh  # 또는 https://cli.github.com' }
@@ -105,14 +111,20 @@ export function runPreflight() {
     }
   }
 
-  // 3. 알림 채널 (설정된 경우만)
+  // 3. tmux (loop.mode가 tmux인 경우)
+  if (config.loop?.mode === 'tmux') {
+    const tmux = checkTmux()
+    results.push({ name: 'tmux', ...tmux, warn: !tmux.ok })
+  }
+
+  // 4. 알림 채널 (설정된 경우만)
   const slack = checkSlack(config)
   if (slack) results.push({ name: 'Slack 알림', ...slack })
 
   const telegram = checkTelegram(config)
   if (telegram) results.push({ name: 'Telegram 알림', ...telegram })
 
-  const passed = results.every(r => r.ok)
+  const passed = results.filter(r => !r.warn).every(r => r.ok)
   return { passed, results }
 }
 

package/src/respond-loop.js

@@ -8,9 +8,10 @@ import { execSync } from 'child_process'
 import { mkdirSync } from 'fs'
 import { writeState, readState, appendLog } from './state.js'
 import { loadConfig } from './config.js'
-import { killExistingLoop } from './loop-utils.js'
+import { killExistingLoop, createAbsoluteTimer } from './loop-utils.js'
 
-const INTERVAL_MS = 5 * 60 * 1000
+const config = loadConfig()
+const INTERVAL_MS = config.loop?.intervalMs ?? 300000
 const STATE_DIR = '.bylane/state'
 
 mkdirSync(STATE_DIR, { recursive: true })
@@ -173,20 +174,17 @@ async function poll() {
 // 초기 실행
 poll()
 
-// 5분 주기 폴링
-const timer = setInterval(poll, INTERVAL_MS)
+// 절대 시간 기반 폴링 (잠자기 모드 후 즉시 보정)
+const { stop } = createAbsoluteTimer(poll, INTERVAL_MS)
 
 // 종료 처리
-process.on('SIGINT', () => {
-  clearInterval(timer)
+function shutdown() {
+  stop()
   writeState('respond-loop', { status: 'stopped' }, STATE_DIR)
   process.exit(0)
-})
-process.on('SIGTERM', () => {
-  clearInterval(timer)
-  writeState('respond-loop', { status: 'stopped' }, STATE_DIR)
-  process.exit(0)
-})
+}
+process.on('SIGINT', shutdown)
+process.on('SIGTERM', shutdown)
 
 writeState('respond-loop', { status: 'running', startedAt: new Date().toISOString(), pid: process.pid }, STATE_DIR)
 console.log('respond-loop 시작. Ctrl+C로 종료.')

package/src/review-loop.js

@@ -7,9 +7,10 @@ import { execSync } from 'child_process'
 import { mkdirSync } from 'fs'
 import { writeState, readState, appendLog } from './state.js'
 import { loadConfig } from './config.js'
-import { killExistingLoop } from './loop-utils.js'
+import { killExistingLoop, createAbsoluteTimer } from './loop-utils.js'
 
-const INTERVAL_MS = 5 * 60 * 1000
+const config = loadConfig()
+const INTERVAL_MS = config.loop?.intervalMs ?? 300000
 const STATE_DIR = '.bylane/state'
 
 mkdirSync(STATE_DIR, { recursive: true })
@@ -120,20 +121,17 @@ async function poll() {
 // 초기 실행
 poll()
 
-// 5분 주기 폴링
-const timer = setInterval(poll, INTERVAL_MS)
+// 절대 시간 기반 폴링 (잠자기 모드 후 즉시 보정)
+const { stop } = createAbsoluteTimer(poll, INTERVAL_MS)
 
 // 종료 처리
-process.on('SIGINT', () => {
-  clearInterval(timer)
+function shutdown() {
+  stop()
   writeState('review-loop', { status: 'stopped' }, STATE_DIR)
   process.exit(0)
-})
-process.on('SIGTERM', () => {
-  clearInterval(timer)
-  writeState('review-loop', { status: 'stopped' }, STATE_DIR)
-  process.exit(0)
-})
+}
+process.on('SIGINT', shutdown)
+process.on('SIGTERM', shutdown)
 
 writeState('review-loop', { status: 'running', startedAt: new Date().toISOString(), pid: process.pid }, STATE_DIR)
 console.log('review-loop 시작. Ctrl+C로 종료.')