@angar2/taskery 0.8.1 → 1.0.1

package/bin/prune.js

@@ -1,189 +1,59 @@
-#!/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 항목별로 받음.
- */
-
+// prune — 닫힌 태스크에 남은 워크트리·브랜치를 정리한다. 기본은 항목마다 묻고, --yes면 묻지 않는다(§5-3)
 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));
+const L = require('./lib');
+const { cleanup } = require('./finish');
+
+// 닫혔는데 워크트리나 브랜치가 남은 태스크
+function leftovers(main) {
+  return L.listStates(main).filter(
+    (st) => st.closed && !st.noBranch && ((st.worktree && fs.existsSync(st.worktree)) || L.branchExists(main, st.branch)),
+  );
 }
 
-async function main() {
-  const mainWt = getMainWorktreePath();
-  const manifest = readManifest(path.join(mainWt, MANIFEST_NAME));
-  if (!manifest) {
-    console.error(`${MANIFEST_NAME} 없음 — 'init' 먼저.`);
-    process.exit(1);
+function describe(main, st) {
+  const parts = [];
+  if (st.worktree && fs.existsSync(st.worktree)) {
+    const dirty = L.changedFiles(st.worktree);
+    parts.push(`워크트리 ${st.worktree}${dirty.length ? ` — 커밋 안 된 변경 ${dirty.length}개` : ''}`);
   }
-  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}`);
+  if (L.branchExists(main, st.branch)) {
+    parts.push(`브랜치 ${st.branch}${L.isAncestor(main, st.branch, st.parent) ? '' : ' — 부모에 병합되지 않음'}`);
   }
-  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 잔여 상태)`;
-      }
-    }
+  return `${L.taskLabel(st.num)} ${st.title} (${st.closed.finished ? '끝난 태스크' : '포기'}): ${parts.join(' · ')}`;
+}
 
-    if (kase) {
-      suspects.push({ branch: t.branch, wtPath, wtExists, days, kase });
+async function prune(ctx, a) {
+  const main = ctx.main;
+  L.requireInstalled(main);
+  L.git(main, ['worktree', 'prune']);
+  const items = leftovers(main);
+  if (!items.length) return '정리할 것 없음 — 닫힌 태스크에 남은 워크트리·브랜치가 없다.';
+  const out = [];
+  let asked = false;
+  for (const st of items) {
+    const line = describe(main, st);
+    if (st.worktree && fs.existsSync(st.worktree) && L.changedFiles(st.worktree).length) {
+      out.push(`건너뜀: ${line}`);
+      continue;
     }
-  }
-
-  // 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 (!a.yes) {
+      if (!ctx.ask) {
+        out.push(`남음: ${line}`);
+        continue;
+      }
+      asked = true;
+      const ans = await ctx.ask(`${line}\n  정리할까? (y/N) `, 'n');
+      if (String(ans).toLowerCase() !== 'y') {
+        out.push(`보존: ${line}`);
+        continue;
       }
     }
+    out.push(`${L.taskLabel(st.num)}:`, ...cleanup(main, st, { force: true }).map((n) => `  - ${n}`));
   }
