timsquad 3.5.0 → 3.6.0

package/templates/base/skills/coding/SKILL.md

@@ -1,47 +1,67 @@
 ---
 name: coding
-description: 코드 작성 규칙 및 패턴 가이드라인
+description: |
+  코드 작성 규칙 및 패턴 가이드라인.
+  네이밍 규칙, 함수 원칙, 에러 핸들링, 금지 패턴을 다룸.
+  Use when: "코드 작성, 구현, 리팩토링, 네이밍, 코딩 컨벤션"
 version: "1.0.0"
 tags: [coding, conventions, naming]
+depends_on: []
+conflicts_with: []
 user-invocable: false
 ---
 
 # Coding Guidelines
 
-## 네이밍 규칙
+코드 작성 시 일관된 컨벤션과 패턴을 적용한다.
 
-| 대상 | 규칙 | 예시 |
-|------|------|------|
-| 클래스 | PascalCase | `UserService`, `OrderRepository` |
-| 함수/메서드 | camelCase | `getUserById`, `calculateTotal` |
-| 변수 | camelCase | `userName`, `totalAmount` |
-| 상수 | UPPER_SNAKE | `MAX_RETRY_COUNT`, `API_BASE_URL` |
-| 파일 | kebab-case | `user-service.ts`, `order-repository.ts` |
+## Philosophy
+
+- 단일 책임: 함수는 한 가지 일만 수행
+- 명확한 이름: 코드만 읽고도 동작을 파악 가능
+- 명시적 에러 처리: 에러를 삼키지 않는다
+
+## Contract
+
+- **Trigger**: 코드 작성/수정 태스크
+- **Input**: 구현 요구사항 + 기존 코드 컨텍스트
+- **Output**: 컨벤션 준수 코드
+- **Error**: 컨벤션 위반 시 수정 안내
+- **Dependencies**: 없음
+
+## Protocol
+
+1. **컨벤션 확인**: 네이밍, 파일 구조 규칙 확인
+2. **구현**: 단일 책임 원칙 준수하며 코드 작성
+3. **린트**: `tsc --noEmit` + 린트 검증
+4. **리뷰**: 금지 패턴(any, 매직넘버, console.log) 제거 확인
 
-## 함수 원칙
-- **단일 책임**: 함수는 한 가지 일만 수행
-- **명확한 이름**: 함수 이름만으로 동작 파악 가능
-- **적절한 크기**: 20줄 이내 권장
+## Verification
 
-## Rules
+| Check | Command | Pass Criteria |
+|-------|---------|---------------|
+| 타입 검사 | `tsc --noEmit` | exit code 0 |
+| any 타입 | `grep -r "any" --include="*.ts"` | 0건 (신규 코드) |
+| console.log | `grep -r "console.log" --include="*.ts"` | 0건 (신규 코드) |
+| 함수 크기 | 수동 검증 | 20줄 이내 권장 |
 
-### 필수
-- 함수가 단일 책임을 가지는가
-- 네이밍이 명확하고 일관적인가
-- 에러가 명시적으로 처리되는가
+## Resources
+
+| Priority | Type | Resource | Description |
+|----------|------|----------|-------------|
+| HIGH | rule | [patterns](rules/patterns.md) | Error Handling, Repository, DTO, Anti-Patterns |
+
+## Quick Rules
+
+### 네이밍
+| 대상 | 규칙 | 예시 |
+|------|------|------|
+| 클래스 | PascalCase | `UserService` |
+| 함수/변수 | camelCase | `getUserById` |
+| 상수 | UPPER_SNAKE | `MAX_RETRY_COUNT` |
+| 파일 | kebab-case | `user-service.ts` |
 
 ### 금지
 - `any` 타입 사용
 - 매직 넘버/문자열 사용
 - `console.log` 사용 (logger 사용)
-
-## Checklist
-- [ ] 함수가 단일 책임
-- [ ] 네이밍이 명확하고 일관적
-- [ ] 에러가 명시적으로 처리됨
-- [ ] any 타입 없음
-- [ ] 매직 넘버/문자열 없음
-- [ ] console.log 없음
-
-## 참조
-- `rules/patterns.md` — Error Handling, Repository, DTO/Entity, 의존성 주입, Anti-Patterns

package/templates/base/skills/coding/rules/async-patterns.md

