the-frame-ai 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,335 @@
+# THE Frame
+
+FRAME — Framework for AI-Assisted Solo Development
+
+[🇺🇸 English](README.md) | [🇪🇸 Español](README.es.md) | [🇷🇺 Русский](README.ru.md) | [🇨🇳 中文](README.zh.md) | [🇧🇷 Português](README.pt.md)
+
+## What is FRAME?
+
+**FRAME (Framework for AI-Assisted Solo Development)** is a framework for solo developers building products with Claude Code. It turns chaotic AI-assisted development into a predictable process — from idea to deploy — with memory, structure, and protection against mistakes.
+
+If you're building a product alone with Claude Code and want to work like a team — FRAME is for you.
+
+## What problems does FRAME solve?
+
+| Problem | What FRAME provides |
+|---------|-------------------|
+| Losing context between sessions | Project memory and automatic state dump on session start |
+| Chaos in tasks and priorities | 6-phase workflow: Research → Plan → Build → Review → Ship → Reflect |
+| Fear of breaking something important | Safety hooks block destructive commands before they run |
+| Repetitive routine tasks | 34 ready-made commands for the full development cycle |
+| Complex features with dependencies | Parallel subagents for independent tasks |
+| No structure for solo work | Roadmap, STATE.md, MAP.md — always know where you are and what's next |
+
+## How to work with FRAME
+
+```
+Research → Plan → Build → Review → Ship → Reflect
+```
+
+Each session is one cycle. Start with `/frame:daily`, end with `/frame:ship`.
+
+**Research** — understand before you build
+Run `/frame:research <topic>` — Claude explores the codebase, external sources, and builds context for the next step.
+
+**Plan** — break it into tasks
+`/frame:plan <feature>` turns research into a concrete task list with estimates.
+
+**Build** — implement
+`/frame:build` executes tasks sequentially (1–3 at a time) with TDD. For many independent tasks — `/frame:wave` runs them in parallel batches. Stuck — `/frame:unstuck`. Found a bug — `/frame:debug`.
+
+**Review** — check before deploying
+`/frame:review` runs automated checks and gives a checklist: tests, types, security, performance.
+
+**Ship** — deploy and record
+`/frame:ship` commits, optional push/PR, and updates project memory.
+
+**Reflect** — learn and improve
+`/frame:retrospective` after deploy updates metrics and captures patterns for future sessions.
+
+## Examples
+
+### New feature: add Google authentication
+
+```
+/frame:daily
+# → see current project status and what's planned
+
+/frame:research "Google OAuth"
+# → Claude studies the codebase: how current auth works,
+#   what patterns are already used, what needs to be added
+
+/frame:plan "Google OAuth"
+# → get a concrete task list:
+#   1. configure Google OAuth credentials
+#   2. add callback route
+#   3. connect to sessions
+#   4. add button to UI
+
+/frame:checkpoint
+# → save a restore point — if something goes wrong, you can roll back
+
+/frame:wave
+# → tasks 1–4 are independent, Claude runs them in parallel
+
+/frame:review
+# → automated checks: tests, types, security
+
+/frame:ship
+# → commit, optional push/PR, project memory updated
+```
+
+### Bug: users can't log in after password reset
+
+```
+/frame:daily
+# → restore context, see the bug is already in the plan or add it
+
+/frame:debug "login after reset"
+# → Claude systematically checks: logs, reset flow, sessions, tokens
+# → you get a hypothesis with a specific location in the code
+
+# If the cause is found immediately:
+/frame:checkpoint                        # restore point before the fix
+/frame:fast "fix: invalidate old session after password reset"
+# → Claude makes a targeted fix, writes a regression test
+
+# If the cause is unclear — go deeper:
+/frame:forensics
+# → analyzes git history of changes in this area,
+#   finds the commit that broke the behavior
+
+/frame:checkpoint
+/frame:fast "fix: ..."                   # fix the found cause
+
+/frame:review
+# → confirm the fix didn't break other login scenarios
+
+/frame:ship
+```
+
+### Improvement: speed up dashboard loading
+
+```
+/frame:daily
+
+/frame:performance
+# → get baseline: bundle size, load time, Lighthouse score
+#   remember the numbers — you'll need them for comparison at the end
+
+/frame:research "dashboard performance"
+# → Claude analyzes dashboard code: heavy components,
+#   redundant requests, what can be cached or lazy-loaded
+
+/frame:plan "dashboard optimization"
+# → task list with impact estimates:
+#   1. lazy load heavy charts
+#   2. cache API requests
+#   3. remove duplicate requests on mount
+
+/frame:build
+# → sequential, each task with a test
+
+/frame:performance
+# → compare with baseline: see the real improvement
+
+/frame:ship
+```
+
+## What's inside
+
+FRAME provides:
+
+- **6-phase workflow**: Research → Plan → Build → Review → Ship → Reflect
+- **34 commands**: from quick tasks to full feature development cycle
+- **5 AI agents**: Researcher, Planner, Builder, Reviewer, Devil's Advocate
+- **Safety Hooks**: block destructive operations, enforce quality gates
+- **Git Safety**: checkpoints, rollback, worktrees, pause/resume
+
+## Prerequisites
+
+- Node.js >= 18
+- Git (project must be a git repository)
+
+## Quick Start
+
+```bash
+# Initialize git repo if needed
+git init && git commit --allow-empty -m "init"
+
+# Install FRAME
+npx the-frame-ai init
+
+# Open Claude Code in this project and run:
+/frame:init    # scans codebase, fills MAP.md
+/frame:daily   # your entry point every day
+```
+
+## Commands
+
+### Core — start here
+
+These 7 commands cover 90% of solo dev work:
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:daily` | **Start here** after any break — what was done, what's next |
+| `/frame:research <topic>` | Before planning a new feature |
+| `/frame:plan <feature>` | Turn research into an actionable task list |
+| `/frame:build` | Implement 1–3 tasks with TDD (sequential) |
+| `/frame:wave` | Implement 4+ independent tasks (parallel subagents) |
+| `/frame:review` | Before deploying — automated checks + checklist |
+| `/frame:ship` | Commit, optional push/PR, update memory |
+
+### All Commands by Phase
+
+<details>
+<summary>Research</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:research <topic>` | Before planning a new feature |
+| `/frame:explain <file>` | Why does this code look like this? |
+| `/frame:why <topic>` | Search decision history |
+</details>
+
+<details>
+<summary>Plan</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:plan <feature>` | Turn research into an actionable task list |
+| `/frame:add-task` | Add a task to the plan without interrupting work |
+</details>
+
+<details>
+<summary>Build</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:build` | Implement plan with TDD (1–3 tasks, sequential) |
+| `/frame:wave` | Implement 4+ independent tasks in parallel batches |
+| `/frame:fast <task>` | Quick task under 30 minutes |
+| `/frame:debug <issue>` | Systematic bug investigation |
+| `/frame:forensics` | Deep dive into why something broke |
+| `/frame:refactor` | Refactor with TDD safety net |
+| `/frame:migrate` | DB/API/deps migration with rollback plan |
+</details>
+
+<details>
+<summary>Review</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:review` | Before deploying — automated checks + checklist |
+| `/frame:health` | Full project health check |
+| `/frame:check-deps` | Security audit + outdated packages |
+| `/frame:performance` | Bundle size and Lighthouse audit |
+</details>
+
+<details>
+<summary>Ship</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:ship` | Commit, optional push/PR, update memory |
+| `/frame:checkpoint` | Save a git tag before a risky change |
+| `/frame:rollback` | Roll back to a checkpoint |
+</details>
+
+<details>
+<summary>Reflect</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:retrospective` | After deploy — update memory and metrics |
+| `/frame:sprint-check` | Weekly progress vs roadmap |
+| `/frame:cleanup-memory` | Trim and archive stale memory |
+</details>
+
+<details>
+<summary>Daily & Utilities</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:daily` | Start of day — what was done, what's next |
+| `/frame:status` | Full state dump (git, memory, blockers) |
+| `/frame:note` | Capture a pattern, decision, or anti-pattern |
+| `/frame:unstuck` | Stuck? Get 3 concrete options to unblock |
+| `/frame:context` | Show current working context |
+| `/frame:init` | First run — scan codebase, fill MAP.md |
+| `/frame:doctor` | Verify FRAME installation |
+| `/frame:pause` / `/frame:resume` | Save and restore mid-task state |
+</details>
+
+<details>
+<summary>Advanced</summary>
+
+| Command | When to use |
+|---------|-------------|
+| `/frame:worktree` | Isolated git worktree for parallel experiments |
+| `/frame:headless` | Autonomous CI mode (no interaction) |
+| `/frame:estimate <task>` | Scope and time estimate before starting |
+</details>
+
+## Hooks
+
+FRAME installs 4 hooks into `.claude/hooks/`. They run automatically.
+
+| Hook | Trigger | What it does | To disable |
+|------|---------|--------------|------------|
+| `safety-net.sh` | Before Bash | Blocks `rm -rf` and `DROP TABLE/DATABASE` | Remove from `.claude/settings.local.json` |
+| `git-safety.sh` | Before Bash | Blocks force push, `reset --hard`, warns on `git add -A` | Remove from `.claude/settings.local.json` |
+| `quality-gate.sh` | After file write | Runs typecheck + lint on changed file | Remove from `.claude/settings.local.json` |
+| `session-init.sh` | Session start | Shows current phase/task; full context dump if away > 24h | Remove from `.claude/settings.local.json` |
+
+## Configuration
+
+FRAME is configured via `.frame/config.json`. Key settings:
+
+```json
+{
+  "quality": {
+    "commands": {
+      "typecheck": "npx tsc --noEmit",
+      "test": "npx vitest run",
+      "lint": "npx eslint .",
+      "build": "npm run build"
+    }
+  }
+}
+```
+
+## CLI
+
+```bash
+npx the-frame-ai init [target-dir]     # Install FRAME
+npx the-frame-ai update [target-dir]   # Update commands, agents, hooks
+npx the-frame-ai doctor [target-dir]   # Check installation health
+npx the-frame-ai version               # Show CLI version
+```
+
+`update` only updates commands, agents, and hooks. Project files (STATE.md, MAP.md, memory/, etc.) are never overwritten.
+
+## Project Structure (after installation)
+
+```
+.claude/
+  commands/          # 34 FRAME commands
+  agents/            # 5 AI agents
+  hooks/             # 4 safety hooks
+.frame/
+  config.json        # FRAME configuration
+.planning/
+  STATE.md           # Current position
+  MAP.md             # Project map
+  ROADMAP.md         # Roadmap
+  memory/            # Project memory
+  specs/             # Feature specs
+  reviews/           # Review results
+  reports/           # Reports (daily, deps, quality, sprint)
+```
+
+## License
+
+MIT

