@silbaram/artifact-driven-agent 0.1.5 → 0.1.6

package/src/commands/sprint.js

@@ -0,0 +1,262 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { getWorkspaceDir, isWorkspaceSetup, getTimestamp } from '../utils/files.js';
+
+/**
+ * 스프린트 관리 명령어
+ * @param {string} action - create / add / close / list
+ * @param {Array} args - 추가 인자
+ */
+export default async function sprint(action, ...args) {
+  if (!isWorkspaceSetup()) {
+    console.log(chalk.red('❌ 워크스페이스가 설정되지 않았습니다.'));
+    console.log(chalk.gray('   ada setup [template]을 먼저 실행하세요.'));
+    process.exit(1);
+  }
+
+  const workspace = getWorkspaceDir();
+  const sprintsDir = path.join(workspace, 'artifacts', 'sprints');
+
+  switch (action) {
+    case 'create':
+      await createSprint(sprintsDir);
+      break;
+    case 'add':
+      await addTasks(sprintsDir, args);
+      break;
+    case 'close':
+      await closeSprint(sprintsDir);
+      break;
+    case 'list':
+      await listSprints(sprintsDir);
+      break;
+    default:
+      console.log(chalk.red('❌ 알 수 없는 명령어입니다.'));
+      console.log('');
+      console.log(chalk.cyan('사용법:'));
+      console.log(chalk.gray('  ada sprint create           - 새 스프린트 생성'));
+      console.log(chalk.gray('  ada sprint add task-001 ... - Task 추가'));
+      console.log(chalk.gray('  ada sprint close            - 현재 스프린트 종료'));
+      console.log(chalk.gray('  ada sprint list             - 스프린트 목록'));
+      process.exit(1);
+  }
+}
+
+/**
+ * 새 스프린트 생성
+ */
+async function createSprint(sprintsDir) {
+  fs.ensureDirSync(sprintsDir);
+
+  // 현재 활성 스프린트 확인
+  const activeSprint = findActiveSprint(sprintsDir);
+  if (activeSprint) {
+    console.log(chalk.yellow(`⚠️  이미 활성 스프린트가 있습니다: ${activeSprint}`));
+    console.log(chalk.gray('   먼저 ada sprint close로 종료하세요.'));
+    process.exit(1);
+  }
+
+  // 다음 스프린트 번호 계산
+  const sprints = fs.readdirSync(sprintsDir).filter(d => {
+    return fs.statSync(path.join(sprintsDir, d)).isDirectory() && !d.startsWith('_');
+  });
+
+  const sprintNumbers = sprints
+    .map(name => {
+      const match = name.match(/^sprint-(\d+)$/);
+      return match ? parseInt(match[1]) : 0;
+    })
+    .filter(n => n > 0);
+
+  const nextNumber = sprintNumbers.length > 0 ? Math.max(...sprintNumbers) + 1 : 1;
+  const sprintName = `sprint-${nextNumber}`;
+  const sprintPath = path.join(sprintsDir, sprintName);
+
+  // 템플릿 복사
+  const templatePath = path.join(sprintsDir, '_template');
+  if (!fs.existsSync(templatePath)) {
+    console.log(chalk.red('❌ 스프린트 템플릿이 없습니다.'));
+    process.exit(1);
+  }
+
+  fs.copySync(templatePath, sprintPath);
+
+  // meta.md 업데이트
+  const metaPath = path.join(sprintPath, 'meta.md');
+  let metaContent = fs.readFileSync(metaPath, 'utf-8');
+  const today = new Date().toISOString().slice(0, 10);
+
+  metaContent = metaContent
+    .replace(/스프린트 번호 \| N/, `스프린트 번호 | ${nextNumber}`)
+    .replace(/상태 \| active \/ completed/, `상태 | active`)
+    .replace(/시작일 \| YYYY-MM-DD/, `시작일 | ${today}`)
+    .replace(/종료 예정 \| YYYY-MM-DD/, `종료 예정 | TBD`);
+
+  fs.writeFileSync(metaPath, metaContent);
+
+  console.log('');
+  console.log(chalk.green('✅ 새 스프린트가 생성되었습니다!'));
+  console.log('');
+  console.log(chalk.cyan(`📂 ${sprintName}/`));
+  console.log(chalk.gray(`   - meta.md (스프린트 정보)`));
+  console.log(chalk.gray(`   - tasks/ (Task 파일)`));
+  console.log(chalk.gray(`   - review-reports/ (리뷰 리포트)`));
+  console.log(chalk.gray(`   - docs/ (문서)`));
+  console.log('');
+  console.log(chalk.cyan('다음 단계:'));
+  console.log(chalk.gray(`   ada sprint add task-001 task-002  - Task 추가`));
+  console.log('');
+}
+
+/**
+ * 현재 활성 스프린트 찾기
+ */
+function findActiveSprint(sprintsDir) {
+  if (!fs.existsSync(sprintsDir)) return null;
+
+  const sprints = fs.readdirSync(sprintsDir).filter(d => {
+    return fs.statSync(path.join(sprintsDir, d)).isDirectory() && !d.startsWith('_');
+  });
+
+  for (const sprint of sprints) {
+    const metaPath = path.join(sprintsDir, sprint, 'meta.md');
+    if (fs.existsSync(metaPath)) {
+      const content = fs.readFileSync(metaPath, 'utf-8');
+      if (content.includes('상태 | active')) {
+        return sprint;
+      }
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Task 추가
+ */
+async function addTasks(sprintsDir, taskIds) {
+  if (taskIds.length === 0) {
+    console.log(chalk.red('❌ Task ID를 지정하세요.'));
+    console.log(chalk.gray('   예: ada sprint add task-001 task-002'));
+    process.exit(1);
+  }
+
+  const activeSprint = findActiveSprint(sprintsDir);
+  if (!activeSprint) {
+    console.log(chalk.red('❌ 활성 스프린트가 없습니다.'));
+    console.log(chalk.gray('   먼저 ada sprint create로 생성하세요.'));
+    process.exit(1);
+  }
+
+  const sprintPath = path.join(sprintsDir, activeSprint);
+  const backlogPath = path.join(getWorkspaceDir(), 'artifacts', 'backlog');
+
+  if (!fs.existsSync(backlogPath)) {
+    console.log(chalk.red('❌ backlog/ 디렉토리가 없습니다.'));
+    process.exit(1);
+  }
+
+  let addedCount = 0;
+
+  for (const taskId of taskIds) {
+    const taskFile = `${taskId}.md`;
+    const sourcePath = path.join(backlogPath, taskFile);
+    const destPath = path.join(sprintPath, 'tasks', taskFile);
+
+    if (!fs.existsSync(sourcePath)) {
+      console.log(chalk.yellow(`⚠️  ${taskId}: backlog에 없음 (건너뜀)`));
+      continue;
+    }
+
+    if (fs.existsSync(destPath)) {
+      console.log(chalk.yellow(`⚠️  ${taskId}: 이미 스프린트에 있음 (건너뜀)`));
+      continue;
+    }
+
+    // Task 파일 복사
+    fs.copyFileSync(sourcePath, destPath);
+    addedCount++;
+
+    console.log(chalk.green(`✅ ${taskId} 추가됨`));
+  }
+
+  console.log('');
+  console.log(chalk.cyan(`📊 ${addedCount}개 Task가 ${activeSprint}에 추가되었습니다.`));
+  console.log('');
+  console.log(chalk.gray(`   meta.md를 업데이트하여 Task 목록을 갱신하세요.`));
+  console.log('');
+}
+
+/**
+ * 스프린트 종료
+ */
+async function closeSprint(sprintsDir) {
+  const activeSprint = findActiveSprint(sprintsDir);
+  if (!activeSprint) {
+    console.log(chalk.red('❌ 활성 스프린트가 없습니다.'));
+    process.exit(1);
+  }
+
+  const sprintPath = path.join(sprintsDir, activeSprint);
+  const metaPath = path.join(sprintPath, 'meta.md');
+
+  // meta.md 업데이트 (active → completed)
+  let metaContent = fs.readFileSync(metaPath, 'utf-8');
+  const today = new Date().toISOString().slice(0, 10);
+
+  metaContent = metaContent
+    .replace(/상태 \| active/, `상태 | completed`)
+    .replace(/종료 예정 \| .*/, `종료 예정 | ${today}`);
+
+  fs.writeFileSync(metaPath, metaContent);
+
+  console.log('');
+  console.log(chalk.green(`✅ ${activeSprint}가 종료되었습니다!`));
+  console.log('');
+  console.log(chalk.cyan('다음 단계:'));
+  console.log(chalk.gray(`   1. meta.md 회고 섹션 작성`));
+  console.log(chalk.gray(`   2. ada documenter [tool]로 문서 작성`));
+  console.log(chalk.gray(`   3. ada sprint create로 다음 스프린트 시작`));
+  console.log('');
+}
+
+/**
+ * 스프린트 목록
+ */
+async function listSprints(sprintsDir) {
+  if (!fs.existsSync(sprintsDir)) {
+    console.log(chalk.yellow('⚠️  스프린트가 없습니다.'));
+    return;
+  }
+
+  const sprints = fs.readdirSync(sprintsDir)
+    .filter(d => {
+      return fs.statSync(path.join(sprintsDir, d)).isDirectory() && !d.startsWith('_');
+    })
+    .sort();
+
+  if (sprints.length === 0) {
+    console.log(chalk.yellow('⚠️  스프린트가 없습니다.'));
+    return;
+  }
+
+  console.log('');
+  console.log(chalk.cyan('📊 스프린트 목록'));
+  console.log(chalk.cyan('━'.repeat(60)));
+
+  for (const sprint of sprints) {
+    const metaPath = path.join(sprintsDir, sprint, 'meta.md');
+    if (fs.existsSync(metaPath)) {
+      const content = fs.readFileSync(metaPath, 'utf-8');
+      const statusMatch = content.match(/상태 \| (active|completed)/);
+      const status = statusMatch ? statusMatch[1] : 'unknown';
+      const statusIcon = status === 'active' ? '🟢' : '✅';
+      const statusText = status === 'active' ? chalk.green('진행 중') : chalk.gray('완료');
+
+      console.log(`${statusIcon} ${chalk.cyan(sprint)} - ${statusText}`);
+    }
+  }
+
+  console.log('');
+}

package/src/commands/validate.js

@@ -5,18 +5,14 @@ import { getWorkspaceDir, isWorkspaceSetup } from '../utils/files.js';
 
 export async function validate(doc) {
   if (!isWorkspaceSetup()) {
-    console.log(chalk.red('❌ 먼저 setup을 실행하세요.'));
+    console.log(chalk.red('? 먼저 setup을 실행하세요.'));
     process.exit(1);
   }
 
   const workspace = getWorkspaceDir();
   const artifactsDir = path.join(workspace, 'artifacts');
 
-  console.log('');
-  console.log(chalk.cyan('━'.repeat(50)));
-  console.log(chalk.cyan.bold('📋 문서 검증'));
-  console.log(chalk.cyan('━'.repeat(50)));
-  console.log('');
+  printSection('문서 검증');
 
   let totalPass = 0;
   let totalFail = 0;
@@ -37,7 +33,7 @@ export async function validate(doc) {
     totalWarn += result.warn;
   } else {
     // 전체 검증
-    for (const [name, validator] of Object.entries(validators)) {
+    for (const validator of Object.values(validators)) {
       const result = validator(artifactsDir);
       totalPass += result.pass;
       totalFail += result.fail;
@@ -45,15 +41,10 @@ export async function validate(doc) {
     }
   }
 
-  // 결과 요약
-  console.log('');
-  console.log(chalk.cyan('━'.repeat(50)));
-  console.log(chalk.white.bold('📊 검증 결과'));
-  console.log(chalk.cyan('━'.repeat(50)));
-  console.log('');
-  console.log(chalk.green(`  ✓ PASS: ${totalPass}`));
-  console.log(chalk.red(`  ✗ FAIL: ${totalFail}`));
-  console.log(chalk.yellow(`  ⚠ WARN: ${totalWarn}`));
+  printSection('검증 결과');
+  console.log(chalk.green(`  PASS: ${totalPass}`));
+  console.log(chalk.red(`  FAIL: ${totalFail}`));
+  console.log(chalk.yellow(`  WARN: ${totalWarn}`));
   console.log('');
 
   if (totalFail > 0) {
@@ -65,10 +56,10 @@ function validatePlan(artifactsDir) {
   const filePath = path.join(artifactsDir, 'plan.md');
   let pass = 0, fail = 0, warn = 0;
 
-  console.log(chalk.white.bold('📄 plan.md'));
+  printSection('plan.md');
 
   if (!fs.existsSync(filePath)) {
-    console.log(chalk.red('  ✗ 파일 없음'));
+    logFail('파일 없음');
     return { pass: 0, fail: 1, warn: 0 };
   }
 
@@ -78,10 +69,10 @@ function validatePlan(artifactsDir) {
   const requiredSections = ['서비스 개요', '기능 목록', '비기능 요구사항'];
   for (const section of requiredSections) {
     if (content.includes(section)) {
-      console.log(chalk.green(`  ✓ 섹션 존재: ${section}`));
+      logPass(`섹션 존재: ${section}`);
       pass++;
     } else {
-      console.log(chalk.red(`  ✗ 섹션 누락: ${section}`));
+      logFail(`섹션 누락: ${section}`);
       fail++;
     }
   }
@@ -89,10 +80,10 @@ function validatePlan(artifactsDir) {
   // TBD 개수 검사
   const tbdMatches = content.match(/TBD/gi) || [];
   if (tbdMatches.length > 3) {
-    console.log(chalk.yellow(`  ⚠ TBD 항목: ${tbdMatches.length}개 (3개 초과)`));
+    logWarn(`TBD 항목: ${tbdMatches.length}개 (3개 초과)`);
     warn++;
   } else {
-    console.log(chalk.green(`  ✓ TBD 항목: ${tbdMatches.length}개`));
+    logPass(`TBD 항목: ${tbdMatches.length}개`);
     pass++;
   }
 
@@ -104,10 +95,10 @@ function validateProject(artifactsDir) {
   const filePath = path.join(artifactsDir, 'project.md');
   let pass = 0, fail = 0, warn = 0;
 
-  console.log(chalk.white.bold('📄 project.md'));
+  printSection('project.md');
 
   if (!fs.existsSync(filePath)) {
-    console.log(chalk.red('  ✗ 파일 없음'));
+    logFail('파일 없음');
     return { pass: 0, fail: 1, warn: 0 };
   }
 
@@ -117,29 +108,29 @@ function validateProject(artifactsDir) {
   const requiredSections = ['프로젝트 규모', '기술 스택'];
   for (const section of requiredSections) {
     if (content.includes(section)) {
-      console.log(chalk.green(`  ✓ 섹션 존재: ${section}`));
+      logPass(`섹션 존재: ${section}`);
       pass++;
     } else {
-      console.log(chalk.red(`  ✗ 섹션 누락: ${section}`));
+      logFail(`섹션 누락: ${section}`);
       fail++;
     }
   }
 
   // Frozen 상태 검사
-  if (content.includes('Frozen') || content.includes('🔒')) {
-    console.log(chalk.green('  ✓ Frozen 상태 표시됨'));
+  if (content.includes('Frozen') || content.includes('??')) {
+    logPass('Frozen 상태 표시됨');
     pass++;
   } else {
-    console.log(chalk.yellow('  ⚠ Frozen 상태 미표시'));
+    logWarn('Frozen 상태 미표시');
     warn++;
   }
 
   // 모호한 버전 검사 (예: 1.x, 2.x)
   if (/\d+\.x/i.test(content)) {
-    console.log(chalk.yellow('  ⚠ 모호한 버전 형식 (예: 1.x)'));
+    logWarn('모호한 버전 형식 (예: 1.x)');
     warn++;
   } else {
-    console.log(chalk.green('  ✓ 버전 형식 양호'));
+    logPass('버전 형식 양호');
     pass++;
   }
 
@@ -147,35 +138,40 @@ function validateProject(artifactsDir) {
   return { pass, fail, warn };
 }
 
-function validateBacklog(artifactsDir) {
-  const filePath = path.join(artifactsDir, 'backlog.md');
+export function validateBacklog(artifactsDir) {
+  const backlogDir = path.join(artifactsDir, 'backlog');
   let pass = 0, fail = 0, warn = 0;
 
-  console.log(chalk.white.bold('📄 backlog.md'));
+  printSection('backlog/');
 
-  if (!fs.existsSync(filePath)) {
-    console.log(chalk.red('  ✗ 파일 없음'));
-    return { pass: 0, fail: 1, warn: 0 };
+  if (!fs.existsSync(backlogDir) || !fs.statSync(backlogDir).isDirectory()) {
+    logWarn('backlog/ 디렉토리 없음 (Task 생성 전)');
+    console.log('');
+    return { pass: 0, fail: 0, warn: 1 };
   }
 
-  const content = fs.readFileSync(filePath, 'utf-8');
+  const taskFiles = fs.readdirSync(backlogDir).filter(file => /^task-\d+\.md$/i.test(file));
 
-  // Task 개수 검사
-  const taskMatches = content.match(/TASK-\d+/gi) || [];
-  if (taskMatches.length > 0) {
-    console.log(chalk.green(`  ✓ Task 개수: ${taskMatches.length}개`));
+  if (taskFiles.length > 0) {
+    logPass(`Task 개수: ${taskFiles.length}개`);
     pass++;
   } else {
-    console.log(chalk.red('  ✗ Task 없음'));
-    fail++;
+    logWarn('대기 Task 없음');
+    warn++;
+    console.log('');
+    return { pass, fail, warn };
   }
 
-  // 수용 조건 존재 검사
-  if (content.includes('수용 조건') || content.includes('AC-') || content.includes('Acceptance')) {
-    console.log(chalk.green('  ✓ 수용 조건 존재'));
+  const missingAcceptance = taskFiles.filter(file => {
+    const content = fs.readFileSync(path.join(backlogDir, file), 'utf-8');
+    return !hasAcceptanceCriteria(content);
+  });
+
+  if (missingAcceptance.length === 0) {
+    logPass(`수용 조건 존재 (${taskFiles.length}/${taskFiles.length})`);
     pass++;
   } else {
-    console.log(chalk.yellow('  ⚠ 수용 조건 미확인'));
+    logWarn(`수용 조건 미확인 (${taskFiles.length - missingAcceptance.length}/${taskFiles.length})`);
     warn++;
   }
 
@@ -183,37 +179,110 @@ function validateBacklog(artifactsDir) {
   return { pass, fail, warn };
 }
 
-function validateSprint(artifactsDir) {
-  const filePath = path.join(artifactsDir, 'current-sprint.md');
+export function validateSprint(artifactsDir) {
+  const sprintsDir = path.join(artifactsDir, 'sprints');
   let pass = 0, fail = 0, warn = 0;
 
-  console.log(chalk.white.bold('📄 current-sprint.md'));
+  printSection('sprints/');
 
-  if (!fs.existsSync(filePath)) {
-    console.log(chalk.gray('  - 파일 없음 (스프린트 시작 전)'));
-    return { pass: 0, fail: 0, warn: 0 };
+  if (!fs.existsSync(sprintsDir) || !fs.statSync(sprintsDir).isDirectory()) {
+    logWarn('sprints/ 디렉토리 없음 (스프린트 시작 전)');
+    console.log('');
+    return { pass: 0, fail: 0, warn: 1 };
   }
 
-  const content = fs.readFileSync(filePath, 'utf-8');
+  const sprintDirs = fs.readdirSync(sprintsDir, { withFileTypes: true })
+    .filter(dirent => dirent.isDirectory() && /^sprint-\d+$/.test(dirent.name))
+    .map(dirent => dirent.name);
+
+  if (sprintDirs.length === 0) {
+    logWarn('스프린트 디렉토리 없음 (스프린트 시작 전)');
+    warn++;
+    console.log('');
+    return { pass, fail, warn };
+  }
+
+  const latestSprint = sprintDirs.sort((a, b) => {
+    const numA = parseInt(a.split('-')[1], 10);
+    const numB = parseInt(b.split('-')[1], 10);
+    return numB - numA;
+  })[0];
+
+  const metaPath = path.join(sprintsDir, latestSprint, 'meta.md');
+  if (!fs.existsSync(metaPath)) {
+    logFail(`${latestSprint}/meta.md 없음`);
+    console.log('');
+    return { pass: 0, fail: 1, warn: 0 };
+  }
+
+  const content = fs.readFileSync(metaPath, 'utf-8');
+  logInfo(`최신 스프린트: ${latestSprint}`);
+
+  const requiredFields = ['스프린트 번호', '상태', '시작일', '종료 예정', '목표'];
+  requiredFields.forEach(field => {
+    if (content.includes(field)) {
+      logPass(`필드 존재: ${field}`);
+      pass++;
+    } else {
+      logWarn(`필드 미확인: ${field}`);
+      warn++;
+    }
+  });
 
-  // 스프린트 번호 검사
-  if (/Sprint\s*#?\d+/i.test(content) || /스프린트\s*#?\d+/.test(content)) {
-    console.log(chalk.green('  ✓ 스프린트 번호 존재'));
+  if (content.includes('Task 요약')) {
+    logPass('Task 요약 섹션 존재');
     pass++;
   } else {
-    console.log(chalk.yellow('  ⚠ 스프린트 번호 미확인'));
+    logWarn('Task 요약 섹션 미확인');
     warn++;
   }
 
-  // 목표 섹션 검사
-  if (content.includes('목표') || content.includes('Goal')) {
-    console.log(chalk.green('  ✓ 목표 섹션 존재'));
-    pass++;
+  const tasksDir = path.join(sprintsDir, latestSprint, 'tasks');
+  if (fs.existsSync(tasksDir) && fs.statSync(tasksDir).isDirectory()) {
+    const taskFiles = fs.readdirSync(tasksDir).filter(file => /^task-\d+\.md$/i.test(file));
+    if (taskFiles.length > 0) {
+      logPass(`Task 개수: ${taskFiles.length}개`);
+      pass++;
+    } else {
+      logWarn('Task 없음');
+      warn++;
+    }
   } else {
-    console.log(chalk.yellow('  ⚠ 목표 섹션 미확인'));
+    logWarn('tasks/ 디렉토리 없음');
     warn++;
   }
 
   console.log('');
   return { pass, fail, warn };
 }
+
+function hasAcceptanceCriteria(content) {
+  return content.includes('수용 조건') || content.includes('Acceptance Criteria') || content.includes('AC-');
+}
+
+function printSection(title) {
+  const width = 60;
+  const line = '─'.repeat(width);
+  const paddedTitle = ` ${title}`.padEnd(width, ' ');
+  console.log('');
+  console.log(chalk.cyan(`┌${line}┐`));
+  console.log(chalk.cyan(`│${paddedTitle}│`));
+  console.log(chalk.cyan(`└${line}┘`));
+  console.log('');
+}
+
+function logPass(message) {
+  console.log(chalk.green(`  [PASS] ${message}`));
+}
+
+function logWarn(message) {
+  console.log(chalk.yellow(`  [WARN] ${message}`));
+}
+
+function logFail(message) {
+  console.log(chalk.red(`  [FAIL] ${message}`));
+}
+
+function logInfo(message) {
+  console.log(chalk.cyan(`  [INFO] ${message}`));
+}

package/src/commands/validate.test.js

@@ -0,0 +1,84 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { validateBacklog, validateSprint } from './validate.js';
+
+function createArtifactsDir(t) {
+  const baseDir = path.join(process.cwd(), 'tmp', 'validate-tests');
+  fs.mkdirSync(baseDir, { recursive: true });
+
+  const rootDir = fs.mkdtempSync(path.join(baseDir, 'case-'));
+  const artifactsDir = path.join(rootDir, 'artifacts');
+  fs.mkdirSync(artifactsDir, { recursive: true });
+
+  t.after(() => {
+    fs.rmSync(rootDir, { recursive: true, force: true });
+  });
+
+  return artifactsDir;
+}
+
+test('validateBacklog: backlog/의 task-*.md를 검증한다', (t) => {
+  const artifactsDir = createArtifactsDir(t);
+  const backlogDir = path.join(artifactsDir, 'backlog');
+  fs.mkdirSync(backlogDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(backlogDir, 'task-001.md'),
+    '# TASK-001\n\n## Acceptance Criteria\n- [ ] 준비\n'
+  );
+
+  const result = validateBacklog(artifactsDir);
+  assert.equal(result.fail, 0);
+  assert.equal(result.warn, 0);
+  assert.ok(result.pass > 0);
+});
+
+test('validateBacklog: Task가 없으면 경고한다', (t) => {
+  const artifactsDir = createArtifactsDir(t);
+  const backlogDir = path.join(artifactsDir, 'backlog');
+  fs.mkdirSync(backlogDir, { recursive: true });
+
+  const result = validateBacklog(artifactsDir);
+  assert.equal(result.fail, 0);
+  assert.ok(result.warn >= 1);
+});
+
+test('validateSprint: 최신 스프린트 meta.md와 tasks를 확인한다', (t) => {
+  const artifactsDir = createArtifactsDir(t);
+  const sprintDir = path.join(artifactsDir, 'sprints', 'sprint-1');
+  const tasksDir = path.join(sprintDir, 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+
+  fs.writeFileSync(
+    path.join(sprintDir, 'meta.md'),
+    [
+      '# Sprint 1 메타정보',
+      '',
+      '| 항목 | 값 |',
+      '|------|-----|',
+      '| 스프린트 번호 | 1 |',
+      '| 상태 | active |',
+      '| 시작일 | 2025-01-01 |',
+      '| 종료 예정 | 2025-01-07 |',
+      '| 목표 | 검증 |',
+      '',
+      '## Task 요약',
+      '',
+      '| Task | 상태 | 담당 | 우선순위 | 크기 |',
+      '|------|:----:|------|:--------:|:----:|',
+      '| task-001 | BACKLOG | - | P0 | S |',
+      ''
+    ].join('\n')
+  );
+
+  fs.writeFileSync(
+    path.join(tasksDir, 'task-001.md'),
+    '# TASK-001\n\n## Acceptance Criteria\n- [ ] 준비\n'
+  );
+
+  const result = validateSprint(artifactsDir);
+  assert.equal(result.fail, 0);
+  assert.equal(result.warn, 0);
+});