@@ -0,0 +1,81 @@
+---
+title: Async/Await Best Practices
+impact: HIGH
+tags: coding, async, performance
+---
+
+# Async/Await Best Practices
+
+## Avoid Callback Hell
+
+```typescript
+// Bad: 중첩 콜백
+getUser(id, (user) => {
+  getOrders(user.id, (orders) => {
+    getItems(orders[0].id, (items) => { /* ... */ });
+  });
+});
+
+// Good: async/await 플랫 구조
+const user = await getUser(id);
+const orders = await getOrders(user.id);
+const items = await getItems(orders[0].id);
+```
+
+## Parallel Execution with Promise.all
+
+```typescript
+// Bad: 순차 실행 — 불필요한 대기
+const users = await getUsers();
+const orders = await getOrders();
+const stats = await getStats();
+
+// Good: 독립 작업은 병렬 실행
+const [users, orders, stats] = await Promise.all([
+  getUsers(),
+  getOrders(),
+  getStats(),
+]);
+```
+
+## Error Propagation
+
+```typescript
+// Bad: 에러 삼킴
+async function fetchData() {
+  try { return await api.get('/data'); }
+  catch { return []; } // 실패 원인 불명
+}
+
+// Good: 의미 있는 에러 변환 후 전파
+async function fetchData() {
+  try { return await api.get('/data'); }
+  catch (err) {
+    throw new AppError('FETCH_FAILED', 'Data fetch failed', 500, err as Error);
+  }
+}
+```
+
+## Promise.allSettled for Partial Failures
+
+```typescript
+const results = await Promise.allSettled([
+  sendEmail(user1),
+  sendEmail(user2),
+  sendEmail(user3),
+]);
+
+const failures = results.filter(
+  (r): r is PromiseRejectedResult => r.status === 'rejected',
+);
+if (failures.length) logger.warn('Partial failures', { count: failures.length });
+```
+
+## Rules
+
+| Rule | Description |
+|------|-------------|
+| 불필요한 await 금지 | return 직전 단일 Promise는 await 생략 가능 |
+| for-of + await 주의 | 순차 필요 시만 사용, 아니면 Promise.all |
+| void Promise 금지 | fire-and-forget 시 명시적 .catch 또는 void 연산자 |
+| async 함수 반환 타입 | Promise<T>를 명시적으로 선언 |

package/templates/base/skills/coding/rules/code-organization.md

@@ -0,0 +1,80 @@
+---
+title: Code Organization
+impact: MEDIUM
+tags: coding, architecture, modules
+---
+
+# Code Organization
+
+## Single Responsibility
+
+```typescript
+// Bad: 하나의 클래스가 여러 책임
+class UserService {
+  async createUser(dto: CreateUserDto) { /* ... */ }
+  async sendWelcomeEmail(user: User) { /* ... */ }
+  async generateReport(userId: string) { /* ... */ }
+}
+
+// Good: 책임 분리
+class UserService { async createUser(dto: CreateUserDto) { /* ... */ } }
+class NotificationService { async sendWelcomeEmail(user: User) { /* ... */ } }
+class ReportService { async generateReport(userId: string) { /* ... */ } }
+```
+
+## Module Boundaries
+
+```
+src/
+  modules/
+    user/
+      user.service.ts
+      user.repository.ts
+      user.types.ts
+      index.ts          # barrel export (public API)
+    order/
+      order.service.ts
+      order.repository.ts
+      order.types.ts
+      index.ts
+```
+
+## Barrel Exports
+
+```typescript
+// modules/user/index.ts — 공개 인터페이스만 노출
+export { UserService } from './user.service';
+export type { User, CreateUserDto } from './user.types';
+// user.repository.ts는 내부 구현이므로 export하지 않음
+
+// 외부에서 사용
+import { UserService, type User } from '@/modules/user';
+```
+
+## Circular Dependency Prevention
+
+```typescript
+// Bad: A -> B -> A 순환 참조
+// user.service.ts imports order.service.ts
+// order.service.ts imports user.service.ts
+
+// Good: 공통 인터페이스 추출
+// shared/types.ts
+export interface IUserLookup {
+  findById(id: string): Promise<User | null>;
+}
+
+// order.service.ts — 인터페이스에 의존
+class OrderService {
+  constructor(private userLookup: IUserLookup) {}
+}
+```
+
+## Rules
+
+| Rule | Description |
+|------|-------------|
+| 파일 300줄 제한 | 초과 시 분리 검토 |
+| 모듈 간 직접 import 금지 | barrel export(index.ts)를 통해서만 접근 |
+| 상위 레이어 import 금지 | domain -> infra 방향 import 불가 |
+| 공유 타입은 shared/ | 두 모듈 이상에서 사용되면 shared로 이동 |

