ai-flow-dev 2.1.9 → 2.2.1

package/prompts/frontend/flow-build-phase-0.md

@@ -1,515 +1,412 @@
-# Phase 0: Context Discovery (Frontend)
+## PHASE 0: Context Discovery (2-5 min)
 
-**⚡ AUTOMATED ANALYSIS - Minimal User Input Required**
+> **Order for this phase:** ALWAYS executed FIRST if an existing project is detected. Skip ONLY for new projects.
 
-This phase automatically analyzes your existing frontend codebase to pre-populate answers for the build questionnaire.
----
-## 🎯 Objective
+> **📌 Scope-based behavior:**
+> - **Interactive Mode:** Ask user for permission to scan files layer by layer.
+> - **Autonomous Mode:** Scan all layers automatically and present the final report.
 
-Detect the current frontend stack, architecture patterns, and configuration from existing code to:
+### Objective
+Efficiently analyze existing projects using a **layered, incremental approach**.
 
-1. **Skip redundant questions** - Don't ask what can be detected
-2. **Validate assumptions** - Confirm detected patterns with user
-3. **Save time** - Reduce questionnaire from ~90 min to ~40 min
-4. **Maintain accuracy** - User can override any detection
----
-## 📋 Detection Layers (Progressive)
+---
 
-### Layer 0: Cache Check (0-2 seconds)
+## 🚫 Critical Exclusion Rules
+To avoid false-positive detections, **IGNORE** the following folders and files during all detection steps:
+- `.ai-flow/` (contains AI Flow internal cache and prompts)
+- `.agent/` (contains AI workflows)
+- `docs/` and `specs/` (if they contain AI Flow generated documentation)
+- `project-brief.md`, `ai-instructions.md`, `AGENT.md`
 
-Check if `.ai-flow/cache/frontend-context.json` exists and is fresh (<7 days old).
+**A project is considered "Existing" only if it contains functional source code or framework configuration files OUTSIDE these excluded paths.**
+
+---
+
+## 0.0 Check for Existing Analysis (Layer 0)
+
+Check if `.ai-flow/cache/docs-analysis.json` exists and is fresh.
 
 **If found:**
+Ask user to use cached analysis or re-analyze.
 
-```json
-{
-  "framework": "React",
-  "frameworkVersion": "18.2.0",
-  "buildTool": "Vite",
-  "typescript": true,
-  "stateManagement": "Zustand",
-  "styling": "Tailwind CSS",
-  "componentPattern": "Atomic Design",
-  "lastAnalyzed": "2025-01-20T10:30:00Z"
-}
-```
+**If not found:**
+Proceed to Layer 1.
 
