timsquad 3.5.0 → 3.7.0

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

@@ -18,14 +18,32 @@ user-invocable: false
 - {핵심 원칙 2}
 - {핵심 원칙 3}
 
+## Contract
+
+- **Trigger**: {스킬 활성화 조건}
+- **Input**: {필요한 입력/컨텍스트}
+- **Output**: {보장하는 출력/결과}
+- **Error**: {실패 시 행동}
+- **Dependencies**: {관련 스킬 또는 "없음"}
+
+## Protocol
+
+1. {첫 번째 단계}
+2. {두 번째 단계}
+3. {세 번째 단계}
+
+## Verification
+
+| Check | Command | Pass Criteria |
+|-------|---------|---------------|
+| {항목} | `{실행 명령}` | exit code 0 |
+
 ## Resources
 
 | Priority | Type | Resource | Description |
 |----------|------|----------|-------------|
 | CRITICAL | rule | [{rule-name}](rules/{rule-name}.md) | {1줄 설명} |
-| HIGH | rule | [{rule-name}](rules/{rule-name}.md) | {1줄 설명} |
 | HIGH | ref | [{topic}](references/{topic}.md) | {1줄 설명} |
-| MEDIUM | script | [{script}](scripts/{script}.sh) | {1줄 설명} |
 
 ## Quick Rules
 
@@ -33,26 +51,22 @@ user-invocable: false
 - {규칙}
 - {규칙}
 
-### {카테고리 2}
-- {규칙}
-- {규칙}
-
-## Checklist
-
-| Priority | Item |
-|----------|------|
-| CRITICAL | {필수 확인 항목} |
-| HIGH | {중요 확인 항목} |
-| MEDIUM | {권장 확인 항목} |
-
 <!--
 스킬 작성 가이드:
 - SKILL.md는 120줄 이하 인덱스 (항상 로드됨 → 컨텍스트 절약)
-- 하위 디렉토리 3종:
-  - rules/   → "이렇게 해라/하지 마라" (Incorrect/Correct 패턴, impact 레벨)
+- 필수 섹션: Philosophy, Contract, Protocol, Verification, Quick Rules
+- 선택 섹션: Resources (rules/references/scripts 있을 때)
+- Checklist는 Verification으로 통합 (중복 제거)
+- 하위 디렉토리 4종:
+  - rules/      → "이렇게 해라/하지 마라" (Incorrect/Correct 패턴, impact 레벨)
   - references/ → "이것을 알아라" (심층 가이드, 외부 문서)
-  - scripts/   → "이것을 실행해라" (자동화, 검증, 생성)
+  - scripts/    → "이것을 실행해라" (자동화, 검증, 생성)
+  - memory/     → "프로젝트에서 결정된 것" (동적, 프로젝트 진행 중 축적)
 - rules/는 Read로 온디맨드 로드, scripts/는 Bash로 실행 (토큰 0)
+- memory/는 스킬 활성 시 Protocol 첫 단계에서 반드시 Read
+  - 프로젝트별 결정사항, 사용자 지시, 컨벤션 축적
+  - git 추적 가능 → 팀 공유
+  - 예: memory/conventions.md, memory/decisions.md
 - "Claude가 이미 아는 것"은 넣지 말 것 → 프로젝트 컨벤션만
 - description은 PRIMARY trigger — 1024자 이하
 - 참조 모델: vercel-react-best-practices (SKILL.md 인덱스 + 45 rules 파일)

package/templates/base/skills/{architecture → tsq-architecture}/SKILL.md

@@ -1,11 +1,11 @@
 ---
-name: architecture
+name: tsq-architecture
 description: |
   아키텍처 설계 및 API 명세 가이드라인.
   Clean Architecture, RESTful API 설계, ADR, 데이터 모델링을 다룸.
   Use when: "아키텍처 설계, API 설계, ADR, 레이어 구조, 데이터 모델"
 version: "1.0.0"
-tags: [architecture, api, design]
+tags: [tsq, architecture, api, design]
 user-invocable: false
 ---
 

