@elyun/bylane 1.22.0 → 1.24.0

package/commands/bylane.md

@@ -1,6 +1,6 @@
 ---
 name: bylane
-description: byLane 메인 커맨드. 자연어로 전체 개발 워크플로우를 실행한다.
+description: byLane 메인 진입점. 자연어 명령을 키워드 감지하여 적절한 에이전트로 자동 라우팅한다. 복합 의도는 오케스트레이터로 전달.
 ---
 
 # /bylane
@@ -8,33 +8,41 @@ description: byLane 메인 커맨드. 자연어로 전체 개발 워크플로우
 ## 사용법
 
 ```
-/bylane [자연어 명령]   — 전체 워크플로우 자동 실행
-/bylane setup          — 셋업 위자드 (재실행 가능)
-/bylane analyze        — 프로젝트 분석 후 .claude/instructions/ 에 instruction 파일 생성
-/bylane monitor        — 실시간 TUI 대시보드
-/bylane issue [#번호 | 텍스트]
-/bylane code [#번호]
-/bylane test
-/bylane commit
-/bylane pr
-/bylane review [PR번호]
-/bylane review-loop    — 5분 주기 자동 리뷰 루프 시작
-/bylane respond [PR번호]
-/bylane respond-loop    — 5분 주기 자동 대응 루프 시작
-/bylane notify
-/bylane status         — 현재 상태 한 줄 요약
+/bylane [자연어 명령]
 ```
 
-## 사전 점검 (모든 명령 전 자동 실행)
+자연어로 개발 의도를 전달하면 키워드를 감지해 적절한 에이전트를 자동 실행한다.
+서브커맨드 없이 **자연어만** 받는다. 개별 에이전트는 `/bylane-*`로 직접 실행한다.
 
-서브커맨드를 라우팅하기 전 아래 점검을 실행한다:
+### 개별 에이전트 직접 실행
+
+| 커맨드 | 설명 |
+|---|---|
+| `/bylane-setup` | GitHub 접근, 이슈 트래커, 알림, 팀 모드, 루프, 브랜치, 모델을 단계별로 설정하여 `.bylane/bylane.json` 생성 |
+| `/bylane-monitor` | blessed 기반 TUI 대시보드 실행 안내. 에이전트 상태/큐/로그를 1초 주기로 표시 |
+| `/bylane-cleanup` | 파일 권한 수정, 죽은 PID 정리, 30분 초과 작업 실패 전환, 큐 pending 복구를 일괄 실행 |
+| `/bylane-analyze-agent` | 코드 스타일/디자인 토큰/아키텍처를 분석하여 `.claude/instructions/`에 저장, CLAUDE.md에 import 추가 |
+| `/bylane-issue-agent` | 코드베이스 병렬 분석 + 사용자 문답으로 전략 스펙 포함 GitHub 이슈 작성. code-agent 입력이 됨 |
+| `/bylane-code-agent` | 이슈 전략 스펙 기반으로 브랜치 생성 + 코드 구현. issueMemory 기록, 실패 시 피드백 재시도 |
+| `/bylane-test-agent` | 테스트 실행 후 PASS/FAIL 반환. FAIL 시 failureDetails를 state에 기록하여 재시도 피드백 제공 |
+| `/bylane-commit-agent` | 변경 파일 분석 → conventional commit(feat/fix/refactor) 메시지 자동 생성. 시크릿 자동 제외 |
+| `/bylane-pr-agent` | 전체 커밋 히스토리 분석 → PR 제목/요약/테스트 계획 자동 작성. 팀 모드 시 리뷰어 할당 |
+| `/bylane-review-agent` | PR diff를 파일별 분석 → 라인별 인라인 코멘트. grammar/domain/code/security 검사, 심각도 분류 |
+| `/bylane-respond-agent` | 리뷰 코멘트 분석 → accept(코드 수정+재커밋) 또는 rebut(근거 반박). CHANGES_REQUESTED 포함 처리 |
+| `/bylane-review-loop` | 설정 주기로 review 요청 PR 감지 → review-queue 기록 → review-agent 자동 실행. 재요청 포함 |
+| `/bylane-respond-loop` | 설정 주기로 내 PR 리뷰/코멘트 감지 → respond-queue 기록 → respond-agent 자동 실행. 재감지 포함 |
+| `/bylane-notify-agent` | 워크플로우 완료/테스트 실패/리뷰 대기/개입 필요 시 Slack/Telegram 알림 발송 |
+
+## 사전 점검 (자동 실행)
+
+키워드 라우팅 전 아래 점검을 실행한다:
 
 ```bash
 npx @elyun/bylane preflight
 ```
 
 점검 항목:
