timsquad 3.5.0 → 3.7.0

package/README.ko.md

@@ -24,7 +24,7 @@
 | 철학 | "Zero learning curve" | **"체계를 세우면 더 잘 된다"** |
 | 의사결정 | LLM이 알아서 | **개발자가 컨트롤** |
 | 우선순위 | 속도 | **품질 + 일관성** |
-| 반복 작업 | LLM이 처리 (토큰 소비) | **프로그램이 처리 (토큰 0)** |
+| 강제성 | 프롬프트만 (소프트) | **Hook Gate + Capability Token (하드)** |
 | 학습 | 없음 | **회고적 학습으로 지속 개선** |
 
 **For developers who want structure, not magic.**
@@ -66,39 +66,37 @@ tsq init -n my-app -t web-service -l 2 -y     # 비대화형
 
 ```
 my-app/
-├── CLAUDE.md                      # PM 역할 정의 (에이전트 지시사항)
+├── CLAUDE.md                      # PM 역할 (자동 주입 ~15줄)
 ├── .claude/
-│   ├── settings.json              # Claude Code 설정
-│   ├── rules/                     # 메인 세션 전용 규칙
-│   ├── agents/                    # 6개 전문 에이전트
-│   │   ├── tsq-architect.md       # 아키텍처 설계 (Sonnet)
-│   │   ├── tsq-developer.md       # 코드 구현 (Sonnet)
-│   │   ├── tsq-qa.md              # 검증/리뷰 (Sonnet)
-│   │   ├── tsq-security.md        # 보안 검토 (Sonnet)
-│   │   ├── tsq-dba.md             # DB 설계 (Sonnet)
-│   │   └── tsq-designer.md        # UI/UX 설계 (Sonnet)
-│   ├── skills/                    # 도메인별 스킬셋
+│   ├── settings.json              # Claude Code 설정 (8개 Hook)
+│   ├── rules/                     # 경로별 규칙 (15개)
+│   ├── agents/                    # 7개 전문 에이전트
+│   │   ├── tsq-architect.md       # 아키텍처 설계
+│   │   ├── tsq-developer.md       # 코드 구현
+│   │   ├── tsq-qa.md              # 검증/리뷰
+│   │   ├── tsq-security.md        # 보안 검토
+│   │   ├── tsq-dba.md             # DB 설계
+│   │   ├── tsq-designer.md        # UI/UX 설계
+│   │   └── tsq-librarian.md       # Phase 기록
+│   ├── skills/                    # tsq-* 스킬 (프로젝트 타입에 따라 선택)
 │   │   ├── tsq-protocol/          # 에이전트 공통 프로토콜
-│   │   ├── coding/                # 코딩 규칙 + rules/
-│   │   ├── testing/               # 테스트 전략 + references/
-│   │   ├── typescript/            # TypeScript 패턴 + rules/
-│   │   ├── frontend/(react|nextjs)/ # 프론트엔드 + Vercel 22개 룰
-│   │   ├── backend/node/          # Node.js 백엔드 + rules/
-│   │   ├── database/prisma/       # Prisma ORM + rules/
-│   │   ├── mobile/dart/             # Dart 언어 + rules/
-│   │   ├── mobile/flutter/          # Flutter 개발 + rules/ + refs/
-│   │   │   └── push-notifications/  # FCM + 로컬 알림 + 백그라운드
-│   │   ├── methodology/(tdd|bdd|ddd|debugging)/
-│   │   └── ...
+│   │   ├── tsq-controller/        # Context DI + 위임
+│   │   ├── tsq-coding/            # 코딩 규칙
+│   │   ├── tsq-testing/           # 테스트 전략
+│   │   ├── tsq-typescript/        # TypeScript 패턴
+│   │   ├── tsq-react/             # React (설정 시)
+│   │   ├── tsq-nextjs/            # Next.js + Vercel 룰
+│   │   ├── tsq-database/          # DB 설계
+│   │   ├── tsq-product-audit/     # 제품 감사 (7개 영역)
+│   │   ├── tsq-tdd/               # TDD 방법론
+│   │   └── ...                    # 기타 (설정에 따라)
 │   └── knowledge/                 # 에이전트 참조 지식
-│       ├── checklists/            # 보안, 접근성, SSOT 검증
-│       └── templates/             # 출력 형식 (task-result 등)
 └── .timsquad/
     ├── config.yaml                # 프로젝트 설정
     ├── ssot/                      # SSOT 문서 (레벨별 5~14개)
     ├── process/                   # 워크플로우 정의
-    ├── state/                     # 상태 관리 + Meta Index
-    ├── feedback/                  # 피드백 저장소
+    ├── state/                     # 상태 관리
+    ├── trails/                    # Phase 사고과정 아카이브
     ├── logs/                      # 3계층 로그 (L1→L2→L3)
     └── retrospective/             # 회고 데이터
 ```