package/templates/base/skills/coding/rules/error-handling.md

@@ -0,0 +1,76 @@
+---
+title: Error Handling Patterns
+impact: HIGH
+tags: coding, error-handling, resilience
+---
+
+# Error Handling Patterns
+
+## Custom Error Classes
+
+```typescript
+class AppError extends Error {
+  constructor(
+    public readonly code: string,
+    message: string,
+    public readonly statusCode: number = 500,
+    public readonly cause?: Error,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}
+
+class NotFoundError extends AppError {
+  constructor(code: string, message: string) {
+    super(code, message, 404);
+  }
+}
+
+class ValidationError extends AppError {
+  constructor(code: string, message: string, public readonly fields: string[]) {
+    super(code, message, 400);
+  }
+}
+```
+
+## Never Swallow Errors
+
+```typescript
+// Bad: 에러 무시 — 디버깅 불가
+try { await save(data); } catch {}
+
+// Bad: 원인 손실
+try { await save(data); } catch { throw new Error('save failed'); }
+
+// Good: 원인 체이닝
+try { await save(data); } catch (err) {
+  throw new AppError('SAVE_FAILED', 'Data save failed', 500, err as Error);
+}
+```
+
+## Error Boundaries (React)
+
+```typescript
+class ErrorBoundary extends React.Component<Props, { error?: Error }> {
+  static getDerivedStateFromError(error: Error) {
+    return { error };
+  }
+  componentDidCatch(error: Error, info: React.ErrorInfo) {
+    logger.error('UI Error', { error, componentStack: info.componentStack });
+  }
+  render() {
+    if (this.state.error) return this.props.fallback;
+    return this.props.children;
+  }
+}
+```
+
+## Rules
+
+| Rule | Description |
+|------|-------------|
+| 에러 로깅 필수 | catch 블록에서 최소 로깅 또는 re-throw |
+| 사용자 메시지 분리 | 내부 에러와 사용자 노출 메시지를 분리 |
+| 에러 코드 사용 | 문자열 비교 대신 enum/const 에러 코드 |
+| cause 체이닝 | 원본 에러를 cause로 보존 |

package/templates/base/skills/coding/rules/type-safety.md

@@ -0,0 +1,85 @@
+---
+title: TypeScript Type Safety
+impact: HIGH
+tags: coding, typescript, type-safety
+---
+
+# TypeScript Type Safety
+
+## Strict Mode
+
+```jsonc
+// tsconfig.json — 최소 필수 설정
+{
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true
+  }
+}
+```
+
+## Avoid `any`
+
+```typescript
+// Bad: any는 타입 검사를 무력화
+function process(data: any) { return data.name; }
+
+// Good: 제네릭 또는 unknown 사용
+function process<T extends { name: string }>(data: T) { return data.name; }
+
+// Good: unknown + 타입 가드
+function process(data: unknown): string {
+  if (typeof data === 'object' && data !== null && 'name' in data) {
+    return (data as { name: string }).name;
+  }
+  throw new Error('Invalid data');
+}
+```
+
+## Discriminated Unions
+
+```typescript
+// 상태별 안전한 분기 처리
+type Result<T> =
+  | { status: 'success'; data: T }
+  | { status: 'error'; error: AppError }
+  | { status: 'loading' };
+
+function handle(result: Result<User>) {
+  switch (result.status) {
+    case 'success': return render(result.data);  // data 타입 보장
+    case 'error':   return showError(result.error);
+    case 'loading': return showSpinner();
+  }
+  // exhaustiveness check: 누락된 case가 있으면 컴파일 에러
+  const _exhaustive: never = result;
+}
+```
+
+## Branded Types
+
+```typescript
+// 같은 string이지만 혼용 방지
+type UserId = string & { readonly __brand: 'UserId' };
+type OrderId = string & { readonly __brand: 'OrderId' };
+
+function createUserId(id: string): UserId { return id as UserId; }
+function createOrderId(id: string): OrderId { return id as OrderId; }
+
+function getUser(id: UserId) { /* ... */ }
+
+const userId = createUserId('u-123');
+const orderId = createOrderId('o-456');
+getUser(userId);   // OK
+// getUser(orderId); // Compile error
+```
+
+## Rules
+
+| Rule | Description |
+|------|-------------|
+| any 사용 금지 | eslint no-explicit-any 활성화 |
+| as 캐스팅 최소화 | 타입 가드 또는 제네릭으로 대체 |
+| union exhaustiveness | switch문에 never 체크 포함 |
+| optional vs undefined | 선택 속성과 undefined 값을 구분 |