-- `.bylane/bylane.json` 존재 여부 → 없으면 `/bylane setup` 안내 후 중단
+- `.bylane/bylane.json` 존재 여부 → 없으면 `bylane-setup` 스킬 실행 후 중단
 - GitHub 접근 방법 (`github.method` 기준):
   - `cli`: `gh auth status` → 로그인 안 됐으면 `gh auth login` 안내
   - `api`: `GITHUB_TOKEN` 환경변수 → 없으면 설정 방법 안내
@@ -42,44 +50,77 @@ npx @elyun/bylane preflight
 - 알림 채널 (활성화된 경우만): Slack 채널 설정 여부, Telegram 토큰 여부
 
 문제가 있으면 각 항목마다 수정 방법을 출력하고 중단한다.
-`setup`, `status`, `preflight` 서브커맨드는 점검 없이 바로 실행한다.
+**셋업/상태 관련 키워드는 점검 없이 바로 실행한다.**
 
-## 실행 흐름
+## 키워드 감지 및 라우팅
 
-첫 번째 인자가 서브커맨드인지 확인.
-**반드시 아래 표의 "실행 스킬" 전체 이름을 Skill 도구에 전달한다. 서브커맨드 이름(analyze, setup 등)을 그대로 스킬 이름으로 사용하지 않는다.**
+입력된 자연어에서 키워드를 감지하여 적절한 스킬로 라우팅한다.
+반드시 아래 표의 **"실행 스킬" 전체 이름**을 Skill 도구에 전달한다.
+**매칭되는 키워드가 없거나 복합 의도이면 `bylane-orchestrator`로 전달한다.**
 
-| 서브커맨드 | 실행 스킬 |
-|---|---|
-| (없음 or 자연어) | `bylane-orchestrator` |
-| `setup` | `bylane-setup` |
-| `monitor` | 아래 참조 |
-| `issue` | `bylane-issue-agent` |
-| `code` | `bylane-code-agent` |
-| `test` | `bylane-test-agent` |
-| `commit` | `bylane-commit-agent` |
-| `pr` | `bylane-pr-agent` |
-| `review` | `bylane-review-agent` |
-| `analyze` | `bylane-analyze-agent` |
-| `review-loop` | `bylane-review-loop` |
-| `respond` | `bylane-respond-agent` |
-| `respond-loop` | `bylane-respond-loop` |
-| `notify` | `bylane-notify-agent` |
-| `status` | `.bylane/state/` 파일 읽어 한 줄 요약 출력 |
-| `preflight` | 연동 상태 점검 및 문제 안내 |
-
-## monitor 서브커맨드
+### 유틸리티 (점검 생략)
 
-```bash
-npm run monitor --prefix PATH_TO_BYLANE
-```
+| 키워드 | 실행 스킬 | 예시 입력 |
+|---|---|---|
+| `setup`, `셋업`, `설정 위자드`, `초기 설정`, `설치` | `bylane-setup` | "셋업 다시 해줘", "초기 설정" |
+| `monitor`, `모니터`, `대시보드`, `dashboard` | `bylane-monitor` | "모니터 켜줘", "대시보드 보고 싶어" |
+| `cleanup`, `정리`, `상태 초기화`, `리셋`, `reset` | `bylane-cleanup` | "상태 정리해줘", "리셋" |
+| `status`, `상태`, `현황`, `지금 뭐 하고 있어` | 상태 요약 출력 | "상태 보여줘", "현황 알려줘" |
+| `preflight`, `점검`, `연동 확인`, `헬스체크` | preflight 실행 | "점검해줘", "연동 확인" |
 