@@ -108,25 +106,52 @@ my-app/
 ```bash
 claude                                    # Claude Code 실행
 
-# PM(CLAUDE.md)이 자동으로 작업을 분류하고 에이전트에 위임
-@tsq-architect "시스템 아키텍처 설계해줘"
+# 슬래시 커맨드로 모든 작업 수행
+/tsq-start                               # 파이프라인 시작 + 온보딩
+/tsq-status                              # 현재 상태 확인
+/tsq-grill                               # Sub-PRD 심층 인터뷰
+/tsq-decompose                           # Phase-Sequence-Task 계획 생성
+
+# PM(CLAUDE.md)이 controller를 통해 에이전트에 위임
 @tsq-developer "로그인 API 구현해줘"
 @tsq-qa "코드 리뷰해줘"
 ```
 
-### 4. CLI로 작업 관리
+### 4. CLI 명령어
 
 ```bash
-tsq status                        # 현재 상태 확인
-tsq q "버튼 색상 변경"              # Quick 모드 (간단한 작업)
-tsq f "결제 기능 추가"              # Full 모드 (SSOT 검증)
-tsq retro auto                    # 회고 자동 실행
+tsq init                          # 프로젝트 초기화
+tsq update                        # 스킬/에이전트 최신화
+tsq daemon start                  # 백그라운드 데몬 시작
 ```
 
+> 나머지 기능은 Claude Code 슬래시 커맨드로 전환되었습니다. [CLI 레퍼런스](docs/cli.md) 참조.
+
 ---
 
 ## 핵심 기능
 
+### 5-Layer 강제 아키텍처
+
+```
+Layer 1: Hook Gate (100% 강제)
+  └ PreToolUse 훅 + Capability Token — 시스템 레벨 차단
+
+Layer 2: Skill Protocol (90-95% 준수)
+  └ tsq-protocol + controller — 프로세스 안내
+  └ 에이전트별 스킬 skills: 필드로 프리로드
+
+Layer 3: CLAUDE.md (역할 정의만)
+  └ PM 역할 + 파이프라인 사전조건 (~15줄)
+
+Layer 4: 슬래시 커맨드 (명시적 프로세스)
+  └ /tsq-start, /tsq-status, /tsq-grill, /tsq-retro
+
+Layer 5: 감사 (비동기 사후 추적)
+  └ 데몬이 관찰 → 세션 로그, 메트릭
+  └ 데몬 장애 시 메인 파이프라인에 영향 없음
+```
+
 ### SSOT 문서 체계
 
 프로젝트 레벨에 따라 필수 문서가 자동 결정됩니다:
@@ -139,88 +164,60 @@ tsq retro auto                    # 회고 자동 실행
 
 ### 에이전트 시스템
 
-PM(CLAUDE.md)이 총괄하며 6개 전문 에이전트에 위임합니다. 각 에이전트는 XML 구조화된 프롬프트, 필수 스킬 주입, 3단계 피드백 라우팅을 갖추고 있습니다.
+7개 전문 에이전트 + Controller 기반 위임:
 
 | 에이전트 | 역할 |
 |----------|------|
-| `@tsq-architect` | 아키텍처 설계, ADR, 코드 구조 리뷰 |
+| `@tsq-architect` | 아키텍처 설계, ADR, 계획 검증 |
 | `@tsq-developer` | SSOT 기반 코드 구현, TDD |
 | `@tsq-qa` | 코드 리뷰, 테스트 검증, SSOT 적합성 |
 | `@tsq-security` | 보안 검증, OWASP, 취약점 분석 |
 | `@tsq-dba` | DB 설계, 쿼리 최적화, 마이그레이션 |
 | `@tsq-designer` | UI/UX 설계, 접근성, 디자인 토큰 |
+| `@tsq-librarian` | Phase 기록, 메모리 관리 |
 