package/templates/base/skills/controller/SKILL.md

@@ -6,106 +6,72 @@ description: |
   Use when: "구현해줘", "테스트해줘", "리뷰해줘", "설계해줘", 서브에이전트 위임
 version: "1.0.0"
 tags: [controller, di, context-injection]
+depends_on: [tsq-protocol]
+conflicts_with: []
 user-invocable: false
 ---
 
 # Controller (Context DI Container)
 
-서브에이전트에게 작업을 위임할 때 필요한 컨텍스트를 자동으로 해석하고 주입하는 컨테이너.
-에이전트가 "스스로 찾아 읽기"가 아닌 "주입받아 바로 시작"하도록 보장.
+서브에이전트에게 작업을 위임할 때 컨텍스트를 자동 해석하고 주입하는 컨테이너.
 
-## Delegation Process
+## Philosophy
 
-서브에이전트 위임 시 반드시 이 순서를 따른다:
+- "스스로 찾기"가 아닌 "주입받아 바로 시작"
+- 태스크에 관련된 섹션만 선별 주입 (전체 주입 지양)
+- spec 신선도는 controller가 판단
 
-1. **에이전트 파일 확인**: `.claude/agents/{agent}.md` 읽기
-2. **Prerequisites 파싱**: `<prerequisites>` 태그에서 필요 SSOT 목록 추출
-3. **Spec Resolve**: `controller/references/`에서 해당 compiled spec 로드
-4. **Phase 제약 로드**: `controller/rules/`에서 현재 phase 제약 확인
-5. **Stale 체크**: `.compile-manifest.json`의 hash와 현재 SSOT hash 비교
-6. **프롬프트 조합**: tsq-protocol + resolved specs + phase 제약 + 태스크 지시
-7. **Task() 호출**: 조합된 프롬프트로 서브에이전트 실행
+## Contract
 
-## Spec Resolution
+- **Trigger**: 서브에이전트 위임 시 (구현, 테스트, 리뷰 등)
+- **Input**: 에이전트 파일 + prerequisites + compiled specs
+- **Output**: 조합된 프롬프트로 Task() 실행
+- **Error**: spec stale 시 `tsq compile` 재실행 안내
+- **Dependencies**: tsq-protocol
 
-```
-에이전트 prerequisites         →  controller references/
-─────────────────────────────────────────────────────────
-service-spec.md               →  references/*.spec.md (endpoint별)
-data-design.md                →  references/*.spec.md (entity별)
-error-codes.md                →  references/error-codes.spec.md
-```
+## Protocol
 
-필요한 spec 전체가 아닌 **태스크에 관련된 섹션만** 주입한다.
-예: "로그인 API 구현" → `references/2-1-로그인.spec.md`만 주입.
+1. **Memory 참조**: `memory/` 디렉토리의 모든 .md 파일을 Read (프로젝트 결정사항)
+2. **SSOT Map 참조**: `.timsquad/ssot-map.yaml` 읽기 → 현재 작업 단위(phase/sequence/task) 판단 → 해당 티어 compiled spec 목록 확인
+3. **에이전트 파일 확인**: `.claude/agents/{agent}.md` 읽기
+4. **Prerequisites 파싱**: `<prerequisites>` 태그에서 SSOT 목록 추출
+5. **Spec Resolve**: `references/`에서 해당 compiled spec + SSOT Map 티어 문서 로드
+6. **Stale 체크**: `.compile-manifest.json` hash 비교
+7. **방법론 참조**: `config.yaml`의 `methodology.development` 확인 → 해당 methodology 스킬 Protocol 로드
+8. **프롬프트 조합**: tsq-protocol + memory + specs + methodology + phase 제약 + 지시
+9. **Task() 호출**: 조합된 프롬프트로 서브에이전트 실행
+10. **트리거 확인**: 완료 시 `triggers/` 해당 상황 규칙 참조 (task-complete, sequence-complete 등)
 
-## Stale Detection
+## Verification
 