package/README.ru.md

@@ -0,0 +1,333 @@
+# THE Frame
+
+[🇺🇸 English](README.md) | [🇪🇸 Español](README.es.md) | [🇷🇺 Русский](README.ru.md) | [🇨🇳 中文](README.zh.md) | [🇧🇷 Português](README.pt.md)
+
+## Что такое THE FRAME?
+
+**FRAME (Framework for AI-Assisted Solo Development)** — это фреймворк для соло-разработчиков, которые строят продукты с помощью Claude Code. Он превращает хаотичную AI-разработку в предсказуемый процесс: от идеи до деплоя — с памятью, структурой и защитой от ошибок.
+
+Если ты один пишешь продукт с Claude Code и хочешь работать как команда — FRAME для тебя.
+
+## Какие задачи решает FRAME?
+
+| Задача | Что даёт FRAME |
+|--------|---------------|
+| Потеря контекста между сессиями | Память проекта и автоматический дамп состояния при старте |
+| Хаос в задачах и приоритетах | 6-фазный воркфлоу: Research → Plan → Build → Review → Ship → Reflect |
+| Страх сломать что-то важное | Safety-хуки блокируют деструктивные команды до их выполнения |
+| Долгие однотипные задачи | 34 готовые команды для всего цикла разработки |
+| Сложные фичи с зависимостями | Параллельные субагенты для независимых задач |
+| Нет структуры для соло-работы | Роадмап, STATE.md, MAP.md — всегда знаешь где ты и что дальше |
+
+## Как работать с FRAME
+
+```
+Research → Plan → Build → Review → Ship → Reflect
+```
+
+Каждая сессия — это один цикл. Начинаешь с `/frame:daily`, заканчиваешь с `/frame:ship`.
+
+**Research** — изучи перед тем как делать
+Запусти `/frame:research <тема>` — Claude исследует кодовую базу, внешние источники и формирует контекст для следующего шага.
+
+**Plan** — разбей на задачи
+`/frame:plan <фича>` превращает исследование в конкретный список задач с оценкой.
+
+**Build** — реализуй
+`/frame:build` выполняет задачи последовательно (1–3 за раз) с TDD. Если задач много и они независимы — `/frame:wave` запускает их параллельно пачками. Застрял — `/frame:unstuck`. Нашёл баг — `/frame:debug`.
+
+**Review** — проверь перед деплоем
+`/frame:review` запускает автоматические проверки и даёт чеклист: тесты, типы, безопасность, производительность.
+
+**Ship** — задеплой и зафиксируй
+`/frame:ship` делает коммит, опциональный push/PR и обновляет память проекта.
+
+**Reflect** — учись и улучшай
+`/frame:retrospective` после деплоя обновляет метрики и фиксирует паттерны для следующих сессий.
+
+## Примеры
+
+### Новая фича: добавить авторизацию через Google
+
+```
+/frame:daily
+# → видишь текущий статус проекта и что запланировано
+
+/frame:research "Google OAuth"
+# → Claude изучает кодовую базу: как устроена текущая авторизация,
+#   какие паттерны уже используются, что нужно добавить
+
+/frame:plan "Google OAuth"
+# → получаешь конкретный список задач:
+#   1. настроить Google OAuth credentials
+#   2. добавить callback-роут
+#   3. связать с сессиями
+#   4. добавить кнопку в UI
+
+/frame:checkpoint
+# → сохраняешь точку возврата — если что-то пойдёт не так, можно откатиться
+
+/frame:wave
+# → задачи 1–4 независимы, Claude выполняет их параллельно
+
+/frame:review
+# → автоматические проверки: тесты, типы, безопасность
+
+/frame:ship
+# → коммит, опциональный push/PR, память проекта обновлена
+```
+
+### Баг: пользователи не могут войти после сброса пароля
+
+```
+/frame:daily
+# → восстанавливаешь контекст, видишь что баг уже в плане или добавляешь его
+
+/frame:debug "login after reset"
+# → Claude систематически проверяет: логи, flow сброса пароля, сессии, токены
+# → в конце получаешь гипотезу с конкретным местом в коде
+
+# Если причина найдена сразу:
+/frame:checkpoint                        # точка возврата перед правкой
+/frame:fast "fix: invalidate old session after password reset"
+# → Claude вносит точечное исправление, пишет тест на регрессию
+
+# Если причина неочевидна — идёшь глубже:
+/frame:forensics
+# → анализирует git-историю изменений в этой области,
+#   находит коммит который сломал поведение
+
+/frame:checkpoint
+/frame:fast "fix: ..."                   # правишь найденную причину
+
+/frame:review
+# → убеждаешься что фикс не сломал другие сценарии входа
+
+/frame:ship
+```
+
+### Улучшение: ускорить загрузку дашборда
+
+```
+/frame:daily
+
+/frame:performance
+# → получаешь baseline: размер бандла, время загрузки, Lighthouse-score
+#   запомни цифры — они нужны для сравнения в конце
+
+/frame:research "dashboard performance"
+# → Claude анализирует код дашборда: тяжёлые компоненты,
+#   лишние запросы, что можно закэшировать или загрузить лениво
+
+/frame:plan "оптимизация дашборда"
+# → список задач с оценкой эффекта:
+#   1. lazy load тяжёлых графиков
+#   2. кэшировать API-запросы
+#   3. убрать дублирующиеся запросы при монтировании
+
+/frame:build
+# → последовательно, каждая задача с тестом
+
+/frame:performance
+# → сравниваешь с baseline: видишь реальный прирост
+
+/frame:ship
+```
+
+## Что внутри
+
+FRAME даёт:
+
+- **6-фазный воркфлоу**: Research → Plan → Build → Review → Ship → Reflect
+- **34 команды**: от быстрых задач до полного цикла разработки фичи
+- **5 AI-агентов**: Researcher, Planner, Builder, Reviewer, Devil's Advocate
+- **Safety Hooks**: блокируют деструктивные операции, запускают quality gates
+- **Git Safety**: чекпоинты, откат, worktrees, пауза/возобновление
+
+## Требования
+
+- Node.js >= 18
+- Git (проект должен быть git-репозиторием)
+
+## Быстрый старт
+
+```bash
+# Инициализировать git-репо если нужно
+git init && git commit --allow-empty -m "init"
+
+# Установить FRAME
+npx the-frame init
+
+# Открой Claude Code в этом проекте и введи:
+/frame:init    # сканирует кодовую базу, заполняет MAP.md
+/frame:daily   # твоя точка входа каждый день
+```
+
+## Команды
+
+### Ядро — начни здесь
+
+Эти 7 команд покрывают 90% работы соло-разработчика:
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:daily` | **Начни здесь** после любого перерыва — что сделано, что дальше |
+| `/frame:research <тема>` | Перед планированием новой фичи |
+| `/frame:plan <фича>` | Превратить исследование в список задач |
+| `/frame:build` | Реализовать 1–3 задачи с TDD (последовательно) |
+| `/frame:wave` | Реализовать 4+ независимых задачи (параллельные субагенты) |
+| `/frame:review` | Перед деплоем — автоматические проверки + чеклист |
+| `/frame:ship` | Коммит, опциональный push/PR, обновление памяти |
+
+### Все команды по фазам
+
+<details>
+<summary>Research</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:research <тема>` | Перед планированием новой фичи |
+| `/frame:explain <файл>` | Почему этот код выглядит именно так? |
+| `/frame:why <тема>` | Поиск по истории решений |
+</details>
+
+<details>
+<summary>Plan</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:plan <фича>` | Превратить исследование в список задач |
+| `/frame:add-task` | Добавить задачу в план без прерывания работы |
+| `/frame:wave` | Параллельное выполнение независимых задач |
+</details>
+
+<details>
+<summary>Build</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:build` | Реализовать план с TDD (1–3 задачи) |
+| `/frame:fast <задача>` | Быстрая задача до 30 минут |
+| `/frame:debug <проблема>` | Систематическое расследование бага |
+| `/frame:forensics` | Глубокий анализ причины поломки |
+| `/frame:refactor` | Рефакторинг с TDD-страховкой |
+| `/frame:migrate` | Миграция БД/API/зависимостей с планом отката |
+</details>
+
+<details>
+<summary>Review</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:review` | Перед деплоем — автоматические проверки + чеклист |
+| `/frame:health` | Полная проверка здоровья проекта |
+| `/frame:check-deps` | Аудит безопасности + устаревшие пакеты |
+| `/frame:performance` | Размер бандла и Lighthouse-аудит |
+</details>
+
+<details>
+<summary>Ship</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:ship` | Коммит, опциональный push/PR, обновление памяти |
+| `/frame:checkpoint` | Сохранить git-тег перед рискованным изменением |
+| `/frame:rollback` | Откатиться к чекпоинту |
+</details>
+
+<details>
+<summary>Reflect</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:retrospective` | После деплоя — обновить память и метрики |
+| `/frame:sprint-check` | Еженедельный прогресс vs роадмап |
+| `/frame:cleanup-memory` | Очистить и архивировать устаревшую память |
+</details>
+
+<details>
+<summary>Ежедневные и утилиты</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:daily` | Начало дня — что сделано, что дальше |
+| `/frame:status` | Полный дамп состояния (git, память, блокеры) |
+| `/frame:note` | Зафиксировать паттерн, решение или антипаттерн |
+| `/frame:unstuck` | Застрял? Получи 3 конкретных варианта разблокировки |
+| `/frame:context` | Показать текущий рабочий контекст |
+| `/frame:init` | Первый запуск — сканировать кодовую базу, заполнить MAP.md |
+| `/frame:doctor` | Проверить установку FRAME |
+| `/frame:pause` / `/frame:resume` | Сохранить и восстановить состояние на середине задачи |
+</details>
+
+<details>
+<summary>Продвинутые</summary>
+
+| Команда | Когда использовать |
+|---------|-------------------|
+| `/frame:worktree` | Изолированный git worktree для параллельных экспериментов |
+| `/frame:headless` | Автономный CI-режим (без взаимодействия) |
+| `/frame:estimate <задача>` | Оценка объёма и времени перед стартом |
+</details>
+
+## Хуки
+
+FRAME устанавливает 4 хука в `.claude/hooks/`. Запускаются автоматически.
+
+| Хук | Триггер | Что делает | Как отключить |
+|-----|---------|------------|---------------|
+| `safety-net.sh` | Before Bash | Блокирует `rm -rf` и `DROP TABLE/DATABASE` | Удалить из `.claude/settings.local.json` |
+| `git-safety.sh` | Before Bash | Блокирует force push, `reset --hard`, предупреждает о `git add -A` | Удалить из `.claude/settings.local.json` |
+| `quality-gate.sh` | After file write | Запускает typecheck + lint на изменённом файле | Удалить из `.claude/settings.local.json` |
+| `session-init.sh` | Session start | Показывает текущую фазу/задачу; полный дамп контекста если перерыв > 24ч | Удалить из `.claude/settings.local.json` |
+
+## Конфигурация
+
+FRAME настраивается через `.frame/config.json`. Ключевые настройки:
+
+```json
+{
+  "quality": {
+    "commands": {
+      "typecheck": "npx tsc --noEmit",
+      "test": "npx vitest run",
+      "lint": "npx eslint .",
+      "build": "npm run build"
+    }
+  }
+}
+```
+
+## CLI
+
+```bash
+npx the-frame init [целевая-папка]     # Установить FRAME
+npx the-frame update [целевая-папка]   # Обновить команды, агентов, хуки
+npx the-frame doctor [целевая-папка]   # Проверить здоровье установки
+npx the-frame version                  # Показать версию CLI
+```
+
+`update` обновляет только команды, агентов и хуки. Файлы проекта (STATE.md, MAP.md, memory/ и т.д.) никогда не перезаписываются.
+
+## Структура проекта (после установки)
+
+```
+.claude/
+  commands/          # 34 команды FRAME
+  agents/            # 5 AI-агентов
+  hooks/             # 4 safety-хука
+.frame/
+  config.json        # Конфигурация FRAME
+.planning/
+  STATE.md           # Текущая позиция
+  MAP.md             # Карта проекта
+  ROADMAP.md         # Роадмап
+  memory/            # Память проекта
+  specs/             # Спецификации фич
+  reviews/           # Результаты ревью
+  reports/           # Отчёты (daily, deps, quality, sprint)
+```
+
+## Лицензия
+
+MIT