package/templates/base/skills/tsq-audit/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: tsq-audit
+description: |
+  코드 감사 스킬. 변경 파일 기반으로 관련 스킬 Verification 자동 실행 + 6관점 분석 + severity별 리포트.
+  자기감사(self-audit)와 교차리뷰(cross-review)를 통합.
+  Use when: `/tsq-audit` 호출 시, Phase gate 전 품질 확인 시, 코드 리뷰 요청 시, PR 리뷰 시.
+version: "2.0.0"
+tags: [tsq, audit, review, verification, quality, code-review]
+user-invocable: true
+context: fork
+allowed-tools: Read, Grep, Glob, Bash
+argument-hint: "[대상] — 변경 사항 감사/리뷰"
+---
+
+# Code Audit
+
+변경 파일 기반 감사를 수행하여 품질 게이트를 통과하도록 돕는다.
+별도 컨텍스트(fork)에서 실행하여 구현자와 독립된 판단을 보장한다.
+
+## Contract
+
+- **Trigger**: `/tsq-audit` 호출 또는 Phase gate 전 품질 확인
+- **Input**: 현재 변경 파일 목록 + 관련 스킬 Verification
+- **Output**: 스킬별 Verification 결과 + 6관점 severity별 리포트
+- **Error**: Verification 실패 시 해당 항목 + 수정 가이드 출력
+- **Dependencies**: coding, testing, security
+
+## Protocol
+
+1. **변경 수집**: `git diff --name-only` 또는 staged changes로 대상 수집
+2. **스킬 매칭**: 변경 파일 확장자/경로 기반으로 관련 스킬 자동 감지
+   - `.ts/.tsx` → coding, typescript 스킬
+   - `test` 포함 경로 → testing 스킬
+   - `security`, `auth`, `middleware` → security 스킬
+   - `.sh` 파일 → security 스킬 (shellcheck)
+   - `schema`, `migration` → database 스킬
+3. **Verification 실행**: 매칭된 각 스킬의 Verification 테이블에서 Command 실행
+4. **6관점 분석**: 변경 코드를 아래 관점에서 분석
+5. **리포트 생성**: severity별 구조화된 결과 출력
+
+## 6관점 분석
+
+| 관점 | 점검 항목 |
+|------|----------|
+| **보안** | OWASP Top 10, 시크릿 노출, injection, XSS |
+| **타입 안전성** | any 타입, 타입 단언(as), 미검증 캐스팅 |
+| **에러 핸들링** | catch 누락, 에러 무시, 불완전한 에러 처리 |
+| **API 호환성** | 기존 인터페이스 변경, breaking changes |
+| **테스트 커버리지** | 변경 코드의 테스트 존재 여부 |
+| **성능** | N+1 쿼리, 불필요한 리렌더링, 메모리 누수 |
+
+## Report Format
+
+```
+## Audit Report
+### CRITICAL (즉시 수정)
+- [CRITICAL] src/auth.ts:42 — SQL injection 가능성
+### HIGH (머지 전 수정)
+- [HIGH] src/api.ts:15 — 에러 핸들링 누락
+### MEDIUM (개선 권장)
+- [MEDIUM] src/utils.ts:8 — any 타입 사용
+### LOW (참고)
+- [LOW] src/config.ts:3 — 매직넘버 사용
+```
+
+## Verification
+
+| Check | Command | Pass Criteria |
+|-------|---------|---------------|
+| 변경 파일 감지 | `git diff --name-only` | 1개 이상 변경 파일 |
+| 스킬 Verification | 관련 스킬 체크 실행 | 모든 체크 통과 |
+| 6관점 커버리지 | 6가지 관점 체크 | 모든 관점 포함 |
+| severity 분류 | 구조화 리포트 | severity 태그 존재 |
+| 파일/라인 참조 | 코드 위치 명시 | 정확한 위치 참조 |

package/templates/base/skills/{methodology/bdd → tsq-bdd}/SKILL.md

@@ -1,10 +1,12 @@
 ---
-name: bdd
-description: Behavior-Driven Development 가이드라인
+name: tsq-bdd
+description: |
+  Behavior-Driven Development 가이드라인. Given-When-Then 시나리오, 비즈니스 언어 기반 명세.
+  Use when: BDD 방식 개발, Given-When-Then 시나리오 작성, Feature 파일 작성, 인수 테스트 설계 시.
 version: "1.0.0"
-tags: [bdd, methodology, testing]
+tags: [tsq, bdd, methodology, testing]
 user-invocable: false
-compatible-with: [tdd, ddd]
+compatible-with: [tsq-tdd, tsq-ddd]
 ---
 
 # BDD (Behavior-Driven Development)
@@ -59,11 +61,14 @@ Then [기대 결과]
 - UI 구현 세부사항 시나리오에 포함
 
 ## Checklist
-- [ ] Feature 파일이 비즈니스 언어로 작성됨
-- [ ] Given-When-Then 형식 준수
-- [ ] 시나리오가 독립적으로 실행 가능
-- [ ] Step Definition 재사용성 확보
-- [ ] Background로 공통 전제조건 추출
+
+| Priority | Item |
+|----------|------|
+| CRITICAL | Feature 파일이 비즈니스 언어로 작성됨 |
+| CRITICAL | Given-When-Then 형식 준수 |
+| HIGH | 시나리오가 독립적으로 실행 가능 |
+| HIGH | Step Definition 재사용성 확보 |
+| MEDIUM | Background로 공통 전제조건 추출 |
 
 ## 참조
 - `rules/gherkin-patterns.md` — Feature 파일, Step Definition, API BDD 예시, 디렉토리 구조

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