-Spec 주입 전 `.compile-manifest.json`을 확인한다:
+| Check | Command | Pass Criteria |
+|-------|---------|---------------|
+| Stale 체크 | `.compile-manifest.json` hash | 일치 |
+| Prerequisites | 에이전트 파일 파싱 | 모든 spec 존재 |
+| Task 사용 | 위임 방식 확인 | Task() 사용 (TeamCreate 금지) |
+| Phase 제약 | 프롬프트 포함 확인 | 현재 phase 제약 포함 |
 
-- hash 일치 → 최신. 주입 진행.
-- hash 불일치 → 사용자에게 `tsq compile` 재실행을 제안.
-- manifest 없음 → 사용자에게 `tsq compile` 최초 실행을 안내.
+## Quick Rules
 
-## Task Prompt Template
+### Spec Resolution
+- 에이전트 prerequisites → `references/*.spec.md`로 매핑
+- 태스크 관련 섹션만 주입 (예: "로그인 API" → 로그인 spec만)
 
-```
-[MODE: {phase}] [TASK: {task_id}] [SPEC: {primary_spec}]
+### Delegation
+- **지원**: Task() — 순차 호출, 도구 실행 가능
+- **금지**: TeamCreate — SDK 제한으로 도구 실행 불가
+- **역할별 규칙**: `delegation/` 디렉토리 참조 (developer, reviewer, librarian)
 
-[tsq-protocol 기본 규칙]
+### Triggers
+상황별 행동 규칙은 `triggers/` 디렉토리 참조:
+- `task-complete.md` — 태스크 완료 시 테스트 게이트 + L1
+- `sequence-complete.md` — 시퀀스 완료 시 통합테스트 + L2
+- `phase-complete.md` — 페이즈 완료 시 e2e + L3 + Librarian
+- `ssot-changed.md` — SSOT 변경 시 재컴파일 확인
 
-[현재 Phase 제약]
-- 허용: {allowed_actions}
-- 금지: {forbidden_actions}
+### Mode Declaration
+서브에이전트 매 응답 첫 줄: `[MODE: {phase}] [TASK: {id}] [SPEC: {file}]`
 
-[Compiled Spec]
-{injected_spec_content}
-
-[태스크 지시]
-task_id: {task_id}
-description: {description}
-```
-
-## Mode Declaration
-
-서브에이전트는 **매 응답 첫 줄**에 모드 선언을 출력해야 한다:
-
-```
-[MODE: IMPLEMENTATION] [TASK: P3-S001-T001] [SPEC: 2-1-로그인.spec.md]
-```
-
-<mode-declaration>
-  <rules>
-    <must>응답 시작 시 [MODE: {phase}] [TASK: {task_id}] [SPEC: {spec}] 선언</must>
-    <must>phase는 current-phase.json 기준 (planning/design/implementation/review)</must>
-    <must>SPEC은 주입받은 primary spec 파일명</must>
-  </rules>
-  <rationale>
-    컨텍스트 압축(compaction) 후에도 에이전트가 자신의 역할·제약·참조 spec을
-    매 응답마다 재확인한다. Rationalization Prevention의 자연스러운 확장.
-  </rationale>
-</mode-declaration>
-
-## Rationalization Prevention
-
-<rationalization-prevention>
-
-| 에이전트의 변명 | 현실 |
-|----------------|------|
-| "이 태스크는 간단해서 spec 없이 가능" | 간단함은 주관적. spec이 있으면 반드시 참조 |
-| "spec이 오래된 것 같아서 직접 판단" | spec 신선도는 controller가 판단. 주입받은 spec을 따를 것 |
-| "이미 비슷한 코드가 있으니 참고만 하면 됨" | 기존 코드가 spec과 일치하는지 알 수 없음. spec 기준 |
-| "테스트는 나중에 한번에 돌리는 게 효율적" | 각 태스크 완료 시 테스트 통과가 완료 조건 |
-| "사용자가 빨리 해달라고 했으니 절차 생략" | 절차는 품질 보장. 절차를 따르는 것이 결과적으로 빠름 |
-
-</rationalization-prevention>
-
-## Checklist
-
-| Priority | Item |
-|----------|------|
-| CRITICAL | 서브에이전트 위임 전 spec resolve 완료 |
-| CRITICAL | compiled spec의 stale 여부 확인 |
-| HIGH | phase 제약이 프롬프트에 포함됨 |
-| HIGH | tsq-protocol이 프롬프트에 포함됨 |
-| MEDIUM | 태스크에 관련된 섹션만 선별 주입 (전체 주입 지양) |
+### P3 Workflow
+Developer(구현+테스트) → vitest → QA(L1 피드백) → L2 자동 생성.
+QA 진입: developer completed + tests pass + build success.