-### 피드백 라우팅 (L1/L2/L3)
-
-피드백을 3단계로 자동 분류하고 적절한 액션을 실행합니다:
-
-```
-L1 (구현 수정) → Developer 자동 처리      → 승인 불필요
-L2 (설계 수정) → in_review 상태로 전환     → Phase Gate 차단
-L3 (기획 수정) → 사용자 승인 대기          → approve/reject 필수
-```
-
-> 상세: [docs/feedback-and-retrospective.md](docs/feedback-and-retrospective.md)
-
-### 회고적 학습
-
-작업 로그 → 패턴 분석 → 개선 제안 → 프롬프트/템플릿 업데이트. LLM 파인튜닝 대신 프롬프트/템플릿 개선으로 실용화합니다.
+### 35개 스킬 (슬래시 커맨드)
 
-```bash
-tsq retro auto              # 수집 → 분석 → 리포트 → 적용 (원클릭)
-tsq improve analyze          # 패턴 분석 + 개선 제안
-```
-
-> 상세: [docs/feedback-and-retrospective.md](docs/feedback-and-retrospective.md)
+모든 스킬은 `tsq-*` flat namespace로 통일되었으며 슬래시 커맨드로 사용:
 
-### 데몬 기반 자동화 파이프라인
-
-**모든 오케스트레이션은 토큰 비용 0** — 프로그램이 판단합니다:
+| 카테고리 | 스킬 |
+|----------|------|
+| **핵심** | `tsq-protocol`, `tsq-controller`, `tsq-start`, `tsq-status` |
+| **코딩** | `tsq-coding`, `tsq-testing`, `tsq-typescript`, `tsq-hono` |
+| **기획** | `tsq-planning`, `tsq-spec`, `tsq-grill`, `tsq-decompose` |
+| **프론트엔드** | `tsq-react`, `tsq-nextjs`, `tsq-ui` |
+| **백엔드** | `tsq-database`, `tsq-prisma`, `tsq-security` |
+| **모바일** | `tsq-dart`, `tsq-flutter` (+ 하위 스킬 6개) |
+| **품질** | `tsq-product-audit`, `tsq-audit`, `tsq-stability` |
+| **방법론** | `tsq-tdd`, `tsq-bdd`, `tsq-ddd`, `tsq-debugging` |
+| **운영** | `tsq-librarian`, `tsq-log`, `tsq-retro`, `tsq-prompt` |
+
+### 8개 Hook Gate
+
+| Hook | 스크립트 | 역할 | 전략 |
+|------|---------|------|------|
+| PreToolUse (Bash) | `safe-guard.sh` | 파괴적 명령 차단 | Fail-closed |
+| PreToolUse (Write\|Edit) | `phase-guard.sh` | Phase별 파일 접근 제한 | Fail-closed |
+| PreToolUse (Write\|Edit) | `check-capability.sh` | Capability Token 검증 | Fail-closed |
+| PreToolUse (Write\|Edit) | `change-scope-guard.sh` | 변경 범위 추적 | Fail-open |
+| Stop | `completion-guard.sh` | 테스트 + TDD + SSOT 확인 | Fail-closed |
+| Stop | `build-gate.sh` | TypeScript 빌드 에러 | Fail-closed |
+| PreCompact | `pre-compact.sh` | 컴팩션 전 상태 저장 | Fail-open |
+| SessionStart (compact) | `context-restore.sh` | 컨텍스트 복원 + SSOT 안내 | Fail-open |
+
+### 데몬 기반 자동화
+
+**관찰자 전용 데몬** — 토큰 비용 0:
 
 ```
-Claude Code 세션 → 데몬이 JSONL 실시간 감시
-  → L1 태스크 로그 자동 기록
-  → L2 시퀀스 로그 자동 집계
-  → L3 Phase 로그 자동 생성
-  → Phase Gate 자동 확인
-  → 메트릭 인메모리 누적 → 세션 끝 flush
-  → Meta Index 자동 업데이트
+Claude Code 세션 → 데몬이 IPC로 관찰
+  → L1 태스크 로그 기록 (SubagentStop 훅)
+  → Decision Log 누적 (decisions.jsonl)
+  → SSOT Drift 감지 (7일 초과 미갱신 경고)
+  → 세션 메트릭 추적
+  → 데몬 장애 시 파이프라인 차단 없음
 ```
 
