@elyun/bylane 1.30.0 → 1.32.0

package/CLAUDE.md

@@ -11,7 +11,7 @@ byLane — Claude Code용 프론트엔드 개발 자동화 하네스.
 
 ```bash
 npm install          # 의존성 설치 + pre-commit 훅 자동 등록 (prepare 스크립트)
-npm test             # 테스트 실행 (19개)
+npm test             # 테스트 실행 (43개)
 npm run monitor      # 모니터 대시보드
 npm version minor    # 마이너 버전 올리기 (커밋 + 태그 자동 생성)
 npm run release      # npm 배포 (커밋/푸시 완료 후 실행)
@@ -38,16 +38,19 @@ npx @elyun/bylane memory read 123
 - `src/config.js` — `.bylane/bylane.json` 로드/저장/검증 (loadConfig, saveConfig, validateConfig, getAgentModel, DEFAULT_CONFIG)
 - `src/branch.js` — 브랜치명 패턴 엔진 (buildBranchName, buildBranchNameFromConfig)
 - `src/memory.js` — 이슈별 컨텍스트 메모리 유틸 (readIssueMemory, appendIssueMemory, listIssueMemories)
-- `src/cli.js` — npx 설치 CLI (install, loop, --symlink 옵션, 기존 파일 .bak 백업)
+- `src/cli.js` — npx 설치 CLI (install, loop, --symlink 옵션, 기존 파일 .bak 백업, Stop 훅 등록)
 - `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/queue-utils.js` — 큐 상태 관리 유틸 (reconcileQueue, expireStaleItems, gcQueue, maintainQueue)
+- `src/pipeline.js` — 파이프라인 상태 추적 (startPipeline, updatePipelineStep, cancelStalePipeline, blockDownstreamOfFailed)
+- `src/review-loop.js` — review 요청 PR 폴러 → `.bylane/state/review-queue.json` (절대시간 기반 폴링, 큐 reconcile/GC 포함)
+- `src/respond-loop.js` — 내 PR 리뷰/코멘트 폴러 → `.bylane/state/respond-queue.json` (절대시간 기반 폴링, 큐 reconcile/GC 포함)
 - `src/monitor/` — blessed 기반 TUI 대시보드 (2열 그리드, 1초 폴링, fullUnicode)
 - `skills/` — Claude Code 에이전트 skill 파일들
 - `hooks/` — 외부 이벤트 자동 감지 훅
 - `commands/` — `/bylane` 슬래시 커맨드 정의
 - `templates/review-template.md` — 리뷰 코멘트 기본 템플릿
 - `scripts/release.sh` — npm 배포 스크립트 (dirty 체크 + 테스트 + publish)
+- `hooks/bylane-session-cleanup.js` — Stop 훅 (세션 종료 시 in_progress→cancelled, 루프/큐 상태 정리)
 - `.githooks/pre-commit` — 보안 검사 훅 (시크릿/민감파일/console.log)
 
 ## 에이전트 파이프라인
@@ -87,7 +90,7 @@ respond-loop  (독립: 설정 주기로 리뷰 코멘트 감지, 절대시간
 ```json
 {
   "agent": "code-agent",
-  "status": "in_progress | completed | failed | idle",
+  "status": "in_progress | completed | failed | cancelled | blocked | idle",
   "startedAt": "ISO8601",
   "progress": 0,
   "retries": 0,
@@ -95,6 +98,25 @@ respond-loop  (독립: 설정 주기로 리뷰 코멘트 감지, 절대시간
 }
 ```
 
+### 큐 항목 상태 값
+
+`pending` → `reviewing`/`responding` → `resolved` | `expired` (GC 후 제거)
+
+큐 reconcile: 매 poll마다 GitHub 상태와 대조하여 불필요한 pending 항목을 resolved로 전환.
+TTL: 24시간 초과 pending → expired. GC: resolved/expired 후 1시간 경과 시 큐에서 제거.
+
+### 파이프라인 상태 (`pipeline.json`)
+
+```json
+{
+  "agent": "pipeline",
+  "status": "in_progress | completed | failed | cancelled",
+  "pipelineType": "A | B | C_review | C_respond | D",
+  "currentStep": "code-agent",
+  "steps": [{ "agent": "code-agent", "status": "completed" }, ...]
+}
+```
+
 ## GitHub 접근 방법
 
 `github.method`: `"auto"` (기본, MCP→CLI→API 순) | `"mcp"` | `"cli"` | `"api"`
@@ -114,9 +136,11 @@ respond-loop  (독립: 설정 주기로 리뷰 코멘트 감지, 절대시간
 
 ```
 tests/
-├── state.test.js   — writeState, readState, clearState, listStates, appendLog
-├── config.test.js  — loadConfig, saveConfig, validateConfig, DEFAULT_CONFIG
-└── branch.test.js  — buildBranchName (6개 패턴 케이스, 슬래시 엣지케이스 포함)
+├── state.test.js        — writeState, readState, clearState, listStates, appendLog (6개)
+├── config.test.js       — loadConfig, saveConfig, validateConfig, DEFAULT_CONFIG (7개)
+├── branch.test.js       — buildBranchName (6개 패턴 케이스, 슬래시 엣지케이스 포함)
+├── queue-utils.test.js  — reconcileQueue, expireStaleItems, gcQueue, maintainQueue (10개)
+└── pipeline.test.js     — startPipeline, updatePipelineStep, cancelStalePipeline, blockDownstreamOfFailed (14개)
 ```
 
 ## 주의사항

package/README.md

@@ -28,7 +28,7 @@ GitHub Issues에서 시작해 코드 구현, 테스트, 커밋, PR 생성, 리
 - [Claude Code](https://claude.ai/code) CLI
 - Node.js 20+
 - GitHub MCP (Claude Code 기본 제공) / `gh` CLI / `GITHUB_TOKEN` 중 하나
-- Slack MCP 또는 Telegram (알림 사용 시, 선택사항)
+- Slack Incoming Webhook URL 또는 Telegram Bot Token (알림 사용 시, 선택사항)
 - Figma MCP (디자인 연동 사용 시, 선택사항)
 
 ---
@@ -443,7 +443,7 @@ respond-loop    독립: 5분 주기 리뷰 코멘트 감지
     "linear": { "enabled": false, "apiKey": "" }
   },
   "notifications": {
-    "slack": { "enabled": true, "channel": "#dev-alerts" },
+    "slack": { "enabled": true, "webhookUrl": "https://hooks.slack.com/services/T.../B.../..." },
     "telegram": { "enabled": false, "chatId": "" }
   },
   "workflow": {
@@ -486,6 +486,26 @@ respond-loop    독립: 5분 주기 리뷰 코멘트 감지
 }
 ```
 
+### Slack 웹훅 설정
+
+1. [Slack API](https://api.slack.com/apps) → **Create New App** → **Incoming Webhooks** 활성화
+2. **Add New Webhook to Workspace** → 채널 선택 → Webhook URL 복사
+3. `.bylane/bylane.json`에 입력:
+
+```json
+"notifications": {
+  "slack": {
+    "enabled": true,
+    "webhookUrl": "https://hooks.slack.com/services/T.../B.../..."
+  }
+}
+```
+
+알림이 발송되는 시점:
+- ✅ PR 생성/머지 완료
+- ⚠️ 테스트 실패로 개입 필요
+- ❌ 파이프라인 오류
+
 ### 브랜치 네이밍 토큰
 
 | 토큰 | 설명 |

package/commands/bylane-cleanup.md

@@ -25,11 +25,16 @@ npx @elyun/bylane cleanup
 
 | 항목 | 동작 |
 |------|------|
+| stale 파이프라인 | 30분 초과 파이프라인 cascade cancel (하위 에이전트 일괄 취소) |
+| upstream 실패 | 파이프라인 내 실패 에이전트 하류 → `blocked` 처리 |
 | `.bylane/state/` 권한 | 디렉토리 755, 파일 644로 수정 |
 | 죽은 루프 프로세스 | PID 확인 → 없으면 `stopped`로 전환 |
 | 30분 초과 `in_progress` | `failed`로 초기화 |
 | `subagents.json` active | PID 없는 항목 제거 |
 | 큐의 `reviewing`/`responding` | `pending`으로 복구 (재처리 대기) |
+| 큐 TTL 초과 pending | 24시간 초과 → `expired` 전환 |
+| 큐 GC | resolved/expired 후 1시간 경과 항목 제거 |
+| 루프-큐 상태 동기화 | 루프 미실행 시 큐 `stopped` 전환 |
 
 ## 완료
 

package/commands/bylane-notify-agent.md

@@ -38,18 +38,21 @@ PR: PR_URL
 
 ### Slack 알림 (notifications.slack.enabled: true)
 
-Slack MCP `slack_send_message` 도구 사용:
-- 채널: `config.notifications.slack.channel`
-- 완료 메시지:
-  ```
-  [byLane] ✅ 완료: TITLE
-  PR: PR_URL | 소요 시간: ELAPSED
-  ```
-- 개입 필요 메시지:
-  ```
-  [byLane] ⚠️ 개입 필요: TITLE
-  이유: REASON | 확인: PR_URL
-  ```
+`config.notifications.slack.webhookUrl`로 Incoming Webhook POST:
+
+```bash
+# 완료 메시지
+curl -s -X POST "$SLACK_WEBHOOK_URL" \
+  -H "Content-Type: application/json" \
+  -d '{"text":"[byLane] ✅ 완료: TITLE\nPR: PR_URL | 소요 시간: ELAPSED"}'
+
+# 개입 필요 메시지
+curl -s -X POST "$SLACK_WEBHOOK_URL" \
+  -H "Content-Type: application/json" \
+  -d '{"text":"[byLane] ⚠️ 개입 필요: TITLE\n이유: REASON | 확인: PR_URL"}'
+```
+
+`webhookUrl`이 비어 있으면 Slack 알림을 건너뜬다.
 
 ### Telegram 알림 (notifications.telegram.enabled: true)
 

package/commands/bylane-orchestrator.md

@@ -31,6 +31,41 @@ npx @elyun/bylane models
 
 ---
 
+## 파이프라인 상태 추적
+
+각 에이전트 호출 전후에 파이프라인 상태를 기록하여, 세션 종료나 에이전트 실패 시 자동 정리가 가능하게 한다.
+
+### 파이프라인 시작 (에이전트 호출 전)
+
+```bash
+npx @elyun/bylane state write pipeline '{"status":"in_progress","pipelineType":"A","issueNumber":null,"startedAt":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","currentStep":"issue-agent","steps":[{"agent":"issue-agent","status":"pending"},{"agent":"code-agent","status":"pending"},{"agent":"test-agent","status":"pending"},{"agent":"commit-agent","status":"pending"},{"agent":"pr-agent","status":"pending"},{"agent":"review-agent","status":"pending"},{"agent":"notify-agent","status":"pending"}]}'
+```
+
+### 각 에이전트 시작/완료 시
+
+```bash
+# 에이전트 시작 시 — 해당 step을 in_progress로
+npx @elyun/bylane state write pipeline '현재 pipeline state에서 해당 step.status를 "in_progress"로 변경'
+
+# 에이전트 완료 시 — 해당 step을 completed로, currentStep을 다음 단계로
+npx @elyun/bylane state write pipeline '현재 pipeline state에서 해당 step.status를 "completed"로 변경, currentStep 갱신'
+```
+
+### 파이프라인 완료/실패 시
+
+```bash
+# 성공
+npx @elyun/bylane state write pipeline '{"status":"completed","completedAt":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'",...}'
+
+# 실패 (maxRetries 초과 등)
+npx @elyun/bylane state write pipeline '{"status":"failed","failedAt":"'$(date -u +%Y-%m-%dT%H:%M:%SZ)'","reason":"...",...}'
+```
+
+> **중요**: 파이프라인 상태가 30분간 업데이트되지 않으면 cleanup이 자동으로 cascade cancel한다.
+> 세션 종료 시 Stop 훅이 in_progress 파이프라인과 하위 에이전트를 즉시 cancelled로 전환한다.
+
+---
+
 ## 의도 파싱 규칙
 
 ### 파이프라인 A — 새 기능 / 이슈 없는 구현 요청
@@ -94,9 +129,13 @@ npx @elyun/bylane models
 
 ### 각 에이전트 호출 방법
 
-Agent 도구에 아래 형식으로 전달한다:
+Agent 도구에 아래 형식으로 전달한다. **호출 전후로 파이프라인 상태를 갱신**한다:
 
 ```
+# 1. 호출 전: 파이프라인 step을 in_progress로 갱신
+npx @elyun/bylane state write pipeline '{...현재 state에서 해당 step.status → "in_progress"}'
+
+# 2. Agent 도구 호출
 subagent_type: "general-purpose"
 model: {models 명령으로 확인한 해당 에이전트 모델}
 prompt: |
@@ -109,6 +148,9 @@ prompt: |
 
   스킬 완료 후 .bylane/state/{에이전트명}.json 에 결과가 기록된다.
   결과 파일의 status, 핵심 출력 필드만 응답으로 돌려줘.
+
+# 3. 호출 후: 파이프라인 step을 completed/failed로 갱신, currentStep을 다음 에이전트로
+npx @elyun/bylane state write pipeline '{...현재 state에서 해당 step.status → "completed", currentStep → 다음}'
 ```
 
 ---

package/hooks/bylane-session-cleanup.js

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+/**
+ * bylane-session-cleanup.js
+ * Stop 훅 — Claude Code 세션 종료 시 상태 파일 자동 정리
+ *
+ * 처리 항목:
+ * - in_progress 에이전트 → cancelled (세션 종료)
+ * - running 루프 (PID 죽은 경우) → stopped
+ * - running 큐 (루프 죽은 경우) → stopped
+ * - pipeline in_progress → cancelled
+ */
+import { readFileSync, readdirSync, writeFileSync, existsSync } from 'fs'
+
+// stdin 읽기 (훅 프로토콜)
+try { readFileSync('/dev/stdin', 'utf8') } catch {}
+
+const STATE_DIR = '.bylane/state'
+if (!existsSync(STATE_DIR)) process.exit(0)
+
+const now = new Date().toISOString()
+
+function isPidAlive(pid) {
+  try { process.kill(Number(pid), 0); return true } catch { return false }
+}
+
+function readJson(path) {
+  try { return JSON.parse(readFileSync(path, 'utf8')) } catch { return null }
+}
+
+function writeJson(path, data) {
+  writeFileSync(path, JSON.stringify({ ...data, updatedAt: now }, null, 2))
+}
+
+try {
+  const files = readdirSync(STATE_DIR).filter(f => f.endsWith('.json'))
+  const { join } = await import('path')
+
+  for (const file of files) {
+    const name = file.replace('.json', '')
+    if (name === 'cancel' || name === 'subagents') continue
+
+    const path = join(STATE_DIR, file)
+    const state = readJson(path)
+    if (!state) continue
+
+    // 파이프라인: in_progress → cancelled + 하위 step도 cancelled
+    if (name === 'pipeline' && state.status === 'in_progress') {
+      writeJson(path, {
+        ...state,
+        status: 'cancelled',
+        cancelledAt: now,
+        reason: 'session_ended',
+        steps: (state.steps ?? []).map(step =>
+          step.status === 'in_progress' || step.status === 'pending'
+            ? { ...step, status: 'cancelled', cancelledAt: now }
+            : step
+        )
+      })
+      continue
+    }
+
+    // in_progress 에이전트 → cancelled
+    if (state.status === 'in_progress' && !name.endsWith('-loop') && !name.endsWith('-queue')) {
+      writeJson(path, {
+        ...state,
+        status: 'cancelled',
+        cancelledAt: now,
+        reason: 'session_ended'
+      })
+      continue
+    }
+
+    // running 루프: PID 죽었으면 stopped
+    if (name.endsWith('-loop') && state.status === 'running' && state.pid) {
+      if (!isPidAlive(state.pid)) {
+        writeJson(path, { ...state, status: 'stopped', stoppedAt: now })
+      }
+      continue
+    }
+
+    // running 큐: 대응 루프가 죽었으면 stopped
+    if (name.endsWith('-queue') && state.status === 'running') {
+      const loopName = name.replace('-queue', '-loop')
+      const loopPath = join(STATE_DIR, `${loopName}.json`)
+      const loopState = readJson(loopPath)
+      const loopAlive = loopState?.status === 'running' && loopState?.pid && isPidAlive(loopState.pid)
+      if (!loopAlive) {
+        writeJson(path, { ...state, status: 'stopped' })
+      }
+    }
+  }
+} catch {}
+
+process.exit(0)

package/package.json

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

package/src/cleanup.js

@@ -6,6 +6,8 @@
 import { readdirSync, chmodSync, existsSync, unlinkSync, readFileSync, writeFileSync, mkdirSync } from 'fs'
 import { join } from 'path'
 import { readState, writeState } from './state.js'
+import { gcQueue, expireStaleItems } from './queue-utils.js'
+import { cancelStalePipeline, blockDownstreamOfFailed } from './pipeline.js'
 
 const STATE_DIR = '.bylane/state'
 const STALE_MS = 30 * 60 * 1000   // 30분 이상 in_progress → 초기화
@@ -73,6 +75,18 @@ export function runCleanup() {
     return result
   }
 
+  // 0. 파이프라인 cascade cancel — stale 파이프라인 감지 시 하위 에이전트 일괄 취소
+  const stalePipeline = cancelStalePipeline()
+  if (stalePipeline.pipelineCancelled) {
+    result.reset.push(`pipeline: stale → cancelled (${stalePipeline.cancelled.length}개 에이전트 취소: ${stalePipeline.cancelled.join(', ')})`)
+  }
+
+  // 0-1. 파이프라인 내 실패 에이전트 하류 → blocked
+  const downstream = blockDownstreamOfFailed()
+  if (downstream.blocked.length > 0) {
+    result.reset.push(`pipeline: upstream 실패 → ${downstream.blocked.length}개 에이전트 blocked (${downstream.blocked.join(', ')})`)
+  }
+
   // 1. 파일 권한 수정
   result.fixed.push(...fixPermissions())
 
@@ -82,8 +96,8 @@ export function runCleanup() {
   for (const file of files) {
     const name = file.replace('.json', '')
 
-    // 특수 파일 건너뜀
-    if (name === 'cancel') continue
+    // 특수 파일 건너뜀 (pipeline은 pipeline.js에서 별도 처리)
+    if (name === 'cancel' || name === 'pipeline') continue
 
     // subagents 별도 처리
     if (name === 'subagents') {
@@ -115,17 +129,53 @@ export function runCleanup() {
       }
     }
 
-    // 큐 파일: responding/reviewing 상태가 남아있으면 pending으로 복구
+    // 큐 파일 종합 정리
     if ((name === 'review-queue' || name === 'respond-queue') && Array.isArray(state.queue)) {
-      const fixed = state.queue.map(item =>
+      let queue = state.queue
+      let changed = false
+
+      // 1) responding/reviewing 상태 → pending 복구
+      const recovered = queue.map(item =>
         item.status === 'reviewing' || item.status === 'responding'
           ? { ...item, status: 'pending', recoveredAt: new Date().toISOString() }
           : item
       )
-      const changedCount = fixed.filter((item, i) => item.status !== state.queue[i].status).length
-      if (changedCount > 0) {
-        writeState(name, { ...state, queue: fixed }, STATE_DIR)
-        result.reset.push(`${name}: ${changedCount}개 진행중 항목 → pending 복구`)
+      const recoveredCount = recovered.filter((item, i) => item.status !== queue[i].status).length
+      if (recoveredCount > 0) {
+        queue = recovered
+        changed = true
+        result.reset.push(`${name}: ${recoveredCount}개 진행중 항목 → pending 복구`)
+      }
+
+      // 2) stale pending → expired (TTL 초과)
+      const expired = expireStaleItems(queue)
+      if (expired.expiredCount > 0) {
+        queue = expired.queue
+        changed = true
+        result.reset.push(`${name}: ${expired.expiredCount}개 pending 항목 → expired (TTL 초과)`)
+      }
+
+      // 3) resolved/expired 항목 GC (1시간 경과)
+      const gc = gcQueue(queue)
+      if (gc.removedCount > 0) {
+        queue = gc.queue
+        changed = true
+        result.cleared.push(`${name}: ${gc.removedCount}개 완료/만료 항목 GC 제거`)
+      }
+
+      // 4) 루프-큐 상태 동기화: 루프가 stopped인데 큐가 running이면 stopped로
+      const loopName = name.replace('-queue', '-loop')
+      const loopState = readState(loopName, STATE_DIR)
+      const loopDead = !loopState || loopState.status !== 'running' ||
+        (loopState.pid && !isPidAlive(loopState.pid))
+      if (state.status === 'running' && loopDead) {
+        changed = true
+        result.reset.push(`${name}: 루프 미실행 → 큐 상태 stopped`)
+      }
+
+      if (changed) {
+        const newStatus = (state.status === 'running' && loopDead) ? 'stopped' : state.status
+        writeState(name, { ...state, status: newStatus, queue }, STATE_DIR)
       }
     }
   }

package/src/cli.js

@@ -49,11 +49,14 @@ function registerHooks() {
   }
 
   const hookScript = join(CLAUDE_DIR, 'hooks', 'bylane-agent-tracker.js')
+  const cleanupHookScript = join(CLAUDE_DIR, 'hooks', 'bylane-session-cleanup.js')
   settings.hooks = settings.hooks ?? {}
 
   // 기존 bylane 훅 제거 후 재등록 (버전 업 시 경로 변경 대응)
   const stripBylane = (arr) =>
-    (arr ?? []).filter(h => !h.hooks?.some(hh => hh.command?.includes('bylane-agent-tracker')))
+    (arr ?? []).filter(h => !h.hooks?.some(hh =>
+      hh.command?.includes('bylane-agent-tracker') || hh.command?.includes('bylane-session-cleanup')
+    ))
 
   settings.hooks.PreToolUse = [
     ...stripBylane(settings.hooks.PreToolUse),
@@ -63,9 +66,14 @@ function registerHooks() {
     ...stripBylane(settings.hooks.PostToolUse),
     { matcher: 'Agent', hooks: [{ type: 'command', command: `node ${hookScript} post` }] }
   ]
+  settings.hooks.Stop = [
+    ...stripBylane(settings.hooks.Stop),
+    { matcher: '', hooks: [{ type: 'command', command: `node ${cleanupHookScript}` }] }
+  ]
 
   writeFileSync(settingsPath, JSON.stringify(settings, null, 2))
-  console.log('  ~ Hook: bylane-agent-tracker 등록 (최신 경로로 갱신)')
+  console.log('  ~ Hook: bylane-agent-tracker 등록 (PreToolUse + PostToolUse)')
+  console.log('  ~ Hook: bylane-session-cleanup 등록 (Stop — 세션 종료 시 상태 정리)')
 }
 
 function preservedConfigs() {
@@ -158,10 +166,13 @@ function uninstall() {
     try {
       const settings = JSON.parse(readFileSync(settingsPath, 'utf8'))
       const stripBylane = (arr) =>
-        (arr ?? []).filter(h => !h.hooks?.some(hh => hh.command?.includes('bylane-agent-tracker')))
+        (arr ?? []).filter(h => !h.hooks?.some(hh =>
+          hh.command?.includes('bylane-agent-tracker') || hh.command?.includes('bylane-session-cleanup')
+        ))
       settings.hooks = settings.hooks ?? {}
       settings.hooks.PreToolUse = stripBylane(settings.hooks.PreToolUse)
       settings.hooks.PostToolUse = stripBylane(settings.hooks.PostToolUse)
+      settings.hooks.Stop = stripBylane(settings.hooks.Stop)
       writeFileSync(settingsPath, JSON.stringify(settings, null, 2))
       console.log('  - Hook: bylane-agent-tracker 제거')
     } catch {}
@@ -267,6 +278,10 @@ if (command === 'install') {
   const sessionName = config.loop?.sessionName ?? 'bylane-loops'
 
   if (subCmd === 'start') {
+    // 시작 전 상태 정리
+    const { runCleanup } = await import('./cleanup.js')
+    runCleanup()
+
     const mode = resolveLoopMode()
 
     if (mode === 'tmux') {
@@ -330,6 +345,10 @@ if (command === 'install') {
       }
     }
 
+    // 종료 후 상태 정리 (큐 상태 동기화 포함)
+    const { runCleanup } = await import('./cleanup.js')
+    runCleanup()
+
     if (!stopped) {
       console.log('  실행 중인 루프가 없습니다.')
     }

package/src/config.js

@@ -8,7 +8,7 @@ export const DEFAULT_CONFIG = {
     linear: { enabled: false, apiKey: '' }
   },
   notifications: {
-    slack: { enabled: false, channel: '' },
+    slack: { enabled: false, webhookUrl: '' },
     telegram: { enabled: false, chatId: '' }
   },
   team: {

package/src/pipeline.js

@@ -0,0 +1,195 @@
+/**
+ * pipeline.js
+ * 에이전트 파이프라인 상태 추적 및 cascade cancel
+ */
+import { readState, writeState } from './state.js'
+
+const STATE_DIR = '.bylane/state'
+
+/** 파이프라인별 에이전트 실행 순서 */
+export const PIPELINES = {
+  A: ['issue-agent', 'code-agent', 'test-agent', 'commit-agent', 'pr-agent', 'review-agent', 'notify-agent'],
+  B: ['code-agent', 'test-agent', 'commit-agent', 'pr-agent', 'review-agent', 'notify-agent'],
+  C_review: ['review-agent'],
+  C_respond: ['respond-agent'],
+  D: []   // 단일 에이전트, 동적 지정
+}
+
+/** 파이프라인 상태 기록 기본 TTL (30분) */
+export const PIPELINE_STALE_MS = 30 * 60 * 1000
+
+/**
+ * 파이프라인 시작 기록
+ * @param {{ type: string, issueNumber?: number, steps: string[] }} opts
+ */
+export function startPipeline({ type, issueNumber, steps }) {
+  const now = new Date().toISOString()
+  writeState('pipeline', {
+    status: 'in_progress',
+    pipelineType: type,
+    issueNumber: issueNumber ?? null,
+    startedAt: now,
+    currentStep: steps[0] ?? null,
+    steps: steps.map(agent => ({ agent, status: 'pending' }))
+  }, STATE_DIR)
+}
+
+/**
+ * 현재 파이프라인 단계 업데이트
+ * @param {string} agentName
+ * @param {'in_progress'|'completed'|'failed'} status
+ */
+export function updatePipelineStep(agentName, status) {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') return
+
+  const steps = (pipeline.steps ?? []).map(step =>
+    step.agent === agentName
+      ? { ...step, status, [`${status}At`]: new Date().toISOString() }
+      : step
+  )
+
+  // 다음 단계 결정
+  const currentIdx = steps.findIndex(s => s.agent === agentName)
+  const nextStep = (status === 'completed' && currentIdx < steps.length - 1)
+    ? steps[currentIdx + 1].agent
+    : null
+
+  // 전체 완료 여부
+  const allDone = steps.every(s => s.status === 'completed')
+  const anyFailed = steps.some(s => s.status === 'failed')
+
+  writeState('pipeline', {
+    ...pipeline,
+    status: allDone ? 'completed' : anyFailed ? 'failed' : 'in_progress',
+    currentStep: nextStep ?? pipeline.currentStep,
+    steps
+  }, STATE_DIR)
+}
+
+/**
+ * 파이프라인 완료 처리
+ */
+export function completePipeline() {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline) return
+  writeState('pipeline', {
+    ...pipeline,
+    status: 'completed',
+    completedAt: new Date().toISOString()
+  }, STATE_DIR)
+}
+
+/**
+ * 활성 파이프라인 조회
+ * @returns {Object|null}
+ */
+export function getActivePipeline() {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') return null
+  return pipeline
+}
+
+/**
+ * stale 파이프라인 감지 및 cascade cancel.
+ * 파이프라인이 staleMs 동안 업데이트 없으면 하위 에이전트를 모두 cancelled 처리한다.
+ *
+ * @param {number} [staleMs=PIPELINE_STALE_MS]
+ * @returns {{ cancelled: string[], pipelineCancelled: boolean }}
+ */
+export function cancelStalePipeline(staleMs = PIPELINE_STALE_MS) {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') {
+    return { cancelled: [], pipelineCancelled: false }
+  }
+
+  const lastUpdate = pipeline.updatedAt || pipeline.startedAt
+  const age = Date.now() - new Date(lastUpdate).getTime()
+  if (age < staleMs) {
+    return { cancelled: [], pipelineCancelled: false }
+  }
+
+  const now = new Date().toISOString()
+  const cancelled = []
+
+  // 파이프라인 소속 에이전트 중 in_progress/pending → cancelled
+  for (const step of pipeline.steps ?? []) {
+    if (step.status === 'in_progress' || step.status === 'pending') {
+      const agentState = readState(step.agent, STATE_DIR)
+      if (agentState && (agentState.status === 'in_progress' || agentState.status === 'idle')) {
+        writeState(step.agent, {
+          ...agentState,
+          status: 'cancelled',
+          cancelledAt: now,
+          reason: 'pipeline_stale'
+        }, STATE_DIR)
+        cancelled.push(step.agent)
+      }
+    }
+  }
+
+  // 파이프라인 자체도 cancelled
+  writeState('pipeline', {
+    ...pipeline,
+    status: 'cancelled',
+    cancelledAt: now,
+    reason: `${Math.floor(age / 60000)}분간 업데이트 없음`,
+    steps: (pipeline.steps ?? []).map(step =>
+      step.status === 'in_progress' || step.status === 'pending'
+        ? { ...step, status: 'cancelled', cancelledAt: now }
+        : step
+    )
+  }, STATE_DIR)
+
+  return { cancelled, pipelineCancelled: true }
+}
+
+/**
+ * 파이프라인에서 실패한 에이전트의 하류 에이전트를 blocked 처리한다.
+ * (cleanup에서 호출)
+ *
+ * @returns {{ blocked: string[] }}
+ */
+export function blockDownstreamOfFailed() {
+  const pipeline = readState('pipeline', STATE_DIR)
+  if (!pipeline || pipeline.status !== 'in_progress') {
+    return { blocked: [] }
+  }
+
+  const steps = pipeline.steps ?? []
+  const blocked = []
+  let foundFailed = false
+
+  for (const step of steps) {
+    if (step.status === 'failed') {
+      foundFailed = true
+      continue
+    }
+    // 실패 에이전트 이후의 pending 단계 → blocked
+    if (foundFailed && step.status === 'pending') {
+      const agentState = readState(step.agent, STATE_DIR)
+      if (!agentState || agentState.status === 'idle' || !agentState.status) {
+        writeState(step.agent, {
+          agent: step.agent,
+          status: 'blocked',
+          blockedAt: new Date().toISOString(),
+          reason: 'upstream_failed'
+        }, STATE_DIR)
+      }
+      blocked.push(step.agent)
+    }
+  }
+
+  if (blocked.length > 0) {
+    writeState('pipeline', {
+      ...pipeline,
+      steps: steps.map(step =>
+        blocked.includes(step.agent)
+          ? { ...step, status: 'blocked', blockedAt: new Date().toISOString() }
+          : step
+      )
+    }, STATE_DIR)
+  }
+
+  return { blocked }
+}

package/src/queue-utils.js

@@ -0,0 +1,119 @@
+/**
+ * queue-utils.js
+ * 큐 상태 관리 공용 유틸 — reconcile, expire, GC
+ */
+
+/** 큐 항목 TTL: 24시간 이상 pending이면 expired */
+export const QUEUE_TTL_MS = 24 * 60 * 60 * 1000
+
+/** GC 대상: resolved/expired 후 1시간 경과 시 제거 */
+export const GC_AGE_MS = 60 * 60 * 1000
+
+/**
+ * 현재 GitHub에서 가져온 PR 번호 목록과 큐를 대조하여
+ * 더 이상 액션이 필요 없는 항목을 resolved로 전환한다.
+ *
+ * @param {Array} queue  기존 큐 배열
+ * @param {Set<number>} activePrNumbers  현재 액션 필요한 PR 번호 Set
+ * @returns {{ queue: Array, resolvedCount: number }}
+ */
+export function reconcileQueue(queue, activePrNumbers) {
+  let resolvedCount = 0
+  const now = new Date().toISOString()
+
+  const result = queue.map(item => {
+    // pending인데 현재 GitHub에서 더 이상 해당 PR이 액션 필요 목록에 없음
+    if (item.status === 'pending' && !activePrNumbers.has(item.number)) {
+      resolvedCount++
+      return { ...item, status: 'resolved', resolvedAt: now, reason: 'no_longer_actionable' }
+    }
+    return item
+  })
+
+  return { queue: result, resolvedCount }
+}
+
+/**
+ * TTL 초과된 pending 항목을 expired로 전환한다.
+ *
+ * @param {Array} queue  큐 배열
+ * @param {number} [ttlMs=QUEUE_TTL_MS]  TTL (밀리초)
+ * @returns {{ queue: Array, expiredCount: number }}
+ */
+export function expireStaleItems(queue, ttlMs = QUEUE_TTL_MS) {
+  const now = Date.now()
+  let expiredCount = 0
+
+  const result = queue.map(item => {
+    if (item.status === 'pending' && item.detectedAt) {
+      const age = now - new Date(item.detectedAt).getTime()
+      if (age > ttlMs) {
+        expiredCount++
+        return { ...item, status: 'expired', expiredAt: new Date().toISOString() }
+      }
+    }
+    return item
+  })
+
+  return { queue: result, expiredCount }
+}
+
+/**
+ * resolved/expired 항목 중 일정 시간이 지난 것을 큐에서 제거한다.
+ *
+ * @param {Array} queue  큐 배열
+ * @param {number} [gcAgeMs=GC_AGE_MS]  GC 기준 시간 (밀리초)
+ * @returns {{ queue: Array, removedCount: number }}
+ */
+export function gcQueue(queue, gcAgeMs = GC_AGE_MS) {
+  const now = Date.now()
+  const before = queue.length
+
+  const result = queue.filter(item => {
+    if (item.status === 'resolved' || item.status === 'expired') {
+      const ts = item.resolvedAt || item.expiredAt
+      if (ts && now - new Date(ts).getTime() > gcAgeMs) {
+        return false
+      }
+    }
+    return true
+  })
+
+  return { queue: result, removedCount: before - result.length }
+}
+
+/**
+ * reconcile + expire + GC 를 한 번에 실행한다.
+ *
+ * @param {Array} queue  기존 큐 배열
+ * @param {Set<number>|null} activePrNumbers  현재 액션 필요한 PR 번호 Set (null이면 reconcile 생략)
+ * @param {{ ttlMs?: number, gcAgeMs?: number }} [opts]
+ * @returns {{ queue: Array, resolvedCount: number, expiredCount: number, removedCount: number }}
+ */
+export function maintainQueue(queue, activePrNumbers, opts = {}) {
+  const { ttlMs = QUEUE_TTL_MS, gcAgeMs = GC_AGE_MS } = opts
+
+  let resolvedCount = 0
+  let expiredCount = 0
+  let removedCount = 0
+  let current = queue
+
+  // 1. Reconcile (activePrNumbers가 있을 때만)
+  if (activePrNumbers) {
+    const r = reconcileQueue(current, activePrNumbers)
+    current = r.queue
+    resolvedCount = r.resolvedCount
+  }
+
+  // 2. Expire stale pending items
+  const e = expireStaleItems(current, ttlMs)
+  current = e.queue
+  expiredCount = e.expiredCount
+
+  // 3. GC resolved/expired items
+  const g = gcQueue(current, gcAgeMs)
+  current = g.queue
+  removedCount = g.removedCount
+
+  return { queue: current, resolvedCount, expiredCount, removedCount }
+}

package/src/respond-loop.js

@@ -9,6 +9,7 @@ import { mkdirSync } from 'fs'
 import { writeState, readState, appendLog } from './state.js'
 import { loadConfig } from './config.js'
 import { killExistingLoop, createAbsoluteTimer } from './loop-utils.js'
+import { maintainQueue } from './queue-utils.js'
 
 const config = loadConfig()
 const INTERVAL_MS = config.loop?.intervalMs ?? 300000
@@ -162,7 +163,21 @@ async function poll() {
     }
   }
 
-  saveQueue(Object.values(queueMap))
+  // 큐 유지보수: reconcile + expire + GC
+  const activePrNumbers = new Set(prs.map(pr => pr.number))
+  const maintained = maintainQueue(Object.values(queueMap), activePrNumbers)
+
+  if (maintained.resolvedCount > 0) {
+    appendLog('respond-loop', `${maintained.resolvedCount}개 항목 resolved (더 이상 액션 불필요)`, STATE_DIR)
+  }
+  if (maintained.expiredCount > 0) {
+    appendLog('respond-loop', `${maintained.expiredCount}개 항목 expired (TTL 초과)`, STATE_DIR)
+  }
+  if (maintained.removedCount > 0) {
+    appendLog('respond-loop', `${maintained.removedCount}개 완료 항목 GC 제거`, STATE_DIR)
+  }
+
+  saveQueue(maintained.queue)
 
   if (newCount > 0) {
     appendLog('respond-loop', `${newCount}개 PR이 큐에 추가됨`, STATE_DIR)
@@ -180,7 +195,14 @@ const { stop } = createAbsoluteTimer(poll, INTERVAL_MS)
 // 종료 처리
 function shutdown() {
   stop()
-  writeState('respond-loop', { status: 'stopped' }, STATE_DIR)
+  writeState('respond-loop', { status: 'stopped', stoppedAt: new Date().toISOString() }, STATE_DIR)
+
+  // 큐 상태도 stopped로 전환
+  const queueState = readState('respond-queue', STATE_DIR)
+  if (queueState) {
+    writeState('respond-queue', { ...queueState, status: 'stopped' }, STATE_DIR)
+  }
+
   process.exit(0)
 }
 process.on('SIGINT', shutdown)

package/src/review-loop.js

@@ -8,6 +8,7 @@ import { mkdirSync } from 'fs'
 import { writeState, readState, appendLog } from './state.js'
 import { loadConfig } from './config.js'
 import { killExistingLoop, createAbsoluteTimer } from './loop-utils.js'
+import { maintainQueue } from './queue-utils.js'
 
 const config = loadConfig()
 const INTERVAL_MS = config.loop?.intervalMs ?? 300000
@@ -109,7 +110,21 @@ async function poll() {
     }
   }
 
-  saveQueue(Object.values(queueMap))
+  // 큐 유지보수: reconcile + expire + GC
+  const activePrNumbers = new Set(prs.map(pr => pr.number))
+  const maintained = maintainQueue(Object.values(queueMap), activePrNumbers)
+
+  if (maintained.resolvedCount > 0) {
+    appendLog('review-loop', `${maintained.resolvedCount}개 항목 resolved (더 이상 리뷰 요청 없음)`, STATE_DIR)
+  }
+  if (maintained.expiredCount > 0) {
+    appendLog('review-loop', `${maintained.expiredCount}개 항목 expired (TTL 초과)`, STATE_DIR)
+  }
+  if (maintained.removedCount > 0) {
+    appendLog('review-loop', `${maintained.removedCount}개 완료 항목 GC 제거`, STATE_DIR)
+  }
+
+  saveQueue(maintained.queue)
 
   if (newCount > 0) {
     appendLog('review-loop', `${newCount}개 PR이 큐에 추가됨`, STATE_DIR)
@@ -127,7 +142,14 @@ const { stop } = createAbsoluteTimer(poll, INTERVAL_MS)
 // 종료 처리
 function shutdown() {
   stop()
-  writeState('review-loop', { status: 'stopped' }, STATE_DIR)
+  writeState('review-loop', { status: 'stopped', stoppedAt: new Date().toISOString() }, STATE_DIR)
+
+  // 큐 상태도 stopped로 전환
+  const queueState = readState('review-queue', STATE_DIR)
+  if (queueState) {
+    writeState('review-queue', { ...queueState, status: 'stopped' }, STATE_DIR)
+  }
+
   process.exit(0)
 }
 process.on('SIGINT', shutdown)

package/tests/pipeline.test.js

@@ -0,0 +1,171 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdirSync, rmSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import { writeState, readState } from '../src/state.js'
+import {
+  startPipeline, updatePipelineStep, completePipeline,
+  getActivePipeline, cancelStalePipeline, blockDownstreamOfFailed,
+  PIPELINES
+} from '../src/pipeline.js'
+
+const STATE_DIR = '.bylane/state'
+
+beforeEach(() => mkdirSync(STATE_DIR, { recursive: true }))
+afterEach(() => rmSync('.bylane', { recursive: true, force: true }))
+
+describe('startPipeline', () => {
+  it('파이프라인 상태를 기록한다', () => {
+    startPipeline({ type: 'A', issueNumber: 42, steps: PIPELINES.A })
+    const state = readState('pipeline', STATE_DIR)
+
+    expect(state.status).toBe('in_progress')
+    expect(state.pipelineType).toBe('A')
+    expect(state.issueNumber).toBe(42)
+    expect(state.currentStep).toBe('issue-agent')
+    expect(state.steps).toHaveLength(7)
+    expect(state.steps[0]).toMatchObject({ agent: 'issue-agent', status: 'pending' })
+  })
+})
+
+describe('updatePipelineStep', () => {
+  it('에이전트 상태를 업데이트하고 다음 단계로 이동한다', () => {
+    startPipeline({ type: 'B', steps: ['code-agent', 'test-agent', 'commit-agent'] })
+
+    updatePipelineStep('code-agent', 'in_progress')
+    let state = readState('pipeline', STATE_DIR)
+    expect(state.steps[0].status).toBe('in_progress')
+
+    updatePipelineStep('code-agent', 'completed')
+    state = readState('pipeline', STATE_DIR)
+    expect(state.steps[0].status).toBe('completed')
+    expect(state.currentStep).toBe('test-agent')
+    expect(state.status).toBe('in_progress')
+  })
+
+  it('마지막 에이전트 완료 시 파이프라인도 completed', () => {
+    startPipeline({ type: 'D', steps: ['review-agent'] })
+    updatePipelineStep('review-agent', 'completed')
+    const state = readState('pipeline', STATE_DIR)
+    expect(state.status).toBe('completed')
+  })
+
+  it('에이전트 실패 시 파이프라인 상태가 failed', () => {
+    startPipeline({ type: 'B', steps: ['code-agent', 'test-agent'] })
+    updatePipelineStep('code-agent', 'failed')
+    const state = readState('pipeline', STATE_DIR)
+    expect(state.status).toBe('failed')
+  })
+
+  it('파이프라인이 없으면 무시한다', () => {
+    // 에러 없이 실행되어야 함
+    updatePipelineStep('code-agent', 'completed')
+  })
+})
+
+describe('completePipeline', () => {
+  it('파이프라인을 완료 처리한다', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    completePipeline()
+    const state = readState('pipeline', STATE_DIR)
+    expect(state.status).toBe('completed')
+    expect(state.completedAt).toBeTruthy()
+  })
+})
+
+describe('getActivePipeline', () => {
+  it('in_progress 파이프라인을 반환한다', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    expect(getActivePipeline()).toBeTruthy()
+  })
+
+  it('completed 파이프라인은 null', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    completePipeline()
+    expect(getActivePipeline()).toBeNull()
+  })
+
+  it('파이프라인 없으면 null', () => {
+    expect(getActivePipeline()).toBeNull()
+  })
+})
+
+describe('cancelStalePipeline', () => {
+  it('stale 파이프라인의 에이전트를 cascade cancel한다', () => {
+    // 30분 전에 시작된 파이프라인 시뮬레이션 — writeState는 updatedAt을 현재로 덮어쓰므로 직접 작성
+    const oldTime = new Date(Date.now() - 31 * 60 * 1000).toISOString()
+    writeFileSync(join(STATE_DIR, 'pipeline.json'), JSON.stringify({
+      agent: 'pipeline',
+      status: 'in_progress',
+      pipelineType: 'B',
+      startedAt: oldTime,
+      updatedAt: oldTime,
+      currentStep: 'code-agent',
+      steps: [
+        { agent: 'code-agent', status: 'in_progress' },
+        { agent: 'test-agent', status: 'pending' }
+      ],
+      log: []
+    }, null, 2))
+    // 에이전트 상태도 생성
+    writeState('code-agent', { status: 'in_progress', startedAt: oldTime }, STATE_DIR)
+
+    const result = cancelStalePipeline()
+
+    expect(result.pipelineCancelled).toBe(true)
+    expect(result.cancelled).toContain('code-agent')
+
+    const codeState = readState('code-agent', STATE_DIR)
+    expect(codeState.status).toBe('cancelled')
+    expect(codeState.reason).toBe('pipeline_stale')
+
+    const pipelineState = readState('pipeline', STATE_DIR)
+    expect(pipelineState.status).toBe('cancelled')
+  })
+
+  it('fresh 파이프라인은 건드리지 않는다', () => {
+    startPipeline({ type: 'A', steps: ['issue-agent'] })
+    const result = cancelStalePipeline()
+    expect(result.pipelineCancelled).toBe(false)
+    expect(readState('pipeline', STATE_DIR).status).toBe('in_progress')
+  })
+
+  it('파이프라인이 없으면 아무것도 안 한다', () => {
+    const result = cancelStalePipeline()
+    expect(result.cancelled).toEqual([])
+  })
+})
+
+describe('blockDownstreamOfFailed', () => {
+  it('실패 에이전트 하류를 blocked 처리한다', () => {
+    writeState('pipeline', {
+      status: 'in_progress',
+      steps: [
+        { agent: 'code-agent', status: 'completed' },
+        { agent: 'test-agent', status: 'failed' },
+        { agent: 'commit-agent', status: 'pending' },
+        { agent: 'pr-agent', status: 'pending' }
+      ]
+    }, STATE_DIR)
+
+    const result = blockDownstreamOfFailed()
+
+    expect(result.blocked).toEqual(['commit-agent', 'pr-agent'])
+
+    const commitState = readState('commit-agent', STATE_DIR)
+    expect(commitState.status).toBe('blocked')
+    expect(commitState.reason).toBe('upstream_failed')
+  })
+
+  it('실패 없으면 아무것도 안 한다', () => {
+    writeState('pipeline', {
+      status: 'in_progress',
+      steps: [
+        { agent: 'code-agent', status: 'completed' },
+        { agent: 'test-agent', status: 'in_progress' }
+      ]
+    }, STATE_DIR)
+
+    const result = blockDownstreamOfFailed()
+    expect(result.blocked).toEqual([])
+  })
+})

package/tests/queue-utils.test.js

@@ -0,0 +1,141 @@
+import { describe, it, expect } from 'vitest'
+import { reconcileQueue, expireStaleItems, gcQueue, maintainQueue, QUEUE_TTL_MS, GC_AGE_MS } from '../src/queue-utils.js'
+
+describe('reconcileQueue', () => {
+  it('활성 PR 목록에 없는 pending 항목을 resolved로 전환한다', () => {
+    const queue = [
+      { number: 1, status: 'pending', detectedAt: new Date().toISOString() },
+      { number: 2, status: 'pending', detectedAt: new Date().toISOString() },
+      { number: 3, status: 'responded', detectedAt: new Date().toISOString() }
+    ]
+    const activePrs = new Set([2])
+    const { queue: result, resolvedCount } = reconcileQueue(queue, activePrs)
+
+    expect(resolvedCount).toBe(1)
+    expect(result[0].status).toBe('resolved')
+    expect(result[0].reason).toBe('no_longer_actionable')
+    expect(result[0].resolvedAt).toBeTruthy()
+    expect(result[1].status).toBe('pending')
+    // responded 항목은 건드리지 않음
+    expect(result[2].status).toBe('responded')
+  })
+
+  it('모든 항목이 활성이면 변경 없음', () => {
+    const queue = [
+      { number: 1, status: 'pending' },
+      { number: 2, status: 'pending' }
+    ]
+    const { queue: result, resolvedCount } = reconcileQueue(queue, new Set([1, 2]))
+    expect(resolvedCount).toBe(0)
+    expect(result[0].status).toBe('pending')
+    expect(result[1].status).toBe('pending')
+  })
+
+  it('빈 큐에서 동작한다', () => {
+    const { queue, resolvedCount } = reconcileQueue([], new Set([1]))
+    expect(queue).toEqual([])
+    expect(resolvedCount).toBe(0)
+  })
+})
+
+describe('expireStaleItems', () => {
+  it('TTL 초과 pending 항목을 expired로 전환한다', () => {
+    const old = new Date(Date.now() - QUEUE_TTL_MS - 1000).toISOString()
+    const fresh = new Date().toISOString()
+    const queue = [
+      { number: 1, status: 'pending', detectedAt: old },
+      { number: 2, status: 'pending', detectedAt: fresh },
+      { number: 3, status: 'resolved', detectedAt: old }
+    ]
+    const { queue: result, expiredCount } = expireStaleItems(queue)
+
+    expect(expiredCount).toBe(1)
+    expect(result[0].status).toBe('expired')
+    expect(result[0].expiredAt).toBeTruthy()
+    expect(result[1].status).toBe('pending')
+    // resolved는 건드리지 않음
+    expect(result[2].status).toBe('resolved')
+  })
+
+  it('커스텀 TTL을 적용할 수 있다', () => {
+    const twoHoursAgo = new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString()
+    const queue = [{ number: 1, status: 'pending', detectedAt: twoHoursAgo }]
+    const { expiredCount } = expireStaleItems(queue, 1 * 60 * 60 * 1000)
+    expect(expiredCount).toBe(1)
+  })
+
+  it('detectedAt 없는 항목은 건너뛴다', () => {
+    const queue = [{ number: 1, status: 'pending' }]
+    const { expiredCount } = expireStaleItems(queue)
+    expect(expiredCount).toBe(0)
+  })
+})
+
+describe('gcQueue', () => {
+  it('GC 기준 초과한 resolved/expired 항목을 제거한다', () => {
+    const oldTs = new Date(Date.now() - GC_AGE_MS - 1000).toISOString()
+    const freshTs = new Date().toISOString()
+    const queue = [
+      { number: 1, status: 'resolved', resolvedAt: oldTs },
+      { number: 2, status: 'expired', expiredAt: oldTs },
+      { number: 3, status: 'resolved', resolvedAt: freshTs },
+      { number: 4, status: 'pending', detectedAt: oldTs }
+    ]
+    const { queue: result, removedCount } = gcQueue(queue)
+
+    expect(removedCount).toBe(2)
+    expect(result).toHaveLength(2)
+    expect(result[0].number).toBe(3)
+    expect(result[1].number).toBe(4)
+  })
+
+  it('GC 기준 미달이면 유지한다', () => {
+    const freshTs = new Date().toISOString()
+    const queue = [
+      { number: 1, status: 'resolved', resolvedAt: freshTs },
+      { number: 2, status: 'expired', expiredAt: freshTs }
+    ]
+    const { removedCount } = gcQueue(queue)
+    expect(removedCount).toBe(0)
+  })
+})
+
+describe('maintainQueue', () => {
+  it('reconcile + expire + GC를 한 번에 실행한다', () => {
+    const oldTs = new Date(Date.now() - GC_AGE_MS - 1000).toISOString()
+    const staleTs = new Date(Date.now() - QUEUE_TTL_MS - 1000).toISOString()
+    const freshTs = new Date().toISOString()
+
+    const queue = [
+      { number: 1, status: 'pending', detectedAt: freshTs },        // active → stays
+      { number: 2, status: 'pending', detectedAt: freshTs },        // not active → resolved
+      { number: 3, status: 'pending', detectedAt: staleTs },        // TTL 초과 → expired
+      { number: 4, status: 'resolved', resolvedAt: oldTs },         // GC 대상
+      { number: 5, status: 'responded', detectedAt: freshTs }       // 유지
+    ]
+    const activePrs = new Set([1])
+
+    const result = maintainQueue(queue, activePrs)
+
+    // #2, #3 모두 active에 없으므로 reconcile에서 resolved (expire보다 먼저 실행)
+    expect(result.resolvedCount).toBe(2)  // #2, #3
+    expect(result.expiredCount).toBe(0)   // reconcile이 먼저 resolved 처리
+    expect(result.removedCount).toBe(1)   // #4
+
+    // 남은 항목 확인
+    expect(result.queue).toHaveLength(4)
+    expect(result.queue.find(q => q.number === 1).status).toBe('pending')
+    expect(result.queue.find(q => q.number === 2).status).toBe('resolved')
+    expect(result.queue.find(q => q.number === 3).status).toBe('resolved')
+    expect(result.queue.find(q => q.number === 5).status).toBe('responded')
+  })
+
+  it('activePrNumbers가 null이면 reconcile을 생략한다', () => {
+    const queue = [
+      { number: 1, status: 'pending', detectedAt: new Date().toISOString() }
+    ]
+    const result = maintainQueue(queue, null)
+    expect(result.resolvedCount).toBe(0)
+    expect(result.queue[0].status).toBe('pending')
+  })
+})

package/.bylane/bylane.json

@@ -1,37 +0,0 @@
-{
-  "trackers": {
-    "primary": "github",
-    "linear": {
-      "enabled": false
-    }
-  },
-  "notifications": {
-    "telegram": {
-      "enabled": true,
-      "chatIdEnv": "TELEGRAM_CHAT_ID",
-      "botTokenEnv": "TELEGRAM_BOT_TOKEN"
-    },
-    "slack": {
-      "enabled": false
-    }
-  },
-  "team": {
-    "enabled": true,
-    "members": [],
-    "reviewAssignment": "round-robin"
-  },
-  "permissions": {
-    "scope": "write"
-  },
-  "maxRetries": 3,
-  "loopTimeoutMinutes": 30,
-  "figma": {
-    "enabled": false
-  },
-  "branch": {
-    "pattern": "{tracker}-{issue-number}",
-    "defaults": {
-      "tracker": "issues"
-    }
-  }
-}