package/templates/base/skills/controller/delegation/developer.md

@@ -0,0 +1,25 @@
+# Developer 위임 규칙
+
+## 역할
+
+코드 구현 + 단위 테스트 작성 전담.
+
+## 위임 시 포함 사항
+
+1. **SSOT Map 티어 문서**: 현재 작업 단위에 맞는 compiled spec
+2. **방법론 제약**: config.methodology.development에 따라:
+   - TDD: "테스트를 먼저 작성하고, 실패를 확인한 후 구현하라"
+   - BDD: "Gherkin 시나리오를 먼저 정의하고 구현하라"
+   - None: 방법론 제약 없음
+3. **Phase 제약**: 현재 Phase에서 허용되는 작업 범위
+4. **tsq-protocol**: TimSquad 프로세스 규칙
+
+## 도구 권한
+
+Read, Edit, Write, Bash (전체)
+
+## 완료 조건
+
+- 단위 테스트 작성 + 통과
+- `tsc --noEmit` 클린
+- 변경 파일 목록 핸드오프에 포함

package/templates/base/skills/controller/delegation/librarian.md

@@ -0,0 +1,33 @@
+# Librarian 위임 규칙
+
+## 역할
+
+Phase 종합 기록 전담. 문서 작성/갱신만 수행하고 소스 코드를 수정하지 않는다.
+
+## 호출 조건
+
+- Phase 내 모든 시퀀스 completed
+- L3 로그 생성 완료
+- Phase Gate PASS (또는 gate 미설정)
+
+## 위임 시 포함 사항
+
+1. **L1/L2/L3 로그**: `.timsquad/logs/` 하위 해당 Phase 로그 전체
+2. **SSOT 현재 상태**: `.compile-manifest.json` stale 목록
+3. **Phase 정보**: 완료된 Phase ID, 시퀀스 목록
+
+## 도구 권한
+
+Read, Write, Edit, Grep, Glob, Bash
+
+## 제약
+
+- **소스 코드(src/, lib/, app/) 수정 절대 금지**
+- .timsquad/ 및 docs/ 내 문서 작성·갱신만 허용
+- 기록, 분석, 리포트 작성만 수행
+
+## 출력
+
+1. Phase 종합 리포트 (`.timsquad/reports/{phase}-report.md`)
+2. SSOT stale 목록 보고
+3. 다음 Phase context note (`docs/sprint/` 하위)

package/templates/base/skills/controller/delegation/reviewer.md

@@ -0,0 +1,19 @@
+# Reviewer 위임 규칙
+
+## 역할
+
+코드 리뷰 + 교차 검증 전담. 읽기만 수행하고 코드를 수정하지 않는다.
+
+## 위임 시 포함 사항
+
+1. **변경 diff**: `git diff` 결과
+2. **6가지 관점**: 보안, 타입 안전성, 에러 핸들링, API 호환성, 테스트 커버리지, 성능
+3. **관련 spec**: 변경 파일과 관련된 SSOT compiled spec
+
+## 도구 권한
+
+Read, Grep, Glob, Bash (읽기 전용)
+
+## 출력 형식
+
+severity별 구조화된 리포트 (CRITICAL/HIGH/MEDIUM/LOW)

package/templates/base/skills/controller/triggers/phase-complete.md

@@ -0,0 +1,25 @@
+# Phase Complete Trigger
+
+Phase 내 모든 시퀀스 완료 시 controller가 수행하는 행동 규칙.
+
+## 행동
+
+1. **E2E 테스트**: `npm run test:e2e` 실행 확인
+2. **L3 로그**: 데몬이 L3 페이즈 로그를 자동 생성했는지 확인
+3. **Phase Gate**: `tsq log phase gate` 실행 → 전환 조건 확인
+4. **Librarian 호출**: Phase 종합 리포트 작성을 위해 Librarian 에이전트 호출
+5. **회고**: `tsq retro` 자동 실행 검토
+
+## Librarian 호출 조건
+
+- Phase 내 모든 시퀀스 completed
+- L3 로그 생성 완료
+- Phase Gate PASS
+
+## 호출 방법
+
+```
+Librarian에게 위임 (delegation/librarian.md 참조):
+- 입력: L1/L2/L3 로그, SSOT 현재 상태
+- 출력: Phase 종합 리포트, SSOT stale 보고, 다음 Phase context note
+```