-**Action:** Ask user: "Found cached analysis from X days ago. Use it? (Y/n)"
-
-**If yes:** Skip to validation step
-
-**If no or cache doesn't exist:** Proceed to Layer 1
----
-### Layer 1: Fast Metadata Scan (10-20 seconds)
-
-**Purpose:** Detect framework, build tool, package manager, TypeScript
-
-#### Files to Check
-
-1. **package.json** (REQUIRED)
-2. **vite.config._ / webpack.config._ / angular.json** (build tool)
-3. **tsconfig.json** (TypeScript)
-4. **tailwind.config._ / postcss.config._** (styling)
-
-#### Detection Logic
-
-```typescript
-// 1. Read package.json
-const pkg = JSON.parse(await fs.readFile('package.json', 'utf-8'));
-
-// 2. Detect UI Framework
-const framework = pkg.dependencies?.react
-  ? 'React'
-  : pkg.dependencies?.vue
-    ? 'Vue'
-    : pkg.dependencies?.['@angular/core']
-      ? 'Angular'
-      : pkg.dependencies?.svelte
-        ? 'Svelte'
-        : pkg.dependencies?.['solid-js']
-          ? 'Solid'
-          : null;
-
-// 3. Detect Meta-Framework
-const metaFramework = pkg.dependencies?.next
-  ? 'Next.js'
-  : pkg.dependencies?.nuxt
-    ? 'Nuxt'
-    : pkg.dependencies?.['@analogjs/platform']
-      ? 'Analog'
-      : pkg.dependencies?.['@sveltejs/kit']
-        ? 'SvelteKit'
-        : pkg.dependencies?.['solid-start']
-          ? 'Solid Start'
-          : null;
-
-// 4. Detect Build Tool
-const buildTool =
-  (await fs.exists('vite.config.ts')) || (await fs.exists('vite.config.js'))
-    ? 'Vite'
-    : (await fs.exists('webpack.config.js'))
-      ? 'Webpack'
-      : (await fs.exists('angular.json'))
-        ? 'Angular CLI'
-        : (await fs.exists('rollup.config.js'))
-          ? 'Rollup'
-          : metaFramework
-            ? `${metaFramework} (built-in)`
-            : 'Unknown';
-
-// 5. Detect TypeScript
-const typescript = await fs.exists('tsconfig.json');
-
-// 6. Detect State Management
-const stateManagement = pkg.dependencies?.zustand
-  ? 'Zustand'
-  : pkg.dependencies?.['@reduxjs/toolkit']
-    ? 'Redux Toolkit'
-    : pkg.dependencies?.pinia
-      ? 'Pinia'
-      : pkg.dependencies?.['@ngrx/store']
-        ? 'NgRx'
-        : pkg.dependencies?.xstate
-          ? 'XState'
-          : null;
-
-// 7. Detect Data Fetching
-const dataFetching =
-  pkg.dependencies?.['@tanstack/react-query'] || pkg.dependencies?.['@tanstack/vue-query']
-    ? 'TanStack Query'
-    : pkg.dependencies?.swr
-      ? 'SWR'
-      : pkg.dependencies?.['@apollo/client']
-        ? 'Apollo Client'
-        : pkg.dependencies?.['@urql/core']
-          ? 'urql'
-          : null;
-
-// 8. Detect Styling
-const styling =
-  pkg.devDependencies?.tailwindcss || pkg.dependencies?.tailwindcss
-    ? 'Tailwind CSS'
-    : pkg.dependencies?.['styled-components']
-      ? 'Styled Components'
-      : pkg.dependencies?.['@emotion/react']
-        ? 'Emotion'
-        : (await fs.exists('*.module.css'))
-          ? 'CSS Modules'
-          : pkg.dependencies?.sass || pkg.devDependencies?.sass
-            ? 'Sass/SCSS'
-            : null;
-
-// 9. Detect Component Library
-const componentLibrary = pkg.dependencies?.['@mui/material']
-  ? 'Material UI'
-  : pkg.dependencies?.['@chakra-ui/react']
-    ? 'Chakra UI'
-    : pkg.dependencies?.antd
-      ? 'Ant Design'
-      : pkg.dependencies?.vuetify
-        ? 'Vuetify'
-        : pkg.dependencies?.['@angular/material']
-          ? 'Angular Material'
-          : pkg.dependencies?.['@shadcn/ui']
-            ? 'shadcn/ui'
-            : null;
-
-// 10. Detect Testing
-const unitTest = pkg.devDependencies?.vitest
-  ? 'Vitest'
-  : pkg.devDependencies?.jest
-    ? 'Jest'
-    : pkg.devDependencies?.['@jest/core']
-      ? 'Jest'
-      : null;
-
-const e2eTest = pkg.devDependencies?.['@playwright/test']
-  ? 'Playwright'
-  : pkg.devDependencies?.cypress
-    ? 'Cypress'
-    : pkg.devDependencies?.puppeteer
-      ? 'Puppeteer'
-      : null;
-```
+---
 
-#### Layer 1 Output
+// turbo
+## ⚡ Layer 1: Fast Metadata Scan (10-20 seconds)
 