-> 상세: [docs/token-efficiency.md](docs/token-efficiency.md)
-
-### Meta Index (코드 구조 인덱스)
-
-AST 기반 코드/UI 구조 자동 인덱싱 + 에이전트 semantic 데이터 병합:
-
-```bash
-tsq mi rebuild              # 전체 코드+UI 인덱스 구축
-tsq mi stats                # Health Score + UI Health
-```
-
-> 상세: [docs/meta-index-architecture.md](docs/meta-index-architecture.md)
-
----
-
-## CLI 명령어 요약
-
-| 명령어 | 설명 |
-|--------|------|
-| `tsq init` | 프로젝트 초기화 (대화형/비대화형) |
-| `tsq status` | 프로젝트 상태 확인 |
-| `tsq q "작업"` | Quick 모드 (간단한 작업) |
-| `tsq f "작업"` | Full 모드 (SSOT 검증) |
-| `tsq log` | 3계층 작업 로그 관리 (L1/L2/L3) |
-| `tsq feedback` | 피드백 분류 + 자동 액션 |
-| `tsq retro` | 회고 실행 (수동/자동) |
-| `tsq metrics` | 메트릭 수집/트렌드 |
-| `tsq mi` | Meta Index 관리 (rebuild/stats) |
-| `tsq knowledge` | Knowledge 파일 관리 |
-| `tsq wf` | 워크플로우 자동화 |
-| `tsq daemon` | 백그라운드 데몬 관리 |
-
-> 전체 CLI 레퍼런스: [docs/cli.md](docs/cli.md)
-
 ---
 
 ## 프로젝트 타입
@@ -232,6 +229,7 @@ tsq mi stats                # Health Score + UI Health
 | `api-backend` | API 서버, 마이크로서비스 |
 | `platform` | 프레임워크, SDK |
 | `fintech` | 거래소, 결제 (Level 3 강제) |
+| `mobile-app` | 크로스플랫폼 모바일 앱 |
 | `infra` | DevOps, 자동화 |
 
 ---
@@ -242,14 +240,12 @@ tsq mi stats                # Health Score + UI Health
 |------|------|
 | [PRD](docs/PRD.md) | 프레임워크 전체 기획 |
 | [Core Concepts](docs/core-concepts.md) | 분수 모델, SSOT, 에이전트/스킬 구조 |
-| [CLI Reference](docs/cli.md) | 전체 CLI 명령어 레퍼런스 |
-| [Authoring Guide](docs/authoring-guide.md) | 에이전트/스킬/Knowledge 작성 가이드 |
+| [CLI Reference](docs/cli.md) | CLI 명령어 레퍼런스 |
+| [File Structure](docs/file-structure.md) | 템플릿 + 초기화 후 구조 |
+| [Hook Execution Order](docs/hook-execution-order.md) | Hook 실행 순서, Fail 전략 |
 | [Log Architecture](docs/log-architecture.md) | 3계층 로그 체계 (L1→L2→L3) |
 | [Feedback & Retrospective](docs/feedback-and-retrospective.md) | 피드백 라우팅 + 회고적 학습 |
-| [Token Efficiency](docs/token-efficiency.md) | 토큰 효율성 설계 |
-| [Knowledge Architecture](docs/knowledge-architecture.md) | Knowledge 시스템 |
-| [Meta Index Architecture](docs/meta-index-architecture.md) | 코드/UI 구조 인덱스 |
-| [File Structure](docs/file-structure.md) | 템플릿 + 초기화 후 구조 |
+| [SDCA Architecture](docs/sdca-architecture.md) | 스킬 주도 컨트롤러 아키텍처 |
 
 ---
 

package/README.md

@@ -24,7 +24,7 @@ Optimized Role Definitions + Advanced Skills + Retrospective Learning = Continuo
 | Philosophy | "Zero learning curve" | **"Structure leads to better results"** |
 | Decision Making | LLM decides everything | **Developer stays in control** |
 | Priority | Speed | **Quality + Consistency** |
-| Repetitive Tasks | LLM handles (token cost) | **Program handles (zero tokens)** |
+| Enforcement | Prompt only (soft) | **Hook Gate + Capability Token (hard)** |
 | Learning | None | **Retrospective learning for continuous improvement** |
 
 **For developers who want structure, not magic.**