-
-  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}`);
-    }
+  if (!a.yes && !asked && !ctx.ask) {
+    out.push('묻지 않고 정리하려면 사용자가 명시했을 때 --yes로 다시 부른다(커밋 안 된 변경이 있는 곳은 그래도 건너뛴다).');
   }
-
-  console.log(`\n✅ taskery prune 완료 — 워크트리 ${toDelete.worktrees.length}건 / 브랜치 ${toDelete.branches.length}건 삭제.`);
+  return out.join('\n');
 }
 
-main().catch((e) => {
-  console.error(`taskery prune 실패: ${e.message}`);
-  process.exit(1);
-});
+module.exports = { prune };

package/bin/status.js

@@ -1,163 +1,69 @@
-#!/usr/bin/env node
-/**
- * bin/status.js
- * `npx @angar2/taskery status` — 멀티세션 현황 요약.
- *
- * 출력:
- *   - 메인 워크트리 + 현재 브랜치
- *   - projectId / stale_days / lock_timeout_ms
- *   - 진행중 태스크 (SSoT) + 각 워크트리 폴더 존재 여부 + 마지막 커밋 시각
- *   - stale 의심 항목 (케이스 A/B/C/D)
- *   - 머지 락 상태 (잡혀 있으면 누가 잡고 있는지)
- *
- * 본 명령은 *변경 X — 읽기 전용*. 정리는 `taskery prune`.
- */
-
+// status — 열린 태스크·단계 표·단계별 시간·문서 경로·워크트리 경로, 플랜별 시작할 수 있는 태스크·읽지 못한 항목(§5-3)
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
-
-const {
-  MANIFEST_NAME,
-  readManifest,
-  gitCapture,
-  getMainWorktreePath,
-  getActiveTasks,
-  getActiveVersion,
-  getWorktreesRoot,
-  getMergeLockPath,
-  DEFAULT_STALE_DAYS,
-  DEFAULT_LOCK_TIMEOUT_MS,
-} = require('./lib');
-
-function daysAgo(date) {
-  const now = Date.now();
-  const ms = now - date.getTime();
-  return Math.floor(ms / (1000 * 60 * 60 * 24));
-}
+const L = require('./lib');
+const { parsePlanItems } = require('./plan');
 
-function main() {
-  // 1. 메인 워크트리 + manifest
-  let mainWt;
-  try {
-    mainWt = getMainWorktreePath();
-  } catch (e) {
-    console.error(`taskery status 실패: ${e.message}`);
-    process.exit(1);
-  }
+const HEAD = ['시작·기획', '개발', '테스트', '닫기'];
 
-  const manifest = readManifest(path.join(mainWt, MANIFEST_NAME));
-  if (!manifest) {
-    console.error(`${MANIFEST_NAME} 없음 — 'npx @angar2/taskery init' 먼저 실행 필요.`);
-    process.exit(1);
+function openTasks(main, open) {
+  if (!open.length) return [`열린 태스크 없음. (본진: ${main})`];
+  const out = [`열린 태스크 ${open.length}개 (본진: ${main})`];
+  for (const st of open) {
+    const cells = L.stageCells(st);
+    out.push('');
+    out.push(`${L.taskLabel(st.num)} ${st.title}`);
+    out.push(`- 플랜 ${st.plan}${st.item ? ` 항목 ${st.item}` : ''} · ${st.type} · ${st.size} · 스위치 ${st.switch.join(',')} · 범위 ${st.range}`);
+    out.push(`- 단계: ${HEAD.map((h, i) => `${h} ${cells[i]}`).join(' | ')}`);
+    out.push(`- 문서: ${L.docShown(main, st)}`);
+    if (st.noBranch) out.push(`- 워크트리: 없음 — 분기 생략(--no-branch), 본진 ${st.parent}에서 일한다`);
+    else if (st.noWorktree) out.push(`- 워크트리: 없음 — 분기 생략(--no-worktree), 본진에서 브랜치 ${st.branch}로 일한다`);
+    else out.push(`- 워크트리: ${st.worktree} (브랜치 ${st.branch})`);
   }
+  return out;
+}
 
-  const projectId = manifest.projectId;
-  const staleDays = manifest.stale_days ?? DEFAULT_STALE_DAYS;
-  const lockTimeoutMs = manifest.lock_timeout_ms ?? DEFAULT_LOCK_TIMEOUT_MS;
-
-  const currentBranch = gitCapture(mainWt, ['rev-parse', '--abbrev-ref', 'HEAD']);
-  const detached = currentBranch === 'HEAD';
-
-  console.log(`\ntaskery status\n`);
-  console.log(`메인 워크트리: ${mainWt}`);
-  // 현재 브랜치 = 새 태스크의 부모 브랜치(0.6.0). detached HEAD면 fork 불가.
-  console.log(
-    `현재 브랜치(= 새 태스크 부모): ${currentBranch}${detached ? ' ⚠ (detached HEAD — 브랜치 체크아웃 필요)' : ''}`,
-  );
-  console.log(`projectId: ${projectId}`);
-  // 활성 plan(0.7.0+ manifest SSoT) — 스킬·진입 문서가 "활성 plan은 status로 확인"이라
-  // 지시하므로 여기서 반드시 출력한다. 미설정이면 다음 행동까지 안내한다.
-  let activePlan = null;
-  try {
-    activePlan = getActiveVersion(mainWt);
-  } catch (e) {
-    activePlan = null;
-  }
-  console.log(
-    `활성 plan: ${activePlan ?? '미설정 — /plan-init으로 생성하거나 plan-switch <NNN_slug>로 지정'}`,
-  );
-  console.log(`stale_days: ${staleDays} / lock_timeout_ms: ${lockTimeoutMs}\n`);
-
-  // 2. 머지 락 상태
-  const lockPath = getMergeLockPath(projectId);
-  const lockDir = lockPath + '.lock'; // proper-lockfile은 <file>.lock 디렉토리 생성
-  if (fs.existsSync(lockDir)) {
-    let lockInfo = '';
-    try {
-      const stat = fs.statSync(lockDir);
-      const ageMs = Date.now() - stat.mtimeMs;
-      lockInfo = ` (잡힘 ${Math.round(ageMs / 1000)}초 전)`;
-    } catch (_) {}
-    console.log(`머지 락: 활성${lockInfo}`);
-  } else {
-    console.log(`머지 락: 비활성`);
-  }
-  console.log();
-
-  // 3. 진행중 태스크 (SSoT)
-  const active = getActiveTasks(mainWt);
-  console.log(`진행중 태스크 (SSoT, ${active.length}건):`);
-
-  if (active.length === 0) {
-    console.log(`  (없음)`);
-  } else {
-    const worktreesRoot = getWorktreesRoot(projectId);
-    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 daysOld = lastDate ? daysAgo(lastDate) : null;
-
-      console.log(`  ${t.branch}`);
-      console.log(`    워크트리: ${wtPath}${wtExists ? '' : ' ⚠ 폴더 없음 (케이스 A — prune 필요)'}`);
-      if (lastDate) {
-        console.log(`    마지막 커밋: ${lastCommit} (${daysOld}일 전)${daysOld >= staleDays ? ' ⚠ stale 의심 (케이스 B/C)' : ''}`);
-      } else {
-        console.log(`    마지막 커밋: (조회 실패)`);
-      }
-      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)) {
-          console.log(`    ⚠ rebase 잔여 상태 (케이스 D) — taskery prune 또는 워크트리에서 git rebase --abort`);
-        }
-      }
+// 플랜 하나의 시작할 수 있는 항목 — 끝나지 않았고, 열린 태스크가 없고, 선행 항목이 모두 끝난 것(§5-3)
+function planLines(main, plan, byNum) {
+  const { items, unreadable, noList } = parsePlanItems(fs.readFileSync(path.join(main, '.taskery', 'plans', plan, 'PLAN.md'), 'utf8'));
+  if (noList) return [`- ${plan}: \`## 태스크 목록\`이 없다`];
+  const index = new Map(items.map((it) => [it.num, it]));
+  // 항목이 끝났다 = 가장 최근 연결된 태스크가 끝난 태스크(마무리 기록이 있고 닫힘)
+  const done = (it) => {
+    const st = it.tasks.length ? byNum.get(it.tasks[it.tasks.length - 1]) : null;
+    return !!(st && st.closed && st.closed.finished);
+  };
+  const ready = [];
+  for (const it of items) {
+    const missing = it.pre.filter((n) => !index.has(n));
+    if (missing.length) {
+      unreadable.push(`${it.line} (선행 항목 ${missing.join(', ')}이 목록에 없다)`);
+      continue;
     }
+    const busy = it.tasks.some((n) => byNum.has(n) && !byNum.get(n).closed);
+    if (!done(it) && !busy && it.pre.every((n) => done(index.get(n)))) ready.push(`${it.num}. ${it.desc}`);
   }
