@angar2/taskery 0.1.0 → 0.1.2

package/bin/lib.js

@@ -1,6 +1,6 @@
 /**
  * bin/lib.js
- * 공통 유틸 — taskery init/create/update 스크립트가 공유.
+ * 공통 유틸 — taskery init/create/update/prune/status 스크립트가 공유.
  *
  * 핵심:
  *   - findTemplateDir(): 패키지 설치 위치에서 template/ 디렉토리 찾기
@@ -8,14 +8,37 @@
  *   - sha256(path): 파일 해시
  *   - mkdirp(path): mkdir -p
  *   - copyFile(src, dst): 파일 카피 + 디렉토리 자동 생성
- *   - writeManifest(manifest, dst): manifest JSON 박음
+ *   - writeManifest(manifest, dst): manifest JSON 기록
  *   - readManifest(path): 기존 manifest Read (없으면 null)
  *   - LOCAL_SUFFIX: '.local.md' suffix 검사 (npx 미터치 룰)
+ *
+ * 멀티세션 (0.1.2+):
+ *   - generateProjectId(): 새 projectId 생성 (8자 hex)
+ *   - getMainWorktreePath(cwd): cwd가 속한 git 트리의 *메인 워크트리* 절대 경로
+ *   - getProjectId(mainWtPath): manifest에서 projectId 추출
+ *   - getWorktreesRoot(projectId): ~/.taskery/worktrees/<projectId>
+ *   - getWorktreePath(projectId, { taskNum, src, slug }): 특정 task 워크트리 경로
+ *   - getMergeLockPath(projectId): ~/.taskery/<projectId>.merge.lock
+ *   - withMergeLock(projectId, fn, opts): proper-lockfile로 머지 락 + fn 실행 + 자동 release
+ *   - withMetaLock(filePath, fn, opts): 메타 파일 쓰기 락 + fn 실행
+ *   - getActiveTasks(mainWtPath): SSoT 조회 (git branch --no-merged dev --list 'feature/*_TASK-*' ...)
+ *   - getNextTaskNumber(mainWtPath): (진행중 ∪ dev 머지 히스토리) 최대 + 1
+ *   - assertMainWorktreeOnDev(mainWtPath): 메인 워크트리가 dev 체크아웃 상태인지 검증
+ *   - assertDevExists(mainWtPath): dev 브랜치 존재 검증
+ *
+ * 백로그 (0.1.2+):
+ *   - getActiveVersion(mainWtPath): .project/AGENT-GUIDE.md에서 활성 plan 버전(vX.X) 추출
+ *   - getBacklogPath(mainWtPath, activeVersion?): .project/tasks/<vX.X>/BACKLOG.md 절대 경로
+ *   - parseBacklogItem(mainWtPath, blId): BL-NNN 항목 메타 파싱 ({ status, type, title, slug, summary, target, taskNums })
+ *   - appendBacklogItem(mainWtPath, meta): withMetaLock + BL-NNN 채번 + 항목 append (placeholder 치환 우선)
+ *   - markBacklogChecked(mainWtPath, blId, taskNum): withMetaLock + [ ] → [x] + TASK 마크 (다회 진행 시 콤마 추가)
  */
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const crypto = require('crypto');
+const { execFileSync } = require('child_process');
 
 const LOCAL_SUFFIX = '.local.md';
 const MANIFEST_NAME = '.taskery-manifest.json';