@@ -66,39 +66,37 @@ tsq init -n my-app -t web-service -l 2 -y     # Non-interactive
 
 ```
 my-app/
-├── CLAUDE.md                      # PM role definition (agent instructions)
+├── CLAUDE.md                      # PM role (auto-injected ~15 lines)
 ├── .claude/
-│   ├── settings.json              # Claude Code settings
-│   ├── rules/                     # Main session rules
-│   ├── agents/                    # 6 specialized agents
-│   │   ├── tsq-architect.md       # Architecture design (Sonnet)
-│   │   ├── tsq-developer.md       # Code implementation (Sonnet)
-│   │   ├── tsq-qa.md              # Verification/review (Sonnet)
-│   │   ├── tsq-security.md        # Security audit (Sonnet)
-│   │   ├── tsq-dba.md             # DB design (Sonnet)
-│   │   └── tsq-designer.md        # UI/UX design (Sonnet)
-│   ├── skills/                    # Domain-specific skillsets
+│   ├── settings.json              # Claude Code settings (8 hooks)
+│   ├── rules/                     # Path-specific rules (15)
+│   ├── agents/                    # 7 specialized agents
+│   │   ├── tsq-architect.md       # Architecture design
+│   │   ├── tsq-developer.md       # Code implementation
+│   │   ├── tsq-qa.md              # Verification/review
+│   │   ├── tsq-security.md        # Security audit
+│   │   ├── tsq-dba.md             # DB design
+│   │   ├── tsq-designer.md        # UI/UX design
+│   │   └── tsq-librarian.md       # Phase recording
+│   ├── skills/                    # tsq-* skills (selected by project type)
 │   │   ├── tsq-protocol/          # Shared agent protocol
-│   │   ├── coding/                # Coding rules + rules/
-│   │   ├── testing/               # Test strategies + references/
-│   │   ├── typescript/            # TypeScript patterns + rules/
-│   │   ├── frontend/(react|nextjs)/ # Frontend + 22 Vercel rules
-│   │   ├── backend/node/          # Node.js backend + rules/
-│   │   ├── database/prisma/       # Prisma ORM + rules/
-│   │   ├── mobile/dart/             # Dart language + rules/
-│   │   ├── mobile/flutter/          # Flutter dev + rules/ + refs/
-│   │   │   └── push-notifications/  # FCM + local + background
-│   │   ├── methodology/(tdd|bdd|ddd|debugging)/
-│   │   └── ...
+│   │   ├── tsq-controller/        # Context DI + delegation
+│   │   ├── tsq-coding/            # Coding rules
+│   │   ├── tsq-testing/           # Test strategies
+│   │   ├── tsq-typescript/        # TypeScript patterns
+│   │   ├── tsq-react/             # React (if configured)
+│   │   ├── tsq-nextjs/            # Next.js + Vercel rules
+│   │   ├── tsq-database/          # DB design
+│   │   ├── tsq-product-audit/     # Product audit (7 areas)
+│   │   ├── tsq-tdd/               # TDD methodology
+│   │   └── ...                    # Others (per config)
 │   └── knowledge/                 # Agent reference knowledge
-│       ├── checklists/            # Security, accessibility, SSOT validation
-│       └── templates/             # Output formats (task-result, etc.)
 └── .timsquad/
     ├── config.yaml                # Project configuration
     ├── ssot/                      # SSOT documents (5–14 per level)
     ├── process/                   # Workflow definitions
-    ├── state/                     # State management + Meta Index
-    ├── feedback/                  # Feedback store
+    ├── state/                     # State management
+    ├── trails/                    # Phase thinking archives
     ├── logs/                      # 3-tier logs (L1→L2→L3)
     └── retrospective/             # Retrospective data
 ```
@@ -108,25 +106,52 @@ my-app/
 ```bash
 claude                                    # Launch Claude Code
 
-# PM (CLAUDE.md) automatically classifies tasks and delegates to agents
-@tsq-architect "Design the system architecture"
+# Use slash commands for all operations
+/tsq-start                               # Start pipeline + onboarding
+/tsq-status                              # Check current status
+/tsq-grill                               # Deep interview for Sub-PRD
+/tsq-decompose                           # Generate Phase-Sequence-Task plan
+
+# PM (CLAUDE.md) delegates to agents via controller
 @tsq-developer "Implement the login API"
 @tsq-qa "Review the code"
 ```
 
-### 4. Manage Tasks via CLI
+### 4. CLI Commands
 
 ```bash
-tsq status                        # Check current status
-tsq q "change button color"       # Quick mode (simple tasks)
-tsq f "add payment feature"       # Full mode (SSOT validation)
-tsq retro auto                    # Run retrospective automatically
+tsq init                          # Initialize project
+tsq update                        # Update skills/agents to latest
+tsq daemon start                  # Start background daemon
 ```
 