@@ -0,0 +1,65 @@
+---
+name: tsq-coding
+description: |
+  코드 작성 규칙 및 패턴 가이드라인.
+  네이밍 규칙, 함수 원칙, 에러 핸들링, 금지 패턴을 다룸.
+  Use when: "코드 작성, 구현, 리팩토링, 네이밍, 코딩 컨벤션"
+version: "1.0.0"
+tags: [tsq, coding, conventions, naming]
+user-invocable: false
+---
+
+# Coding Guidelines
+
+코드 작성 시 일관된 컨벤션과 패턴을 적용한다.
+
+## Philosophy
+
+- 단일 책임: 함수는 한 가지 일만 수행
+- 명확한 이름: 코드만 읽고도 동작을 파악 가능
+- 명시적 에러 처리: 에러를 삼키지 않는다
+
+## Contract
+
+- **Trigger**: 코드 작성/수정 태스크
+- **Input**: 구현 요구사항 + 기존 코드 컨텍스트
+- **Output**: 컨벤션 준수 코드
+- **Error**: 컨벤션 위반 시 수정 안내
+- **Dependencies**: 없음
+
+## Protocol
+
+1. **컨벤션 확인**: 네이밍, 파일 구조 규칙 확인
+2. **구현**: 단일 책임 원칙 준수하며 코드 작성
+3. **린트**: `tsc --noEmit` + 린트 검증
+4. **리뷰**: 금지 패턴(any, 매직넘버, console.log) 제거 확인
+
+## Verification
+
+| 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 사용)