@@ -37,7 +60,7 @@ function sha256(filePath) {
 
 function walkTemplate(templateDir) {
   // template/ 안 모든 파일 상대경로 + 해시 맵 리턴
-  // 결과: { 'CLAUDE.md': 'sha256:...', '.claude/skills/task-init.md': 'sha256:...', ... }
+  // 결과: { 'CLAUDE.md': 'sha256:...', '.claude/skills/task-init/SKILL.md': 'sha256:...', ... }
   const result = {};
   function walk(dir, relBase) {
     const entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -92,6 +115,349 @@ function getPackageVersion() {
   return pkg.version;
 }
 
+// === 멀티세션 (0.1.2+) ===
+
+const TASKERY_HOME = path.join(os.homedir(), '.taskery');
+const DEFAULT_STALE_DAYS = 30;
+const DEFAULT_LOCK_TIMEOUT_MS = 30000;
+
+const BRANCH_PATTERNS = [
+  'feature/*_TASK-*',
+  'bug/*_TASK-*',
+  'improve/*_TASK-*',
+  'refactor/*_TASK-*',
+  'docs/*_TASK-*',
+  'chore/*_TASK-*',
+];
+
+function generateProjectId() {
+  return crypto.randomBytes(4).toString('hex');
+}
+
+function gitCapture(cwd, args, opts = {}) {
+  try {
+    return execFileSync('git', ['-C', cwd, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', opts.captureStderr ? 'pipe' : 'ignore'],
+    }).trimEnd();
+  } catch (e) {
+    if (opts.allowFail) return null;
+    throw e;
+  }
+}
+
+function getMainWorktreePath(cwd = process.cwd()) {
+  // git ≥ 2.31 — `git rev-parse --path-format=absolute --git-common-dir` 는
+  // 메인 워크트리의 .git 경로(또는 .git 디렉토리 자체)를 절대 경로로 돌려준다.
+  // 그 부모가 *메인 워크트리* 절대 경로.
+  const commonDir = gitCapture(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  if (!commonDir) throw new Error(`메인 워크트리 검출 실패 (cwd=${cwd})`);
+  return path.dirname(commonDir);
+}
+
+function getProjectId(mainWtPath) {
+  const m = readManifest(path.join(mainWtPath, MANIFEST_NAME));
+  if (!m || !m.projectId) {
+    throw new Error(
+      `${MANIFEST_NAME}.projectId 누락 — 'npx @angar2/taskery update' 로 마이그레이션 필요.`,
+    );
+  }
+  return m.projectId;
+}
+
+function getWorktreesRoot(projectId) {
+  return path.join(TASKERY_HOME, 'worktrees', projectId);
+}
+
+function getWorktreePath(projectId, { taskNum, src, slug }) {
+  // src = 'BL-NNN' | 'RM-NNN' | 'DR'
+  const nnn = String(taskNum).padStart(3, '0');
+  return path.join(getWorktreesRoot(projectId), `TASK-${nnn}_${src}_${slug}`);
+}
+
+function getMergeLockPath(projectId) {
+  return path.join(TASKERY_HOME, `${projectId}.merge.lock`);
+}
+
+async function withMergeLock(projectId, fn, opts = {}) {
+  const lockfile = require('proper-lockfile');
+  const lockPath = getMergeLockPath(projectId);
+  mkdirp(path.dirname(lockPath));
+  // proper-lockfile은 *기존 파일 위에 락*을 잡는다. sentinel 파일 보장.
+  if (!fs.existsSync(lockPath)) fs.writeFileSync(lockPath, '');
+  const release = await lockfile.lock(lockPath, {
+    stale: opts.stale ?? DEFAULT_LOCK_TIMEOUT_MS,
+    retries: opts.retries ?? {
+      retries: 5,
+      factor: 1,
+      minTimeout: 1000,
+      maxTimeout: 1000,
+    },
+    realpath: false,
+  });
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
+async function withMetaLock(filePath, fn, opts = {}) {
+  const lockfile = require('proper-lockfile');
+  const target = filePath;
+  if (!fs.existsSync(target)) {
+    // 락 대상은 파일이어야 함. 없으면 sentinel 빈 파일 만들어 락 가능 상태로.
+    mkdirp(path.dirname(target));
+    fs.writeFileSync(target, '');
+  }
+  const release = await lockfile.lock(target, {
+    stale: opts.stale ?? DEFAULT_LOCK_TIMEOUT_MS,
+    retries: opts.retries ?? {
+      retries: 5,
+      factor: 1,
+      minTimeout: 1000,
+      maxTimeout: 1000,
+    },
+    realpath: false,
+  });
+  try {
+    return await fn();
+  } finally {
+    await release();
+  }
+}
+
+function assertDevExists(mainWtPath) {
+  const ok = gitCapture(mainWtPath, ['rev-parse', '--verify', 'dev'], { allowFail: true });
+  if (ok === null) {
+    throw new Error('dev 브랜치 부재. 사용자 결정 필요 (생성?).');
+  }
+}
+
+function assertMainWorktreeOnDev(mainWtPath) {
+  const current = gitCapture(mainWtPath, ['rev-parse', '--abbrev-ref', 'HEAD']);
+  if (current !== 'dev') {
+    throw new Error(`메인 워크트리가 dev 아님 (현재: ${current}). taskery 정책 위배.`);
+  }
+}
+
+function parseBranchName(branch) {
+  // 형식: {type}/{dev}_TASK-NNN_{src}_{slug}
+  // 예: feature/claude_TASK-007_BL-003_login-feature
+  //     bug/angar2_TASK-012_DR_mobile-form-refresh
+  const m = branch.match(
+    /^(feature|bug|improve|refactor|docs|chore)\/([^_]+)_TASK-(\d+)_([A-Z]{2}(?:-\d+)?|DR)_(.+)$/,
+  );
+  if (!m) return null;
+  return {
+    branch,
+    type: m[1],
+    dev: m[2],
+    taskNum: parseInt(m[3], 10),
+    src: m[4],
+    slug: m[5],
+  };
+}
+
+function getActiveTasks(mainWtPath) {
+  // SSoT — TASK-* 패턴 작업 브랜치 (분기 직후 빈 브랜치 포함). `--no-merged dev` 미사용:
+  // 워크트리 분기 직후 브랜치는 dev와 동일 commit이라 `--no-merged dev`가 *완전 머지 상태*로
+  // 처리 → 빈 결과 → getNextTaskNumber 충돌. 브랜치 존재 자체가 SSoT (정상 흐름은 task-close
+  // 자동 삭제로 자연 정리, 보존 키워드 잔존분도 *진행중*으로 잡힘이 정합).
+  const out = gitCapture(mainWtPath, ['branch', '--list', ...BRANCH_PATTERNS]);
+  if (!out) return [];
+  return out
+    .split('\n')
+    .map((l) => l.replace(/^[*+]?\s*/, '').trim())
+    .filter(Boolean)
+    .map(parseBranchName)
+    .filter(Boolean);
+}
+
+function getNextTaskNumber(mainWtPath) {
+  // 1. 진행중 (SSoT)
+  const activeNums = getActiveTasks(mainWtPath).map((t) => t.taskNum);
+  // 2. dev 머지 히스토리 (GIT_RULE 풍부 메시지)
+  const log = gitCapture(mainWtPath, [
+    'log',
+    'dev',
+    '--grep',
+    'TASK-[0-9]\\+',
+    '--extended-regexp',
+    '--oneline',
+  ]);
+  const merged = log
+    ? Array.from(log.matchAll(/TASK-(\d+)/g)).map((m) => parseInt(m[1], 10))
+    : [];
+  const all = [...activeNums, ...merged];
+  if (all.length === 0) return 1;
+  return Math.max(...all) + 1;
+}
+
+// ─── 백로그 (0.1.2+) ────────────────────────────────────────────────
+
+const BACKLOG_PLACEHOLDER =
+  '(사용자 발화 또는 task-close 직후 메인 감지로 한 행씩 추가. 빈 상태 default.)';
+
+function getActiveVersion(mainWtPath) {
+  // .project/AGENT-GUIDE.md '## 활성 plan 버전' 섹션 다음 비어 있지 않은 첫 줄에서 vX.X 추출
+  const guidePath = path.join(mainWtPath, '.project', 'AGENT-GUIDE.md');
+  if (!fs.existsSync(guidePath)) {
+    throw new Error(`.project/AGENT-GUIDE.md 부재. /project-init 먼저 호출.`);
+  }
+  const content = fs.readFileSync(guidePath, 'utf8');
+  const sec = content.match(/##\s*활성 plan 버전\s*\n+([^\n]+)/);
+  if (!sec) {
+    throw new Error(`.project/AGENT-GUIDE.md '## 활성 plan 버전' 섹션 부재.`);
+  }
+  const m = sec[1].match(/\bv[\d.]+(?:[-\w]*)?/);
+  if (!m) {
+    throw new Error(
+      `'## 활성 plan 버전' 값에서 vX.X 패턴 추출 실패: ${sec[1].trim()} — /plan-init으로 활성 버전 갱신 필요.`,
+    );
+  }
+  return m[0];
+}
+
+function getBacklogPath(mainWtPath, activeVersion) {
+  const v = activeVersion ?? getActiveVersion(mainWtPath);
+  return path.join(mainWtPath, '.project', 'tasks', v, 'BACKLOG.md');
+}
+
+function computeNextBLNumber(content) {
+  const matches = Array.from(content.matchAll(/\bBL-(\d+)\b/g)).map((m) => parseInt(m[1], 10));
+  if (matches.length === 0) return 1;
+  return Math.max(...matches) + 1;
+}
+
+function formatBacklogBlock({ id, type, title, slug, summary, target }) {
+  const blId = `BL-${String(id).padStart(3, '0')}`;
+  return `- [ ] **${blId}** [${type}] ${title} \`${slug}\`\n  - 개요: ${summary}\n  - 대상 영역: ${target}`;
+}
+
+async function appendBacklogItem(mainWtPath, meta) {
+  // meta: { type, title, slug, summary, target }
+  const backlogPath = getBacklogPath(mainWtPath);
+  if (!fs.existsSync(backlogPath)) {
+    throw new Error(
+      `${backlogPath} 부재. /plan-init 먼저 호출해 활성 버전 디렉토리 + 빈 BACKLOG.md 생성 필요.`,
+    );
+  }
+  return await withMetaLock(backlogPath, async () => {
+    const content = fs.readFileSync(backlogPath, 'utf8');
+    const next = computeNextBLNumber(content);
+    const block = formatBacklogBlock({ id: next, ...meta });
+    let updated;
+    if (content.includes(BACKLOG_PLACEHOLDER)) {
+      updated = content.replace(BACKLOG_PLACEHOLDER, block);
+    } else {
+      updated = content.replace(/\s*$/, '') + '\n\n' + block + '\n';
+    }
+    fs.writeFileSync(backlogPath, updated);
+    return next;
+  });
+}
+
+function parseBacklogItem(mainWtPath, blId) {
+  // blId: 'BL-001'. 발견 못하면 null.
+  const backlogPath = getBacklogPath(mainWtPath);
+  if (!fs.existsSync(backlogPath)) return null;
+  const content = fs.readFileSync(backlogPath, 'utf8');
+  const lines = content.split('\n');
+  const headRe = new RegExp(
+    `^- \\[([ x])\\] \\*\\*${blId}\\*\\* \\[(\\w+)\\] (.+?) \`([\\w-]+)\``,
+  );
+  let idx = -1;
+  let head = null;
+  for (let i = 0; i < lines.length; i++) {
+    const m = lines[i].match(headRe);
+    if (m) {
+      idx = i;
+      head = m;
+      break;
+    }
+  }
+  if (idx === -1) return null;
+  let summary = null;
+  let target = null;
+  let taskNums = null;
+  for (let j = idx + 1; j < lines.length; j++) {
+    const l = lines[j];
+    if (l.startsWith('- ') && !l.startsWith('  - ')) break; // 다음 BL 항목
+    if (l.trim() === '') continue; // 블록 안 빈 줄 허용 (안전)
+    if (!l.startsWith('  - ')) break;
+    const ms = l.match(/^  - 개요:\s*(.+)/);
+    if (ms) { summary = ms[1].trim(); continue; }
+    const mt = l.match(/^  - 대상 영역:\s*(.+)/);
+    if (mt) { target = mt[1].trim(); continue; }
+    const mk = l.match(/^  - TASK:\s*(.+)/);
+    if (mk) { taskNums = mk[1].trim(); continue; }
+  }
+  return {
+    blId,
+    status: head[1] === 'x' ? 'checked' : 'pending',
+    type: head[2],
+    title: head[3],
+    slug: head[4],
+    summary,
+    target,
+    taskNums,
+  };
+}
+
+async function markBacklogChecked(mainWtPath, blId, taskNum) {
+  // taskNum: number. [ ] → [x] + TASK 마크 (있으면 콤마 추가, 없으면 신규 줄)
+  const backlogPath = getBacklogPath(mainWtPath);
+  if (!fs.existsSync(backlogPath)) {
+    throw new Error(`${backlogPath} 부재.`);
+  }
+  const taskLabel = `TASK-${String(taskNum).padStart(3, '0')}`;
+  return await withMetaLock(backlogPath, async () => {
+    const content = fs.readFileSync(backlogPath, 'utf8');
+    const lines = content.split('\n');
+    const headRe = new RegExp(`^(- )\\[[ x]\\](\\s+\\*\\*${blId}\\*\\*.+)$`);
+    let idx = -1;
+    for (let i = 0; i < lines.length; i++) {
+      if (headRe.test(lines[i])) {
+        idx = i;
+        break;
+      }
+    }
+    if (idx === -1) {
+      throw new Error(`${blId} 항목 없음.`);
+    }
+    lines[idx] = lines[idx].replace(headRe, '$1[x]$2');
+    // 다음 BL 헤드 또는 파일 끝까지가 같은 블록 — 그 안에서 TASK 줄 검색
+    let blockEnd = lines.length;
+    for (let j = idx + 1; j < lines.length; j++) {
+      if (lines[j].startsWith('- ') && !lines[j].startsWith('  - ')) {
+        blockEnd = j;
+        break;
+      }
+    }
+    let taskLineIdx = -1;
+    for (let j = idx + 1; j < blockEnd; j++) {
+      if (lines[j].match(/^  - TASK:/)) {
+        taskLineIdx = j;
+        break;
+      }
+    }
+    if (taskLineIdx !== -1) {
+      const existing = lines[taskLineIdx].match(/^  - TASK:\s*(.+)/)[1].trim();
+      const existingTasks = existing.split(/[,\s]+/).filter(Boolean);
+      if (!existingTasks.includes(taskLabel)) {
+        lines[taskLineIdx] = `  - TASK: ${existing}, ${taskLabel}`;
+      }
+    } else {
+      // blockEnd 직전 빈 줄 건너뛰고 삽입
+      let insertAt = blockEnd;
+      while (insertAt > idx + 1 && lines[insertAt - 1].trim() === '') insertAt--;
+      lines.splice(insertAt, 0, `  - TASK: ${taskLabel}`);
+    }
+    fs.writeFileSync(backlogPath, lines.join('\n'));
+  });
+}
+
 module.exports = {
   LOCAL_SUFFIX,
   MANIFEST_NAME,
@@ -104,4 +470,32 @@ module.exports = {
   readManifest,
   isLocalOverride,
   getPackageVersion,
+  // 멀티세션 (0.1.2+)
+  TASKERY_HOME,
+  DEFAULT_STALE_DAYS,
+  DEFAULT_LOCK_TIMEOUT_MS,
+  BRANCH_PATTERNS,
+  generateProjectId,
+  gitCapture,
+  getMainWorktreePath,
+  getProjectId,
+  getWorktreesRoot,
+  getWorktreePath,
+  getMergeLockPath,
+  withMergeLock,
+  withMetaLock,
+  assertDevExists,
+  assertMainWorktreeOnDev,
+  parseBranchName,
+  getActiveTasks,
+  getNextTaskNumber,
+  // 백로그 (0.1.2+)
+  BACKLOG_PLACEHOLDER,
+  getActiveVersion,
+  getBacklogPath,
+  computeNextBLNumber,
+  formatBacklogBlock,
+  appendBacklogItem,
+  parseBacklogItem,
+  markBacklogChecked,
 };

package/bin/prune.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * bin/prune.js
+ * `npx @angar2/taskery prune` — stale 워크트리 / 브랜치 대화형 정리.
+ *
+ * 흐름:
+ *   1. git worktree prune (자동, 케이스 A 폴더 없는 등록 정리)
+ *   2. 의심 항목 목록 표시 (케이스 B/C/D + orphan)
+ *   3. 사용자 항목별 보존 / 삭제 선택
+ *   4. 선택된 항목 삭제:
+ *      - 브랜치: git branch -D <name>  ← 사용자 명시 선택이므로 -D 허용 (rebase 잔여 등 -d 거부 가능)
+ *      - 워크트리: git worktree remove --force <path>
+ *   5. 결과 보고
+ *
+ * 본 명령은 *변경 발생 가능* — 사용자 confirm 항목별로 받음.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const {
+  MANIFEST_NAME,
+  readManifest,
+  gitCapture,
+  getMainWorktreePath,
+  getActiveTasks,
+  getWorktreesRoot,
+  DEFAULT_STALE_DAYS,
+} = require('./lib');
+const { execFileSync } = require('child_process');
+
+function ask(rl, q) {
+  return new Promise((resolve) => rl.question(q, (a) => resolve(a.trim().toLowerCase())));
+}
+
+function daysAgo(date) {
+  return Math.floor((Date.now() - date.getTime()) / (1000 * 60 * 60 * 24));
+}
+
+async function main() {
+  const mainWt = getMainWorktreePath();
+  const manifest = readManifest(path.join(mainWt, MANIFEST_NAME));
+  if (!manifest) {
+    console.error(`${MANIFEST_NAME} 없음 — 'init' 먼저.`);
+    process.exit(1);
+  }
+  const projectId = manifest.projectId;
+  const staleDays = manifest.stale_days ?? DEFAULT_STALE_DAYS;
+
+  console.log(`\ntaskery prune\n`);
+  console.log(`메인 워크트리: ${mainWt}`);
+  console.log(`stale_days: ${staleDays}\n`);
+
+  // 1. git worktree prune (자동 — 케이스 A)
+  console.log(`Step 1 — git worktree prune (폴더 없는 워크트리 등록 정리)`);
+  try {
+    execFileSync('git', ['-C', mainWt, 'worktree', 'prune', '-v'], { stdio: 'inherit' });
+  } catch (e) {
+    console.error(`  git worktree prune 실패: ${e.message}`);
+  }
+  console.log();
+
+  // 2. 의심 항목 수집
+  const active = getActiveTasks(mainWt);
+  const worktreesRoot = getWorktreesRoot(projectId);
+
+  // 케이스 B/C/D
+  const suspects = [];
+  for (const t of active) {
+    const wtPath = path.join(
+      worktreesRoot,
+      `TASK-${String(t.taskNum).padStart(3, '0')}_${t.src}_${t.slug}`,
+    );
+    const wtExists = fs.existsSync(wtPath);
+    const lastCommit = gitCapture(mainWt, ['log', '-1', '--format=%ci', t.branch], {
+      allowFail: true,
+    });
+    const lastDate = lastCommit ? new Date(lastCommit) : null;
+    const days = lastDate ? daysAgo(lastDate) : null;
+
+    let kase = null;
+    if (!wtExists) kase = 'A (폴더 없음 — git worktree prune 처리됐을 가능성)';
+    else if (days !== null && days >= staleDays) kase = `C (워크트리 폴더 존재 + ${days}일 비활성)`;
+
+    if (wtExists) {
+      const rebaseApply = path.join(wtPath, '.git', 'rebase-apply');
+      const rebaseMerge = path.join(wtPath, '.git', 'rebase-merge');
+      if (fs.existsSync(rebaseApply) || fs.existsSync(rebaseMerge)) {
+        kase = `D (rebase 잔여 상태)`;
+      }
+    }
+
+    if (kase) {
+      suspects.push({ branch: t.branch, wtPath, wtExists, days, kase });
+    }
+  }
+
+  // orphan 워크트리 (SSoT에 없는 폴더)
+  const orphans = [];
+  if (fs.existsSync(worktreesRoot)) {
+    const folders = fs.readdirSync(worktreesRoot).filter((n) => n.startsWith('TASK-'));
+    const activeFolders = new Set(
+      active.map(
+        (t) => `TASK-${String(t.taskNum).padStart(3, '0')}_${t.src}_${t.slug}`,
+      ),
+    );
+    for (const f of folders) {
+      if (!activeFolders.has(f)) {
+        orphans.push(path.join(worktreesRoot, f));
+      }
+    }
+  }
+
+  if (suspects.length === 0 && orphans.length === 0) {
+    console.log(`✅ 정리할 의심 항목 없음.`);
+    return;
+  }
+
+  console.log(`Step 2 — 의심 항목 (${suspects.length + orphans.length}건)\n`);
+
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  const toDelete = { branches: [], worktrees: [] };
+
+  // suspects 처리
+  for (const s of suspects) {
+    console.log(`[${s.kase}] ${s.branch}`);
+    console.log(`  워크트리: ${s.wtPath}${s.wtExists ? '' : ' (폴더 X)'}`);
+    if (s.days !== null) console.log(`  마지막 커밋: ${s.days}일 전`);
+    const ans = await ask(rl, `  삭제? (y=브랜치+워크트리 / w=워크트리만 / k=보존, 기본 k) `);
+    if (ans === 'y') {
+      toDelete.branches.push(s.branch);
+      if (s.wtExists) toDelete.worktrees.push(s.wtPath);
+    } else if (ans === 'w' && s.wtExists) {
+      toDelete.worktrees.push(s.wtPath);
+    } else {
+      console.log(`  보존`);
+    }
+    console.log();
+  }
+
+  // orphan 처리
+  for (const o of orphans) {
+    console.log(`[orphan] 워크트리 폴더 (SSoT에 없는 브랜치)`);
+    console.log(`  ${o}`);
+    const ans = await ask(rl, `  워크트리 폴더 삭제? (y/N) `);
+    if (ans === 'y') toDelete.worktrees.push(o);
+    else console.log(`  보존`);
+    console.log();
+  }
+
+  rl.close();
+
+  // 3. 실제 삭제
+  if (toDelete.branches.length === 0 && toDelete.worktrees.length === 0) {
+    console.log(`삭제 대상 없음.`);
+    return;
+  }
+
+  console.log(`\nStep 3 — 삭제 실행\n`);
+
+  for (const wt of toDelete.worktrees) {
+    try {
+      execFileSync('git', ['-C', mainWt, 'worktree', 'remove', '--force', wt], {
+        stdio: 'inherit',
+      });
+      console.log(`  worktree removed: ${wt}`);
+    } catch (e) {
+      console.error(`  worktree remove 실패 (${wt}): ${e.message}`);
+    }
+  }
+
+  for (const b of toDelete.branches) {
+    try {
+      // -D 강제 삭제 — 사용자 명시 선택 (prune 대화형) 이므로 허용
+      execFileSync('git', ['-C', mainWt, 'branch', '-D', b], { stdio: 'inherit' });
+      console.log(`  branch deleted: ${b}`);
+    } catch (e) {
+      console.error(`  branch -D 실패 (${b}): ${e.message}`);
+    }
+  }
+
+  console.log(`\n✅ taskery prune 완료 — 워크트리 ${toDelete.worktrees.length}건 / 브랜치 ${toDelete.branches.length}건 삭제.`);
+}
+
+main().catch((e) => {
+  console.error(`taskery prune 실패: ${e.message}`);
+  process.exit(1);
+});