-  console.log();
+  const out = [`- ${plan}: ${ready.length ? ready.join(' · ') : '없음'}`];
+  for (const u of unreadable) out.push(`  - 읽지 못한 항목(시작할 수 있는 태스크에서 뺐다): ${u}`);
+  return out;
+}
 
-  // 4. 워크트리 폴더 vs SSoT mismatch (orphan)
-  const worktreesRoot = getWorktreesRoot(projectId);
-  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}`,
-      ),
-    );
-    const orphans = folders.filter((f) => !activeFolders.has(f));
-    if (orphans.length > 0) {
-      console.log(`⚠ SSoT에 없는 워크트리 폴더 ${orphans.length}건 (이미 부모 머지된 잔존?):`);
-      for (const o of orphans) {
-        console.log(`  ${path.join(worktreesRoot, o)}`);
-      }
-      console.log(`  → 'taskery prune' 으로 정리`);
-      console.log();
-    }
+async function status(ctx) {
+  const main = ctx.main;
+  L.requireInstalled(main);
+  const states = L.listStates(main);
+  const out = openTasks(
+    main,
+    states.filter((s) => !s.closed),
+  );
+  const dir = path.join(main, '.taskery', 'plans');
+  const plans = fs.existsSync(dir) ? fs.readdirSync(dir).filter((n) => fs.existsSync(path.join(dir, n, 'PLAN.md'))).sort() : [];
+  if (plans.length) {
+    const byNum = new Map(states.map((s) => [s.num, s]));
+    out.push('', '플랜별 시작할 수 있는 태스크 (PLAN.md 목록 항목)');
+    for (const plan of plans) out.push(...planLines(main, plan, byNum));
   }
-
-  console.log(`기타 명령:`);
-  console.log(`  npx @angar2/taskery prune   stale 워크트리 / 브랜치 대화형 정리`);
-  console.log();
+  return out.join('\n');
 }
 
-try {
-  main();
-} catch (e) {
-  console.error(`taskery status 실패: ${e.message}`);
-  process.exit(1);
-}
+module.exports = { status };

package/bin/taskery.js

@@ -1,131 +1,87 @@
 #!/usr/bin/env node
-/**
- * bin/taskery.js
- * `npx @angar2/taskery <subcommand>` — 진입점 dispatcher.
- *
- * 서브커맨드:
- *   init    — 현재 디렉토리에 taskery 자산 카피 + manifest 생성 (플랫폼 선택)
- *   add     — 기존 설치 리포에 플랫폼 자산 추가 (claude | codex)
- *   update  — 최신 버전 fetch + manifest 비교 + 머지 갱신
- *   status  — 멀티세션 현황 요약 (진행중 태스크 / 워크트리 / 머지 락, 0.1.2+)
- *   prune   — stale 워크트리 / 브랜치 대화형 정리 (0.1.2+)
- *   fork    — task 분기 (채번+워크트리+브랜치 생성 init 락 원자 실행, 0.3.2+) + 골격 task.md 자동 생성(--size/--title)
- *   backlog-add/get/mark — 활성 plan BACKLOG.md 조작 (채번/조회/확인 마킹, 코드화)
- *   set-status — task 헤더 상태 전이 (7×7 유효전이 검증, 코드화)
- *   plan-init — plan 생성 (채번+폴더+ROADMAP/PLAN/BACKLOG 골격+manifest.activePlan 갱신, 코드화)
- *   plan-switch — 활성 plan 전환 (manifest.activePlan 갱신, 0.7.0+)
- *   close   — close 결정적 준비 (Phase커밋+status=closed+문서커밋+추적마커; 비가역 머지/정리는 스킬, 코드화)
- *   mcp     — stdio MCP 서버 기동 (lib core를 도구 8종으로 노출; Claude/Codex 등록)
- *   help    — 사용법 출력
- */
-
-const { spawnSync } = require('child_process');
+// taskery CLI 입구 — 설치 명령(init·update·add)·mcp는 각 스크립트로, 나머지는 명령 정의표에서 만든다
 const path = require('path');
+const { spawnSync } = require('child_process');
+const { COMMANDS, execute } = require('./commands');
+const L = require('./lib');
 
-const sub = process.argv[2];
+const INSTALL = { init: 'init.js', update: 'update.js', add: 'add.js', mcp: 'mcp.js' };
 
-function runScript(scriptName, injectArgs = []) {
-  // injectArgs: dispatcher가 스크립트에 주입하는 선행 인자(예: backlog 서브op). 그 뒤로 사용자 인자.
-  const scriptPath = path.resolve(__dirname, scriptName);
-  const r = spawnSync(process.execPath, [scriptPath, ...injectArgs, ...process.argv.slice(3)], {
-    stdio: 'inherit',
-  });
-  process.exit(r.status ?? 1);
+function usage(cmd) {
+  const pos = cmd.args.filter((a) => a.positional).map((a) => `<${a.name}>`);
+  const opts = cmd.args
+    .filter((a) => !a.positional)
+    .map((a) => (a.type === 'bool' ? `[--${a.name}]` : a.type === 'list' ? `[--${a.name} <값> …]` : `[--${a.name} <값>]`));
+  return [cmd.name, ...pos, ...opts].join(' ');
 }
 
 function help() {
-  console.log(`taskery v${require('./lib').getPackageVersion()}
-
-사용법:
-  npx @angar2/taskery init      현재 디렉토리에 taskery 자산 설치 (플랫폼 선택)
-  npx @angar2/taskery add <p>   기존 설치에 플랫폼 추가 (claude | codex)
-  npx @angar2/taskery update    최신 버전 fetch + 머지 갱신
-  npx @angar2/taskery status    멀티세션 현황 (진행중 태스크 / 워크트리 / 머지 락)
-  npx @angar2/taskery prune     stale 워크트리 / 브랜치 대화형 정리
-  npx @angar2/taskery fork <type> <dev> <src> <slug> [--size <s> --title "<제목>" --promote]   task 분기 + 골격 생성 (통상 /task-init 경유)
-  npx @angar2/taskery backlog-add --type <t> --title <제목> --slug <slug> --summary <개요> --target <대상영역>   백로그 추가
-  npx @angar2/taskery backlog-get <BL-NNN>             백로그 항목 조회 (JSON)
-  npx @angar2/taskery backlog-mark <BL-NNN> <TASK-NNN> 백로그 확인 마킹
-  npx @angar2/taskery set-status <TASK-NNN> <state>    task 상태 전이 (유효전이 검증)
-  npx @angar2/taskery plan-init <slug> [--force]       plan 생성 (채번+폴더+골격+활성plan 갱신)
-  npx @angar2/taskery plan-switch <NNN_slug>           활성 plan 전환
-  npx @angar2/taskery close <TASK-NNN>                 close 결정적 준비 (Phase커밋+status=closed+추적마커)
-  npx @angar2/taskery mcp                              MCP stdio 서버 기동 (Claude .mcp.json / Codex codex mcp add 등록)
-  npx @angar2/taskery help      도움말
-
-새 프로젝트 시작:
-  npx -p @angar2/taskery create-taskery <project-name>
-
-상세: https://github.com/angar2/taskery
-`);
+  const lines = [`taskery v${L.getPackageVersion()}`, '', '설치:'];
+  lines.push('  init                현재 리포(또는 빈 폴더)에 taskery를 설치한다');
+  lines.push('  update              설치된 파일을 이 버전으로 갱신한다');
+  lines.push('  add <claude|codex>  플랫폼을 추가한다');
+  lines.push('  mcp                 MCP 서버를 띄운다(.mcp.json·.codex/config.toml이 부른다)');
+  lines.push('', '명령:');
+  for (const c of COMMANDS) {
+    lines.push(`  ${usage(c)}`);
+    lines.push(`      ${c.summary}`);
+  }
+  return lines.join('\n');
 }
 
-switch (sub) {
-  case 'init':
-    runScript('init.js');
-    break;
-  case 'add':
-    runScript('add.js');
-    break;
-  case 'update':
-    runScript('update.js');
-    break;
-  case 'status':
-    runScript('status.js');
-    break;
-  case 'prune':
-    if (process.argv[3] === '--help' || process.argv[3] === '-h') {
-      console.log(`taskery prune — stale 워크트리 / 브랜치 대화형 정리
-
-사용법:
-  npx @angar2/taskery prune
-
-설명:
-  .taskery-manifest.json의 stale_days (기본 30일) 기준으로 비활성 워크트리 + 브랜치를 대화형 정리합니다.
-  케이스 분기: A (워크트리 + 브랜치 모두 stale) / B (브랜치만 stale) / C (워크트리 폴더 잔존) / D (정합 영역).
-  각 케이스마다 y/n/k 선택 가능 (y = 삭제 / n = 건너뜀 / k = 보존 명시).
-
-상세: https://github.com/angar2/taskery
-`);
-      break;
+function parseArgs(cmd, argv) {
+  const out = {};
+  const positional = cmd.args.filter((a) => a.positional);
+  let pi = 0;
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok.startsWith('--')) {
+      const name = tok.slice(2);
+      const def = cmd.args.find((a) => !a.positional && a.name === name);
+      if (!def) L.fail(`${cmd.name}: 모르는 옵션 --${name}.\n사용법: ${usage(cmd)}`);
+      if (def.type === 'bool') out[name] = true;
+      else if (def.type === 'list') {
+        const vals = [];
+        while (i + 1 < argv.length && !argv[i + 1].startsWith('--')) vals.push(argv[++i]);
+        out[name] = vals;
+      } else {
+        if (i + 1 >= argv.length) L.fail(`${cmd.name}: --${name}에 값을 넣는다.`);
+        out[name] = argv[++i];
+      }
+    } else {
+      if (pi >= positional.length) L.fail(`${cmd.name}: 인자가 너무 많다 ('${tok}').\n사용법: ${usage(cmd)}`);
+      out[positional[pi++].name] = tok;
     }
-    runScript('prune.js');
-    break;
-  case 'fork':
-    runScript('fork.js');
-    break;
-  case 'backlog-add':
-    runScript('backlog.js', ['add']);
-    break;
-  case 'backlog-get':
-    runScript('backlog.js', ['get']);
-    break;
-  case 'backlog-mark':
-    runScript('backlog.js', ['mark']);
-    break;
-  case 'set-status':
-    runScript('set-status.js');
-    break;
-  case 'plan-init':
-    runScript('plan.js', ['init']);
-    break;
-  case 'plan-switch':
-    runScript('plan.js', ['switch']);
-    break;
-  case 'close':
-    runScript('close.js');
-    break;
-  case 'mcp':
-    runScript('mcp.js');
-    break;
-  case 'help':
-  case '--help':
-  case '-h':
-  case undefined:
-    help();
-    break;
-  default:
-    console.error(`taskery: 알 수 없는 서브커맨드 '${sub}'.`);
-    help();
-    process.exit(1);
+  }
+  return out;
 }
+
+async function main() {
+  const sub = process.argv[2];
+  if (!sub || sub === 'help' || sub === '--help' || sub === '-h') {
+    console.log(help());
+    return 0;
+  }
+  if (INSTALL[sub]) {
+    const r = spawnSync(process.execPath, [path.join(__dirname, INSTALL[sub]), ...process.argv.slice(3)], { stdio: 'inherit' });
+    return r.status ?? 1;
+  }
+  const cmd = COMMANDS.find((c) => c.name === sub);
+  if (!cmd) {
+    console.error(`taskery: 모르는 명령 '${sub}'.\n\n${help()}`);
+    return 1;
+  }
+  const asker = cmd.interactive ? require('./install').makeAsker() : null;
+  try {
+    const out = await execute(cmd, parseArgs(cmd, process.argv.slice(3)), { ask: asker && asker.ask });
+    if (out) console.log(out);
+    return 0;
+  } catch (e) {
+    console.error(e instanceof L.TaskeryError ? e.message : `taskery ${sub} 실패: ${e.stack || e.message}`);
+    return 1;
+  } finally {
+    if (asker) asker.close();
+  }
+}
+
+main().then((code) => process.exit(code));