-```
-✅ DETECTED:
-
-Framework: React 18.2.0 (with Next.js 14.0.0)
-Build Tool: Vite 5.0.0
-TypeScript: Yes
-State Management: Zustand 4.4.0
-Data Fetching: TanStack Query 5.0.0
-Styling: Tailwind CSS 3.3.0
-Component Library: None
-Testing: Vitest + Playwright
-
-Continue to Layer 2 for structural analysis? (Y/n)
-```
----
-### Layer 2: Structural Analysis (30-90 seconds)
+**Purpose:** Detect framework, language, build tool, and existing AI configurations.
 
-**Purpose:** Analyze component structure, routing, and architecture patterns
+⭐ **Context Links:**
+- Node.js: [package.json](file:///package.json)
+- Python: [requirements.txt](file:///requirements.txt) | [pyproject.toml](file:///pyproject.toml)
+- PHP: [composer.json](file:///composer.json)
+- Go: [go.mod](file:///go.mod)
+- Java: [pom.xml](file:///pom.xml) | [build.gradle](file:///build.gradle)
 
-#### Files to Analyze
+### 0.1.1 Universal Tech Stack Detection
+**Action:** Use your internal knowledge to detect the language and framework by scanning the root configuration files (package.json, pyproject.toml, etc.).
 
-- **Component files:** `src/**/*.{jsx,tsx,vue,svelte}`
-- **Routes:** `src/routes/**`, `src/pages/**`, `app/**`
-- **Store files:** `src/store/**`, `src/state/**`
-- **Config files:** `src/config/**`
+**Detect (but don't be limited to):**
+- **Node.js:** NestJS, Express, Fastify, etc.
+- **Python:** FastAPI, Django, Flask, etc.
+- **PHP:** Laravel, Symfony, etc.
+- **Java/Kotlin:** Spring Boot, Micronaut, Ktor, etc.
+- **Go:** Gin, Echo, Fiber, etc.
+- **C#/.NET, Ruby, Rust, Elixir.**
 
-#### Detection Patterns
+### 0.1.2 Find AI & Documentation
+- Find existing AI configs (`AGENT.md`, `.cursorrules`, etc.)
+- Scan for `README.md` and existing `docs/`.
 
-```typescript
-// 1. Component Pattern Detection
-const componentPattern = detectComponentPattern(srcFiles);
+### Layer 1 Output
+Show a summary of detected Name, Language, Framework, ORM, and Documentation files.
 
-function detectComponentPattern(files: string[]): string {
-  const hasAtomic = files.some(
-    (f) => f.includes('/atoms/') || f.includes('/molecules/') || f.includes('/organisms/')
-  );
-  const hasFeatures = files.some((f) => f.includes('/features/'));
-  const hasDomains = files.some((f) => f.includes('/domains/'));
-  const hasPages = files.some((f) => f.includes('/pages/'));
+---
 
-  if (hasAtomic) return 'Atomic Design';
-  if (hasFeatures) return 'Feature-based';
-  if (hasDomains) return 'Domain-driven';
-  if (hasPages) return 'Pages-based';
-  return 'Flat';
-}
+## 0.2 Layer 2: Structural Analysis (30-90 seconds)
 
-// 2. Routing Strategy
-const routingStrategy = detectRouting(srcFiles);
+**Purpose:** Analyze directory organization and architecture patterns without reading code line-by-line.
 
-function detectRouting(files: string[]): string {
-  const hasAppDir = files.some((f) => f.startsWith('app/'));
-  const hasPagesDir = files.some((f) => f.startsWith('pages/'));
-  const hasSrcRoutes = files.some((f) => f.includes('/routes/'));
+### 0.2.1 Pattern Detection
+1. **Identify Pattern:** Feature-based, Layer-based, Modular Monolith, or Hybrid.
+2. **Entity Detection:** Scan for Schema/Entity files based on the detected ORM (Prisma, TypeORM, Django Models, etc.).
+3. **Maturity Check:** Assess documentation and test coverage ratio.
 
-  if (hasAppDir) return 'App Router (Next.js 13+)';
-  if (hasPagesDir) return 'Pages Router';
-  if (hasSrcRoutes) return 'File-based routing';
+### Layer 2 Output
+Summary of Architecture Pattern, Code Structure counts (Controllers, Services, etc.), and Recommended Build Scope (MVP/Production/Enterprise).
 
-  // Check for react-router/vue-router in code
-  const hasReactRouter = files.some((f) => {
-    const content = fs.readFileSync(f, 'utf-8');
-    return content.includes('react-router-dom');
-  });
+---
 
-  if (hasReactRouter) return 'React Router (code-based)';
-  return 'Unknown';
-}
+## 0.3 Layer 3: Selective Deep Analysis (1-5 minutes, OPTIONAL)
 
-// 3. API Integration Pattern
-const apiPattern = detectAPIPattern(srcFiles);
+**Purpose:** Read and parse representative code files for detailed insights into API endpoints, data relationships, and security patterns.
 
-function detectAPIPattern(files: string[]): string {
-  const hasApiDir = files.some((f) => f.includes('/api/'));
-  const hasServicesDir = files.some((f) => f.includes('/services/'));
-  const hasHooksDir = files.some((f) => f.includes('/hooks/use') && f.includes('query'));
+### 0.3.1 Areas of Analysis
+- **API Endpoints:** Parse routes/controllers.
+- **Data Model:** Map entity relationships.
+- **Security:** Detect auth patterns (JWT, OAuth), validation (Zod, Pydantic), and middleware.
 
-  if (hasHooksDir) return 'Custom hooks with TanStack Query';
-  if (hasServicesDir) return 'Service layer pattern';
-  if (hasApiDir) return 'API client pattern';
-  return 'Unknown';
-}
+### 0.3.2 Sampling Strategy
+Use stratified sampling to read only the most relevant files (e.g., core controllers and entities) to stay within context limits.
 
-// 4. Component Examples (Extract 2-3 representative components)
-const componentExamples = extractComponentExamples(srcFiles);
-
-function extractComponentExamples(files: string[]): Component[] {
-  // Find 2-3 well-structured components
-  const candidates = files.filter((f) => {
-    const content = fs.readFileSync(f, 'utf-8');
-    return content.includes('export') && content.length > 50 && content.length < 500;
-  });
-
-  return candidates.slice(0, 3).map((file) => ({
-    name: path.basename(file, path.extname(file)),
-    path: file,
-    snippet: fs.readFileSync(file, 'utf-8').slice(0, 200),
-  }));
-}
-```
+---
 
-#### Layer 2 Output
+## ✅ Validation & Synthesis
 
-```
-✅ ARCHITECTURE DETECTED:
+### Present Findings
+Show the final "🔍 BACKEND STACK DETECTED" report and ask for confirmation.
+
+### 💾 Cache & Pre-populate
+1. **Export:** Save results to `.ai-flow/cache/docs-analysis.json`.
+2. **Pre-populate:** Fill answers for Phases 1-7 based on detected data.
 
-Component Pattern: Atomic Design
-  - atoms/: 12 components
-  - molecules/: 23 components
-  - organisms/: 8 components
+---
 
-Routing: App Router (Next.js 13+)
-  - app/: 15 routes
-  - Dynamic routes: 5
+## 0.4 Layer 4: Documentation Audit (30-90s, CONDITIONAL)
 
-API Integration: Custom hooks with TanStack Query
-  - hooks/useQuery*.ts: 8 hooks
-  - services/api.ts: REST client
+**Trigger:** Only if `docs/` or `specs/` directories exist with content.
 
-Example Components:
-  1. atoms/Button.tsx (56 lines) - Reusable button with variants
-  2. molecules/UserCard.tsx (89 lines) - User card with avatar
-  3. organisms/ProductGrid.tsx (124 lines) - Product grid with pagination
+**Purpose:** Validate existing documentation against implemented code to detect inconsistencies.
+
+### 0.4.1 Ask User Permission
 
-Continue to Layer 3 for deep analysis? (Y/n)
 ```
----
-### Layer 3: Selective Deep Analysis (Optional, 60-120 seconds)
+📚 Existing documentation detected (12 files in docs/, 3 in specs/)
 
-**Purpose:** Extract advanced patterns, conventions, and documentation
+Would you like to audit documentation vs code?
+A) Yes, audit and show inconsistencies (recommended) ⭐
+B) No, skip audit (continue to Phase 1)
 
-**Only proceed if:**
+> _
+```
 
-- User confirms (not automatic)
-- Project is large (>50 components)
-- Accuracy is critical
+**If user selects B:** Skip to section 0.5 (Validation & Synthesis).
 
-#### Advanced Detection
+### 0.4.2 Parse Existing Documentation
 
-```typescript
-// 1. Naming Conventions
-const namingConvention = analyzeNamingPatterns(srcFiles);
+**Action:** Extract documented information from:
+- `docs/architecture.md` → Architecture patterns
+- `docs/data-model.md` → Entities and fields
+- `docs/api.md` → Endpoints and methods
+- `specs/requirements.md` → Business requirements
 
-function analyzeNamingPatterns(files: string[]): NamingConvention {
-  const componentNames = files.map((f) => path.basename(f, path.extname(f)));
+**Save to:** `.ai-flow/cache/docs-snapshot.json`
 
-  const pascalCase = componentNames.filter((n) => /^[A-Z][a-zA-Z0-9]*$/.test(n)).length;
-  const camelCase = componentNames.filter((n) => /^[a-z][a-zA-Z0-9]*$/.test(n)).length;
-  const kebabCase = componentNames.filter((n) => /^[a-z][a-z0-9-]*$/.test(n)).length;
+### 0.4.3 Compare Code vs Documentation
 
-  const dominant = Math.max(pascalCase, camelCase, kebabCase);
+**Compare:**
+1. **Entities:** Schema files (Prisma, TypeORM, etc.) vs `docs/data-model.md`
+2. **Endpoints:** Controllers/Routes vs `docs/api.md`
+3. **Architecture:** Code structure vs `docs/architecture.md`
+4. **Tech Stack:** `package.json` vs documented stack
 
-  return {
-    files: dominant === kebabCase ? 'kebab-case' : 'PascalCase',
-    components: dominant === pascalCase ? 'PascalCase' : 'camelCase',
-    hooks: files.some((f) => f.includes('use')) ? 'use* (hooks)' : 'N/A',
-  };
-}
+**Detect:**
+- Items in code but not in docs (undocumented features)
+- Items in docs but not in code (missing implementations or obsolete docs)
+- Mismatches in fields, types, or patterns
 
-// 2. Code Quality Patterns
-const qualityPatterns = analyzeQualityPatterns(srcFiles);
-
-function analyzeQualityPatterns(files: string[]): QualityPatterns {
-  let hasTypeScript = 0;
-  let hasPropTypes = 0;
-  let hasTests = 0;
-  let hasStories = 0;
-
-  files.forEach((file) => {
-    if (file.endsWith('.ts') || file.endsWith('.tsx')) hasTypeScript++;
-    const content = fs.readFileSync(file, 'utf-8');
-    if (content.includes('PropTypes')) hasPropTypes++;
-  });
-
-  const testFiles = files.filter((f) => f.includes('.test.') || f.includes('.spec.'));
-  hasTests = testFiles.length;
-
-  const storyFiles = files.filter((f) => f.includes('.stories.'));
-  hasStories = storyFiles.length;
-
-  return {
-    typeScriptCoverage: (hasTypeScript / files.length) * 100,
-    propTypesUsage: hasPropTypes > 0,
-    testCoverage: `${hasTests} test files`,
-    storybookUsage: hasStories > 0,
-  };
-}
+### 0.4.4 Classify Inconsistencies
 
-// 3. Accessibility Patterns
-const a11yPatterns = analyzeAccessibility(srcFiles);
+**Severity Levels:**
 
-function analyzeAccessibility(files: string[]): A11yPatterns {
-  let ariaUsage = 0;
-  let semanticHTML = 0;
+🔴 **CRITICAL** (Requires user decision):
+- Documented entity/endpoint not implemented
+- Major architectural mismatch
 
-  files.forEach((file) => {
-    const content = fs.readFileSync(file, 'utf-8');
-    if (content.includes('aria-')) ariaUsage++;
-    if (content.includes('<button') || content.includes('<nav') || content.includes('<header')) {
-      semanticHTML++;
-    }
-  });
+🟡 **MEDIUM** (Auto-correctable with confirmation):
+- Implemented endpoint not documented
+- Missing fields in docs
 
-  return {
-    ariaAttributesUsage: ariaUsage > files.length * 0.2 ? 'Frequent' : 'Rare',
-    semanticHTMLUsage: semanticHTML > files.length * 0.5 ? 'Good' : 'Needs improvement',
-  };
-}
-```
+🟢 **LOW** (Auto-correctable):
+- Obsolete fields in docs
+- Outdated version numbers
+
+### 0.4.5 Generate Audit Summary
 
-#### Layer 3 Output
+**Output:** Concise summary (full report saved for later).
 
 ```
-✅ DEEP ANALYSIS COMPLETE:
+---
+📊 Documentation Audit Summary
+
+Consistency Score: 72%
 
-Naming Conventions:
-  - Files: PascalCase
-  - Components: PascalCase
-  - Hooks: use* prefix
+🔴 Critical: 2 issues
+  - Entity 'Category' documented but not in schema
+  - Endpoint POST /api/auth/register documented but missing
 
-Code Quality:
-  - TypeScript: 95% coverage
-  - PropTypes: Not used (TypeScript instead)
-  - Tests: 48 test files (60% coverage)
-  - Storybook: Yes (23 stories)
+🟡 Medium: 5 issues
+  - 3 endpoints implemented but not documented
+  - 2 entity fields missing in docs
 
-Accessibility:
-  - ARIA attributes: Frequent usage
-  - Semantic HTML: Good usage
-  - Recommended: WCAG 2.1 AA compliance
+🟢 Minor: 3 issues
+  - 3 obsolete fields in documentation
 
-Analysis complete! Proceeding to validation...
+💡 Recommendation:
+  - Review critical issues before continuing
+  - Full audit report will be generated in Phase 8
+  - Auto-corrections can be applied after Phase 8
+---
 ```
----
-## ✅ Validation & Confirmation
 
-### Present Findings
+### 0.4.6 Handle Critical Issues (If Any)
 
-After detection, show user a summary and ask for confirmation:
+**If critical issues found:**
 
 ```
----
-🔍 FRONTEND STACK DETECTED
----
-✅ Framework: React 18.2.0 (with Next.js 14.0.0)
-✅ Build Tool: Vite 5.0.0
-✅ TypeScript: Yes
-✅ State Management: Zustand 4.4.0
-✅ Data Fetching: TanStack Query 5.0.0
-✅ Styling: Tailwind CSS 3.3.0
-✅ Component Pattern: Atomic Design
-✅ Testing: Vitest + Playwright
-✅ Routing: App Router (Next.js 13+)
-✅ Component Library: None
-
-Is this correct? (Y/n)
-```
+⚠️ Critical inconsistencies detected!
 
-### If User Says "Yes"
+How would you like to proceed?
+A) Continue to Phase 1 (address issues later in Phase 8) ⭐
+B) Review critical issues now (interactive)
+C) Cancel /flow-build (fix manually first)
 
+> _
 ```
-✅ Great! I'll use these detected values.
-
-I'll still ask you questions for:
-  - Business requirements (Phase 1)
-  - Specific conventions and preferences
-  - Performance targets
-  - Deployment strategy
 
-This will reduce the questionnaire from ~90 min to ~40 min.
+**Option A (Recommended):** Continue to Phase 1
+- Save audit data for Phase 8
+- Phase 8 will offer to apply corrections
 
-Proceed to Phase 1? (Y/n)
+**Option B:** Interactive review now
 ```
+🔴 Critical Issue 1/2: Entity 'Category'
+   Documented in docs/data-model.md but NOT in schema
 
-### If User Says "No" or Makes Corrections
+   What should we do?
+   A) Mark as "To Implement" (add to roadmap)
+   B) Mark as "Obsolete" (remove from docs in Phase 8)
+   C) Skip for now
 
+> _
 ```
-Please correct any incorrect detections:
 
-1. Framework: React 18.2.0 → (Enter new value or press Enter to keep)
-2. State Management: Zustand → (Enter new value or press Enter to keep)
-...
+**Option C:** Cancel
+- User fixes issues manually
+- Re-run `/flow-build` later
 
-(After corrections)
+### 0.4.7 Save Audit Data
 
-✅ Updated! Proceeding to Phase 1...
-```
----
-## 💾 Cache Storage
+> **📌 IMPORTANT - Phases 9-10 for Existing Projects:**
+> 
+> If the project has **substantial functional code already implemented** (detected in Layer 1-3):
+> - Set `phase9.recommendation = "SKIP"` with reason: "Project already implemented - roadmap not needed"
+> - Set `phase10.recommendation = "SKIP"` with reason: "Project already implemented - user stories not needed"
+> 
+> **Phases 9-10 are only useful for:**
+> - New projects (no code yet)
+> - Projects in early development (< 30% features implemented)
+> 
+> **For existing projects**, focus on Phases 1-8 (documentation sync) instead.
 
-Save detected context for future use:
+**Save to:** `.ai-flow/cache/audit-data.json`
 
-```typescript
-// .ai-flow/cache/frontend-context.json
+```json
 {
-  "framework": "React",
-  "frameworkVersion": "18.2.0",
-  "metaFramework": "Next.js",
-  "metaFrameworkVersion": "14.0.0",
-  "buildTool": "Vite",
-  "buildToolVersion": "5.0.0",
-  "typescript": true,
-  "stateManagement": "Zustand",
-  "dataFetching": "TanStack Query",
-  "styling": "Tailwind CSS",
-  "componentLibrary": null,
-  "componentPattern": "Atomic Design",
-  "routing": "App Router",
-  "unitTest": "Vitest",
-  "e2eTest": "Playwright",
-  "namingConvention": "PascalCase",
-  "testCoverage": 60,
-  "a11yCompliance": "WCAG 2.1 AA",
-  "lastAnalyzed": "2025-01-20T10:30:00Z",
-  "projectPath": "/Users/username/my-app"
+  "auditPerformed": true,
+  "timestamp": "2025-12-22T16:43:00Z",
+  "consistencyScore": 72,
+  "critical": 2,
+  "medium": 5,
+  "minor": 3,
+  "userDecisions": {
+    "Category": "obsolete",
+    "POST /api/auth/register": "to_implement"
+  },
+  "phases": {
+    "phase1": {
+      "file": "project-brief.md",
+      "exists": true,
+      "consistencyScore": 100,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "Complete business context documented"
+    },
+    "phase2": {
+      "file": "docs/data-model.md",
+      "exists": true,
+      "consistencyScore": 98,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "All entities documented and match schema"
+    },
+    "phase3": {
+      "file": "docs/architecture.md",
+      "exists": true,
+      "consistencyScore": 87,
+      "recommendation": "HYBRID",
+      "gaps": ["api_versioning", "rate_limiting"],
+      "reason": "Architecture documented but missing 2 details"
+    },
+    "phase4": {
+      "file": "specs/security.md",
+      "exists": true,
+      "consistencyScore": 95,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "Security patterns match implementation"
+    },
+    "phase5": {
+      "file": "docs/code-standards.md",
+      "exists": true,
+      "consistencyScore": 92,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "Standards documented and enforced"
+    },
+    "phase6": {
+      "file": "docs/testing.md",
+      "exists": true,
+      "consistencyScore": 90,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "Testing strategy documented"
+    },
+    "phase7": {
+      "file": "docs/deployment.md",
+      "exists": true,
+      "consistencyScore": 82,
+      "recommendation": "HYBRID",
+      "gaps": ["monitoring_strategy", "incident_runbooks"],
+      "reason": "Deployment documented but missing operational details"
+    },
+    "phase8": {
+      "file": "AGENT.md",
+      "exists": true,
+      "consistencyScore": 95,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "Final documentation complete and up-to-date"
+    },
+    "phase9": {
+      "file": "docs/roadmap.md",
+      "exists": false,
+      "consistencyScore": 0,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "Project already implemented - roadmap not needed for existing code"
+    },
+    "phase10": {
+      "file": "docs/user-stories/",
+      "exists": false,
+      "consistencyScore": 0,
+      "recommendation": "SKIP",
+      "gaps": [],
+      "reason": "Project already implemented - user stories not needed for existing features"
+    }
+  }
 }
 ```
 
-**Cache invalidation:** 7 days or when package.json is modified
----
-## 🚀 Next Steps
+**Recommendation Logic:**
+- **SKIP** (≥95%): Phase can be skipped, use existing docs
+- **HYBRID** (80-94%): Ask only missing questions, merge with existing docs
+- **FULL** (<80% or file missing): Execute full phase with pre-filled answers
 
-After Phase 0 completes:
+This data will be used in Phases 1-7 to:
+1. Determine if phase can be skipped
+2. Identify specific gaps to ask about
+3. Merge new answers with existing documentation
 
-```
-✅ Context analysis complete!
+This data will be used in Phase 8 to:
+1. Generate detailed audit report
+2. Apply auto-corrections
+3. Update roadmap with "To Implement" items
 
-Next: Proceed to Phase 1 (Discovery & UX)
+---
 
-Read: .ai-flow/prompts/frontend/flow-build-phase-1-discovery.md
-```
----
-**Last Updated:** 2025-01-XX
+## 0.5 Validation & Synthesis
+
+### Present Findings
+
+Show the final report including:
+1. **🔍 BACKEND STACK DETECTED** (from Layers 1-3)
+2. **📊 Documentation Audit Summary** (from Layer 4, if executed)
+
+Ask for confirmation to proceed to Phase 1.
+
+### 💾 Cache & Pre-populate
+
+1. **Export code analysis:** `.ai-flow/cache/docs-analysis.json`
+2. **Export audit data:** `.ai-flow/cache/audit-data.json` (if Layer 4 executed)
+3. **Pre-populate:** Fill answers for Phases 1-7 based on detected data
+
+### 🎯 Set Flags for Phase 8
+
+If documentation audit was performed:
+- Set flag: `auditPerformed: true`
+- Phase 8 will:
+  - Generate detailed audit report (`docs/audit-report.md`)
+  - Offer to apply auto-corrections (🟡 Medium + 🟢 Low)
+  - Update roadmap with "To Implement" items (🔴 Critical marked as such)
+
+---
+
+✅ **Phase 0 Complete: Context Analysis Finalized**
+
+---
+
+### Phase Summary
+- Pre-populated detected tech stack values.
+- Architectural patterns identified.
+- Context cached in `.ai-flow/cache/docs-analysis.json`.
+- **Documentation audit completed** (if existing docs found).
+- **Inconsistencies flagged** for Phase 8 resolution.
 
-**Version:** 1.2.0
+---
 
+**Next Phase:** Phase 1 - Discovery & Business Requirements
 
+**What happens next:**
+- Phase 1-7 will use pre-populated answers (40-60% filled)
+- You'll only answer questions that couldn't be auto-detected
+- Phase 8 will offer to resolve documentation inconsistencies
 
+Read: `.ai-flow/prompts/backend/flow-build-phase-1.md`
 
+---
+_Version: 4.3 (Antigravity Optimized - With Integrated Audit)_
+_Last Updated: 2025-12-22_