+> All other operations use Claude Code slash commands. See [CLI Reference](docs/cli.en.md).
+
 ---
 
 ## Key Features
 
+### 5-Layer Enforcement Architecture
+
+```
+Layer 1: Hook Gate (100% enforced)
+  └ PreToolUse hooks + Capability Token — system-level blocking
+
+Layer 2: Skill Protocol (90-95% compliance)
+  └ tsq-protocol + controller — process guidance
+  └ Agent-specific skills preloaded via skills: field
+
+Layer 3: CLAUDE.md (role definition only)
+  └ PM role + pipeline prerequisites (~15 lines)
+
+Layer 4: Slash Commands (explicit process)
+  └ /tsq-start, /tsq-status, /tsq-grill, /tsq-retro
+
+Layer 5: Audit (async post-tracking)
+  └ Daemon observes → session logs, metrics
+  └ Daemon failure doesn't affect main pipeline
+```
+
 ### SSOT Document System
 
 Required documents are automatically determined by project level:
@@ -139,88 +164,60 @@ Required documents are automatically determined by project level:
 
 ### Agent System
 
-The PM (CLAUDE.md) orchestrates and delegates to 6 specialized agents. Each agent features XML-structured prompts, mandatory skill injection, and 3-tier feedback routing.
+7 specialized agents with Controller-based delegation:
 
 | Agent | Role |
 |-------|------|
-| `@tsq-architect` | Architecture design, ADR, code structure review |
+| `@tsq-architect` | Architecture design, ADR, plan review |
 | `@tsq-developer` | SSOT-driven code implementation, TDD |
 | `@tsq-qa` | Code review, test verification, SSOT compliance |
 | `@tsq-security` | Security audit, OWASP, vulnerability analysis |
 | `@tsq-dba` | DB design, query optimization, migrations |
 | `@tsq-designer` | UI/UX design, accessibility, design tokens |
+| `@tsq-librarian` | Phase recording, memory management |
 
-### Feedback Routing (L1/L2/L3)
+### 35 Skills (Slash Commands)
 
-Feedback is automatically classified into 3 tiers with appropriate actions:
+All skills use `tsq-*` flat namespace and are available as slash commands:
 
-```
-L1 (Implementation fix) → Developer auto-handles     → No approval needed
-L2 (Design change)      → Transitions to in_review   → Phase Gate blocks
-L3 (Planning change)    → Awaits user approval        → approve/reject required
-```
+| Category | Skills |
+|----------|--------|
+| **Core** | `tsq-protocol`, `tsq-controller`, `tsq-start`, `tsq-status` |
+| **Coding** | `tsq-coding`, `tsq-testing`, `tsq-typescript`, `tsq-hono` |
+| **Planning** | `tsq-planning`, `tsq-spec`, `tsq-grill`, `tsq-decompose` |
+| **Frontend** | `tsq-react`, `tsq-nextjs`, `tsq-ui` |
+| **Backend** | `tsq-database`, `tsq-prisma`, `tsq-security` |
+| **Mobile** | `tsq-dart`, `tsq-flutter` (+ 6 sub-skills) |
+| **Quality** | `tsq-product-audit`, `tsq-audit`, `tsq-stability` |
+| **Methodology** | `tsq-tdd`, `tsq-bdd`, `tsq-ddd`, `tsq-debugging` |
+| **Operations** | `tsq-librarian`, `tsq-log`, `tsq-retro`, `tsq-prompt` |
 
-> Details: [docs/feedback-and-retrospective.en.md](docs/feedback-and-retrospective.en.md)
+### 8 Hook Gates
 
-### Retrospective Learning
+| Hook | Script | Role | Strategy |
+|------|--------|------|----------|
+| PreToolUse (Bash) | `safe-guard.sh` | Block destructive commands | Fail-closed |
+| PreToolUse (Write\|Edit) | `phase-guard.sh` | Phase file restrictions | Fail-closed |
+| PreToolUse (Write\|Edit) | `check-capability.sh` | Capability Token verification | Fail-closed |
+| PreToolUse (Write\|Edit) | `change-scope-guard.sh` | Change scope tracking | Fail-open |
+| Stop | `completion-guard.sh` | Test + TDD + SSOT check | Fail-closed |
+| Stop | `build-gate.sh` | TypeScript build errors | Fail-closed |
+| PreCompact | `pre-compact.sh` | Save state before compact | Fail-open |
+| SessionStart (compact) | `context-restore.sh` | Restore context + SSOT readiness | Fail-open |
 