-또는 byLane이 PATH에 설치된 경우:
-```bash
-bylane-monitor
-```
+### 분석
+
+| 키워드 | 실행 스킬 | 예시 입력 |
+|---|---|---|
+| `analyze`, `분석`, `프로젝트 분석`, `코드 분석`, `구조 분석` | `bylane-analyze-agent` | "프로젝트 분석해줘", "코드 구조 파악해줘" |
+
+### 이슈 & 구현
+
+| 키워드 | 실행 스킬 | 예시 입력 |
+|---|---|---|
+| `이슈 만들어`, `이슈 작성`, `이슈 생성`, `issue 생성` | `bylane-issue-agent` | "이슈 만들어줘", "버그 이슈 작성" |
+| `#N 구현`, `이슈 #N`, `코드 작성`, `코딩`, `구현` + 이슈번호 | `bylane-code-agent` | "#32 구현해줘", "이슈 #15 코딩" |
+
+### 테스트 & 커밋 & PR
+
+| 키워드 | 실행 스킬 | 예시 입력 |
+|---|---|---|
+| `test`, `테스트`, `검증`, `테스트 돌려`, `시험` | `bylane-test-agent` | "테스트 돌려줘", "검증해줘" |
+| `commit`, `커밋`, `커밋해`, `변경사항 저장` | `bylane-commit-agent` | "커밋해줘", "변경사항 커밋" |
+| `pr`, `PR`, `풀리퀘`, `풀 리퀘스트`, `PR 생성`, `PR 만들어` | `bylane-pr-agent` | "PR 만들어줘", "풀리퀘 올려줘" |
+
+### 리뷰 & 대응
+
+| 키워드 | 실행 스킬 | 예시 입력 |
+|---|---|---|
+| `리뷰해`, `코드 리뷰`, `review` + PR번호 | `bylane-review-agent` | "PR #45 리뷰해줘", "코드 리뷰 해줘" |
+| `반영`, `반박`, `대응`, `respond`, `수정 반영`, `리뷰 수락` | `bylane-respond-agent` | "리뷰 반영해줘", "#45 반박해" |
+| `리뷰 루프`, `자동 리뷰`, `리뷰 자동화`, `review loop` | `bylane-review-loop` | "자동 리뷰 시작", "리뷰 루프 켜줘" |
+| `대응 루프`, `자동 대응`, `대응 자동화`, `respond loop` | `bylane-respond-loop` | "자동 대응 시작", "대응 루프 시작" |
+| `루프 시작`, `loop start`, `루프 켜`, `자동화 시작` | `bylane-review-loop` + `bylane-respond-loop` 순차 실행 | "루프 시작해줘", "자동화 켜" |
+| `루프 종료`, `loop stop`, `루프 꺼`, `자동화 중단` | 루프 종료 안내 | "루프 꺼줘", "자동화 중단" |
+
+### 알림
+
+| 키워드 | 실행 스킬 | 예시 입력 |
+|---|---|---|
+| `notify`, `알림`, `알려줘`, `슬랙`, `텔레그램`, `통보` | `bylane-notify-agent` | "슬랙에 알림 보내줘" |
+
+### 복합 의도 → 오케스트레이터
+
+아래 경우는 `bylane-orchestrator`로 전달한다:
+- 키워드가 2개 이상 카테고리에 걸칠 때 ("이슈 만들고 구현까지 해줘")
+- 기능 요청 자연어 ("다크모드 토글 추가해줘", "로그인 페이지 만들어줘")
+- 매칭되는 키워드가 없을 때
+
+## 라우팅 우선순위
+
+1. **유틸리티 키워드** — setup, monitor, cleanup, status, preflight
+2. **루프 키워드** — 리뷰 루프, 대응 루프, 루프 시작/종료
+3. **단일 에이전트 키워드** — review, commit, test, pr 등
+4. **복합 의도 / 자연어** → `bylane-orchestrator`
 
-## status 서브커맨드
+## status 동작
 
 `.bylane/state/*.json` 파일을 읽어 각 에이전트의 현재 상태를 한 줄로 출력:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyun/bylane",
-  "version": "1.22.0",
+  "version": "1.24.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/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로 종료.')