package/templates/base/skills/tsq-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/tsq-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/tsq-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/tsq-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/tsq-controller/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: tsq-controller
+description: |
+  Context DI 컨테이너. 서브에이전트 위임 시 compiled spec을 의존성으로 주입.
+  서브에이전트 호출, Task() 위임, 에이전트 실행 시 자동 트리거.
+  Use when: "구현해줘", "테스트해줘", "리뷰해줘", "설계해줘", 서브에이전트 위임
+version: "2.1.0"
+tags: [tsq, controller, di, context-injection]
+user-invocable: false
+---
+
+# Controller (Context DI Container)
+
+서브에이전트에게 작업을 위임할 때 컨텍스트를 자동 해석하고 주입하는 컨테이너.
+
+## Contract
+
+- **Trigger**: 서브에이전트 위임 시 (구현, 테스트, 리뷰 등)
+- **Input**: 에이전트 파일 + prerequisites + compiled specs
+- **Output**: 조합된 프롬프트로 Task() 실행
+- **Error**: spec stale 시 `tsq compile` 재실행 안내
+
+## Protocol
+
+1. **Memory 참조**: `memory/` 디렉토리의 모든 .md 파일 Read
+2. **SSOT Map 참조**: `.timsquad/ssot-map.yaml` → 티어 compiled spec 목록 확인
+3. **Capability Token 발급**: `.timsquad/state/controller-active` + `allowed-paths.txt` 생성
+4. **에이전트 파일 확인**: `.claude/agents/{agent}.md` 읽기
+5. **Prerequisites 파싱**: `<prerequisites>` 태그에서 SSOT 목록 추출
+6. **Spec Resolve**: `references/`에서 해당 compiled spec 로드
+7. **Stale 체크**: `.compile-manifest.json` hash 비교
+8. **방법론 참조**: `config.yaml`의 `methodology.development` → 해당 스킬 Protocol 로드
+9. **프롬프트 조합**: tsq-protocol + **phase-memory carry-over** + memory + specs + methodology + phase 제약 + 지시
+   - `.timsquad/state/phase-memory.md` 존재 시 carry-over/주의 섹션을 프롬프트 앞에 강제 삽입
+   - 미존재 시 스킵 (초기 프로젝트)
+10. **Task() 호출**: 조합된 프롬프트로 서브에이전트 실행. 에이전트 파일의 `model` 필드가 있으면 Task()의 model 파라미터로 전달 (예: model: sonnet → 빠른 모델, model: opus → 정밀 모델)
+11. **Completion Report 검증**: 5개 필드(Task, Status, Files, Tests, Notes) 확인 — 누락 시 재요청
+12. **완료 트리거**: Triggers 섹션의 해당 규칙 수행
+13. **Capability Token 회수**: `controller-active` + `allowed-paths.txt` 삭제
+
+## Delegation Rules
+
+**Developer** — 코드 구현 + 단위 테스트. 도구: 전체. 완료: 테스트 통과 + `tsc --noEmit` 클린.
+**QA** (`tsq-qa.md`) — 코드 리뷰 (읽기 전용). 도구: Read, Grep, Glob, Bash. 출력: severity별 리포트.
+**Librarian** (`tsq-librarian.md`) — Phase 종합 기록 (소스 수정 금지). 도구: 전체 (src/ 제외). 호출 조건: Phase Gate PASS.
+**Architect** (`tsq-architect.md`) — 실행 계획 검증 (읽기 전용, fork 컨텍스트). 도구: Read, Grep, Glob. 출력: 커버리지/의존성/크기 검증 리포트.
+
+## Triggers
+
+동기(Controller) = 프로세스 강제, 게이트 판정. 비동기(Daemon) = 관찰, 로그 기록. Daemon 장애 시 Controller는 정상 동작.
+
+### task-complete (동기)
+1. **Completion Report 검증** — 5개 필드(Task, Status, Files, Tests, Notes) 확인, 누락 시 재요청
+2. **단위 테스트 확인** — Status=pass 필수, fail 시 Developer에 재위임
+3. **L1 로그 + Decision Log 확인** — Daemon이 L1 생성 (SubagentStop Hook). Daemon 장애 시 Controller가 수동 기록
+4. **workflow.json 갱신** — `.timsquad/state/workflow.json`에 완료된 task/sequence/phase 상태 기록 (compact 후 재개 시 진행 상태 복구용)
+5. **Sequence 완료 판정**: 해당 sequence의 expected_agents 모두 완료 → sequence-complete
+6. **미완료 시**: 다음 태스크 위임. planning.md의 해당 Task 산출물(출력 파일)이 이미 존재하면 스킵하고 그 다음 Task로 진행 (세션 재개 시 중복 작업 방지)
+
+### sequence-complete (동기)
+1. **통합 게이트**: `npm run test:integration` + `tsc --noEmit` — 실패 시 차단, Developer에 수정 위임
+2. **L2 로그 확인**: `.timsquad/logs/sequences/{seq-id}.md` 존재 확인
+3. **문서 갱신 체크**: ROADMAP/STATUS/CHANGELOG stale 여부 (7일 이상 미수정 시 경고)
+3.5. **Spec Compliance 체크**: 해당 Sequence의 Sub-PRD Must-Have 목록과 완료된 Task 산출물을 대조. 누락 항목이 있으면 경고 표시 (block 아님 — 다른 Sequence나 Phase에서 처리 가능). 경고 내용을 L2 로그에 기록
+4. **Phase 완료 판정**: 모든 시퀀스 완료 → phase-complete
+
+### phase-complete (동기)
+1. **E2E 게이트**: `npm run test:e2e` — 실패 시 차단
+2. **L3 로그 + Phase Gate 확인**: `.timsquad/logs/phases/{phase-id}.md` 존재
+3. **Librarian 호출**: Task(librarian) — Phase Memory 아카이브 + 새 HEAD 생성 + Trail + 리포트
+4. **사용자 안내**: "Phase {id} 완료. 다음 단계: (1) `/tsq-retro` — 회고 실행, (2) `/clear` — 컨텍스트 초기화 (phase-memory 자동 주입됩니다)"
+
+### ssot-changed (비동기, Daemon 전담)
+Daemon이 파일 감시로 `.compile-manifest.json` 갱신. 다음 Controller 실행 시 Stale 체크로 감지.
+
+## Mode Declaration
+서브에이전트 매 응답 첫 줄: `[MODE: {phase}] [TASK: {id}] [SPEC: {file}]`
+
+## P3 Workflow
+Developer(구현+테스트) → vitest → QA(L1 피드백) → L2 자동 생성.
+QA 진입: developer completed + tests pass + build success.

package/templates/base/skills/{mobile/dart → tsq-dart}/SKILL.md

@@ -1,8 +1,10 @@
 ---
-name: dart
-description: Dart 언어 가이드라인. Sound null safety, 패턴 매칭, sealed class, 비동기 프로그래밍, Effective Dart 스타일.
+name: tsq-dart
+description: |
+  Dart 언어 가이드라인. Sound null safety, 패턴 매칭, sealed class, 비동기 프로그래밍, Effective Dart 스타일.
+  Use when: Dart 코드 작성·수정, null safety 적용, 패턴 매칭 사용, .dart 파일 편집 시.
 version: "1.0.0"
-tags: [dart, language, null-safety, async]
+tags: [tsq, dart, language, null-safety, async]
 user-invocable: false
 ---