-Task logs → Pattern analysis → Improvement suggestions → Prompt/template updates. Instead of LLM fine-tuning, we improve through prompt/template refinement.
-
-```bash
-tsq retro auto              # Collect → Analyze → Report → Apply (one-click)
-tsq improve analyze          # Pattern analysis + improvement suggestions
-```
+### Daemon-Based Automation
 
-> Details: [docs/feedback-and-retrospective.en.md](docs/feedback-and-retrospective.en.md)
-
-### Daemon-Based Automation Pipeline
-
-**All orchestration at zero token cost** — the program decides:
+**Observer-only daemon** — no token cost:
 
 ```
-Claude Code session → Daemon watches JSONL in real-time
-  → L1 task logs recorded automatically
-  → L2 sequence logs aggregated automatically
-  → L3 phase logs generated automatically
-  → Phase Gate checked automatically
-  → Metrics accumulated in-memory → flushed at session end
-  → Meta Index updated automatically
-```
-
-> Details: [docs/token-efficiency.en.md](docs/token-efficiency.en.md)
-
-### Meta Index (Code Structure Index)
-
-AST-based code/UI structure auto-indexing + agent semantic data merging:
-
-```bash
-tsq mi rebuild              # Build full code+UI index
-tsq mi stats                # Health Score + UI Health
+Claude Code session → Daemon observes via IPC
+  → L1 task logs recorded (SubagentStop hook)
+  → Decision Log accumulated (decisions.jsonl)
+  → SSOT Drift detection (7-day stale warning)
+  → Session metrics tracked
+  → Daemon failure doesn't block pipeline
 ```
 
-> Details: [docs/meta-index-architecture.en.md](docs/meta-index-architecture.en.md)
-
----
-
-## CLI Commands
-
-| Command | Description |
-|---------|-------------|
-| `tsq init` | Initialize project (interactive/non-interactive) |
-| `tsq status` | Check project status |
-| `tsq q "task"` | Quick mode (simple tasks) |
-| `tsq f "task"` | Full mode (SSOT validation) |
-| `tsq log` | 3-tier task log management (L1/L2/L3) |
-| `tsq feedback` | Feedback classification + auto actions |
-| `tsq retro` | Run retrospective (manual/auto) |
-| `tsq metrics` | Metrics collection/trends |
-| `tsq mi` | Meta Index management (rebuild/stats) |
-| `tsq knowledge` | Knowledge file management |
-| `tsq wf` | Workflow automation |
-| `tsq daemon` | Background daemon management |
-
-> Full CLI reference: [docs/cli.en.md](docs/cli.en.md)
-
 ---
 
 ## Project Types
@@ -232,6 +229,7 @@ tsq mi stats                # Health Score + UI Health
 | `api-backend` | API servers, microservices |
 | `platform` | Frameworks, SDKs |
 | `fintech` | Exchanges, payments (Level 3 enforced) |
+| `mobile-app` | Cross-platform mobile apps |
 | `infra` | DevOps, automation |
 
 ---
@@ -242,14 +240,12 @@ tsq mi stats                # Health Score + UI Health
 |----------|-------------|
 | [PRD](docs/PRD.en.md) | Full framework specification |
 | [Core Concepts](docs/core-concepts.en.md) | Fountain model, SSOT, agent/skill architecture |
-| [CLI Reference](docs/cli.en.md) | Complete CLI command reference |
-| [Authoring Guide](docs/authoring-guide.en.md) | Agent/skill/knowledge authoring guide |
-| [Log Architecture](docs/log-architecture.en.md) | 3-tier log system (L1→L2→L3) |
-| [Feedback & Retrospective](docs/feedback-and-retrospective.en.md) | Feedback routing + retrospective learning |
-| [Token Efficiency](docs/token-efficiency.en.md) | Token efficiency design |
-| [Knowledge Architecture](docs/knowledge-architecture.en.md) | Knowledge system |
-| [Meta Index Architecture](docs/meta-index-architecture.en.md) | Code/UI structure index |
+| [CLI Reference](docs/cli.en.md) | CLI command reference |
 | [File Structure](docs/file-structure.en.md) | Templates + post-init structure |
+| [Hook Execution Order](docs/hook-execution-order.md) | Hook sequence, fail strategy |
+| [Log Architecture](docs/log-architecture.en.md) | 3-tier log system (L1→L2→L3) |
+| [Feedback & Retrospective](docs/feedback-and-retrospective.en.md) | Feedback routing + retrospective |
+| [SDCA Architecture](docs/sdca-architecture.md) | Skill-Driven Controller Architecture |
 
 ---
 

package/dist/commands/daemon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/commands/daemon.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwF5D"}
+{"version":3,"file":"daemon.d.ts","sourceRoot":"","sources":["../../src/commands/daemon.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAUpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAwF5D"}

package/dist/commands/daemon.js

@@ -8,6 +8,8 @@ import { colors, printHeader, printError, printSuccess, printKeyValue } from '..
 import { findProjectRoot } from '../lib/project.js';
 import { isDaemonRunning, killZombie } from '../daemon/index.js';
 import { queryDaemon } from '../daemon/meta-cache.js';
+import { loadSessionState } from '../daemon/session-state.js';
+import { loadWorkflowState } from '../lib/workflow-state.js';
 export function registerDaemonCommand(program) {
     const cmd = program
         .command('daemon')
@@ -200,13 +202,57 @@ async function showStatus() {
     printHeader('Daemon Status');
     if (!status.running) {
         console.log(colors.dim('  Not running'));
+        // Still show session state if available
+        const session = await loadSessionState(projectRoot);
+        if (session) {
+            console.log(colors.subheader('\n  Last Session'));
+            printKeyValue('  Session', session.sessionShort);
+            printKeyValue('  Started', session.startedAt);
+            printKeyValue('  Turns', String(session.turnCount));
+        }
         return;
     }
     printKeyValue('  PID', String(status.pid));
     printKeyValue('  Status', colors.success('running'));
-    // IPC로 상세 정보 조회
+    // Session state (file-based — always available)
+    const session = await loadSessionState(projectRoot);
+    if (session) {
+        const uptimeMs = Date.now() - new Date(session.startedAt).getTime();
+        const uptimeMin = Math.floor(uptimeMs / 60000);
+        const uptimeSec = Math.floor((uptimeMs % 60000) / 1000);
+        printKeyValue('  Uptime', `${uptimeMin}m ${uptimeSec}s`);
+        printKeyValue('  Session', session.sessionShort);
+        console.log(colors.subheader('\n  Session Metrics'));
+        printKeyValue('  Turns', String(session.turnCount));
+        printKeyValue('  Tool Uses', String(session.metrics.toolUses));
+        if (session.metrics.toolFailures > 0) {
+            printKeyValue('  Tool Failures', colors.error(String(session.metrics.toolFailures)));
+        }
+        printKeyValue('  Subagents', String(session.metrics.subagentCount));
+        printKeyValue('  Bash Commands', String(session.metrics.bashCommands));
+        printKeyValue('  TSQ Commands', String(session.metrics.tsqCommands));
+        if (session.metrics.tokenDataReceived) {
+            console.log(colors.subheader('\n  Token Usage'));
+            printKeyValue('  Input', session.metrics.tokenInput.toLocaleString());
+            printKeyValue('  Output', session.metrics.tokenOutput.toLocaleString());
+            printKeyValue('  Cache Create', session.metrics.tokenCacheCreate.toLocaleString());
+            printKeyValue('  Cache Read', session.metrics.tokenCacheRead.toLocaleString());
+        }
+    }
+    // Automation toggles
+    try {
+        const wfState = await loadWorkflowState(projectRoot);
+        console.log(colors.subheader('\n  Automation'));
+        for (const [key, val] of Object.entries(wfState.automation)) {
+            const icon = val ? colors.success('ON') : colors.dim('OFF');
+            console.log(`    ${key.padEnd(16)} ${icon}`);
+        }
+    }
+    catch { /* skip */ }
+    // IPC로 메타인덱스 정보 조회
     try {
         const info = await queryDaemon(projectRoot, 'status');
+        console.log(colors.subheader('\n  Meta Index'));
         if (info.mode) {
             printKeyValue('  Mode', info.mode);
         }
@@ -224,7 +270,7 @@ async function showStatus() {
         }
     }
     catch {
-        console.log(colors.dim('  (IPC not available)'));
+        console.log(colors.dim('\n  (IPC not available — meta index info unavailable)'));
     }
 }
 //# sourceMappingURL=daemon.js.map