@iservu-inc/adf-cli 0.17.0 → 0.17.1

package/lib/frameworks/questions.js

@@ -2,12 +2,12 @@
 // Level 1: Rapid (Agent-Native), Level 2: Balanced (OpenSpec), Level 3: Comprehensive (Agent-Native)
 
 const prpQuestions = [
-  // Phase 1: Goal Definition (4 questions)
+  // Phase 1: Goal Definition (3 questions)
   {
     id: 'prp-1',
     phase: 'goal-definition',
     number: 1,
-    total: 20,
+    total: 10,
     text: 'What specific software feature or product are you building?',
     guidance: 'Be precise about the type of software, technology, and core functionality',
     goodExample: 'A React dashboard that displays real-time analytics from PostgreSQL with Chart.js',
@@ -24,31 +24,19 @@ const prpQuestions = [
     id: 'prp-2',
     phase: 'goal-definition',
     number: 2,
-    total: 20,
-    text: 'What is the primary user action this enables?',
-    guidance: 'Focus on the ONE main thing users will do most often',
-    goodExample: 'Users can add a new job application by filling out a form with company name, position, date applied, and current status',
-    badExample: 'Use the app',
-    keywords: ['create', 'add', 'update', 'delete', 'view', 'search', 'filter', 'upload', 'download', 'submit'],
-    requiredElements: ['action', 'user-interaction']
+    total: 10,
+    text: 'What problem does this solve and what primary user action does it enable?',
+    guidance: 'Describe the pain point users face WITHOUT this solution and the ONE main thing users will do most often',
+    goodExample: 'Job seekers applying to 50+ positions lose track of applications and miss follow-up deadlines. This lets them add and track job applications with company, position, date, and status.',
+    badExample: 'They need to track stuff',
+    keywords: ['pain', 'challenge', 'problem', 'create', 'add', 'update', 'view', 'search', 'submit'],
+    requiredElements: ['problem-statement', 'action', 'user-interaction']
   },
   {
     id: 'prp-3',
     phase: 'goal-definition',
     number: 3,
-    total: 20,
-    text: 'What problem does this solve?',
-    guidance: 'Describe the pain point or challenge users face WITHOUT this solution',
-    goodExample: 'Job seekers applying to 50+ positions lose track of which companies they applied to, when they applied, and miss critical follow-up deadlines',
-    badExample: 'They need to track applications',
-    keywords: ['pain', 'challenge', 'problem', 'frustration', 'difficulty', 'struggle'],
-    requiredElements: ['problem-statement']
-  },
-  {
-    id: 'prp-4',
-    phase: 'goal-definition',
-    number: 4,
-    total: 20,
+    total: 10,
     text: 'What does success look like?',
     guidance: 'Define a concrete, measurable outcome that indicates this is working',
     goodExample: 'Users successfully track 20+ applications, receive automated reminders 3 days after applying, and have a 50% reduction in missed follow-ups',
@@ -57,112 +45,52 @@ const prpQuestions = [
     requiredElements: ['measurable-outcome']
   },
 
-  // Phase 2: Business Justification (3 questions)
+  // Phase 2: Business Context (1 question)
   {
-    id: 'prp-5',
-    phase: 'business-justification',
-    number: 5,
-    total: 20,
-    text: 'Why is this valuable to users?',
-    guidance: 'Explain the benefit and value users get from this',
-    goodExample: 'Saves 5+ hours per week organizing applications in spreadsheets, reduces stress from missed deadlines, increases job search success rate',
-    badExample: 'It helps them',
-    keywords: ['saves', 'reduces', 'increases', 'improves', 'enables', 'automates'],
-    requiredElements: ['user-benefit']
-  },
-  {
-    id: 'prp-6',
-    phase: 'business-justification',
-    number: 6,
-    total: 20,
-    text: 'What happens if this is NOT built?',
-    guidance: 'Describe the negative impact of not having this solution',
-    goodExample: 'Users continue using error-prone spreadsheets, miss 30% of follow-up opportunities, lose potential job offers due to poor organization',
-    badExample: 'Nothing',
-    keywords: ['continue', 'remain', 'miss', 'lose', 'waste'],
-    requiredElements: ['negative-impact']
-  },
-  {
-    id: 'prp-7',
-    phase: 'business-justification',
-    number: 7,
-    total: 20,
-    text: 'What is the expected usage pattern?',
-    guidance: 'How often will users interact with this? Daily, weekly, per-session?',
-    goodExample: 'Users check the dashboard daily, add 2-5 applications per week, update statuses 3-4 times per week when hearing back from companies',
-    badExample: 'Sometimes',
-    keywords: ['daily', 'weekly', 'monthly', 'per session', 'frequently', 'occasionally'],
-    requiredElements: ['frequency']
+    id: 'prp-4',
+    phase: 'business-context',
+    number: 4,
+    total: 10,
+    text: 'Why is this valuable and what\'s the expected usage pattern?',
+    guidance: 'Explain the benefit users get, the cost of NOT building this, and how often users will interact (daily, weekly, per-session)',
+    goodExample: 'Saves 5+ hours/week vs spreadsheets. Without it, users miss 30% of follow-ups. Users check the dashboard daily, add 2-5 applications per week, update statuses 3-4 times weekly.',
+    badExample: 'It helps them sometimes',
+    keywords: ['saves', 'reduces', 'increases', 'daily', 'weekly', 'monthly', 'frequency'],
+    requiredElements: ['user-benefit', 'negative-impact', 'frequency']
   },
 
-  // Phase 3: Contextual Intelligence (5 questions)
+  // Phase 3: Contextual Intelligence (2 questions)
   {
-    id: 'prp-8',
+    id: 'prp-5',
     phase: 'contextual-intelligence',
-    number: 8,
-    total: 20,
-    text: 'What is your complete technology stack?',
-    guidance: 'Include frontend, backend, database, and specific version numbers',
-    goodExample: 'Frontend: Next.js 14 with TypeScript and Tailwind CSS. Backend: Node.js 20 with Express. Database: PostgreSQL 15. Auth: NextAuth.js',
+    number: 5,
+    total: 10,
+    text: 'What is your complete technology stack, including key libraries?',
+    guidance: 'Include frontend, backend, database, specific version numbers, and important npm/pip/maven packages',
+    goodExample: 'Frontend: Next.js 14 with TypeScript and Tailwind CSS. Backend: Node.js 20 with Express. Database: PostgreSQL 15. Auth: NextAuth.js. Packages: zod@3.22.4, react-hook-form@7.48.2, date-fns@2.30.0',
     badExample: 'JavaScript',
-    keywords: ['frontend', 'backend', 'database', 'auth', 'version'],
-    requiredElements: ['frontend-tech', 'backend-tech', 'database']
-  },
-  {
-    id: 'prp-9',
-    phase: 'contextual-intelligence',
-    number: 9,
-    total: 20,
-    text: 'What files and directories will be affected?',
-    guidance: 'List exact file paths where code will be added or modified',
-    goodExample: 'src/app/dashboard/page.tsx, src/components/ApplicationForm.tsx, src/lib/db/schema.ts, src/api/applications/route.ts',
-    badExample: 'Some files',
-    keywords: ['src/', 'app/', 'components/', 'api/', 'lib/', 'pages/'],
-    requiredElements: ['file-paths']
-  },
-  {
-    id: 'prp-10',
-    phase: 'contextual-intelligence',
-    number: 10,
-    total: 20,
-    text: 'What libraries and packages will you use?',
-    guidance: 'List npm/pip/maven packages with version numbers',
-    goodExample: 'zod@3.22.4 for validation, react-hook-form@7.48.2 for forms, date-fns@2.30.0 for date handling, pg@8.11.3 for PostgreSQL',
-    badExample: 'Some libraries',
-    keywords: ['npm', 'yarn', 'pip', 'maven', 'package', 'dependency'],
-    requiredElements: ['dependencies']
+    keywords: ['frontend', 'backend', 'database', 'auth', 'version', 'npm', 'package', 'dependency'],
+    requiredElements: ['frontend-tech', 'backend-tech', 'database', 'dependencies']
   },
   {
-    id: 'prp-11',
+    id: 'prp-6',
     phase: 'contextual-intelligence',
-    number: 11,
-    total: 20,
-    text: 'Are there existing code patterns or conventions to follow?',
-    guidance: 'Reference existing code structure, naming conventions, or architectural patterns',
-    goodExample: 'Follow the existing pattern in src/components/JobCard.tsx for card layouts. Use the API route structure from src/api/users/route.ts. Follow Airbnb style guide',
+    number: 6,
+    total: 10,
+    text: 'What existing patterns, conventions, and documentation should be followed?',
+    guidance: 'Reference existing code structure, naming conventions, architectural patterns, and any relevant docs/API specs',
+    goodExample: 'Follow the existing pattern in src/components/JobCard.tsx for card layouts. Use API route structure from src/api/users/route.ts. Airbnb style guide. Docs: Next.js App Router docs, DB schema in ./docs/database.md',
     badExample: 'No',
-    keywords: ['pattern', 'convention', 'style', 'structure', 'example'],
-    requiredElements: ['code-patterns']
-  },
-  {
-    id: 'prp-12',
-    phase: 'contextual-intelligence',
-    number: 12,
-    total: 20,
-    text: 'What documentation should be referenced?',
-    guidance: 'Provide URLs or file paths to relevant documentation, API docs, or design specs',
-    goodExample: 'Next.js App Router docs (https://nextjs.org/docs/app), PostgreSQL schema in ./docs/database.md, API spec in ./docs/api-reference.md',
-    badExample: 'The docs',
-    keywords: ['docs/', 'documentation', 'readme', 'api', 'spec'],
-    requiredElements: ['documentation-refs']
+    keywords: ['pattern', 'convention', 'style', 'structure', 'docs', 'documentation', 'readme', 'spec'],
+    requiredElements: ['code-patterns', 'documentation-refs']
   },
 
-  // Phase 4: Implementation Blueprint (5 questions)
+  // Phase 4: Implementation Blueprint (3 questions)
   {
-    id: 'prp-13',
+    id: 'prp-7',
     phase: 'implementation-blueprint',
-    number: 13,
-    total: 20,
+    number: 7,
+    total: 10,
     text: 'What are the main implementation steps in order?',
     guidance: 'List 3-7 ordered steps that outline the implementation approach',
     goodExample: '1. Create database schema with applications table 2. Build API route for CRUD operations 3. Create ApplicationForm component with validation 4. Build dashboard page with data table 5. Add filtering and search 6. Implement reminder system',
@@ -171,34 +99,22 @@ const prpQuestions = [
     requiredElements: ['ordered-steps']
   },
   {
-    id: 'prp-14',
-    phase: 'implementation-blueprint',
-    number: 14,
-    total: 20,
-    text: 'What is the data model?',
-    guidance: 'Define entities, fields, types, and relationships',
-    goodExample: 'Application entity: { id: UUID, company: string, position: string, dateApplied: Date, status: enum[applied,interviewing,offer,rejected], notes: text, userId: UUID (FK to Users) }',
-    badExample: 'Some data',
-    keywords: ['entity', 'model', 'schema', 'table', 'fields', 'columns', 'relationship'],
-    requiredElements: ['data-structure']
-  },
-  {
-    id: 'prp-15',
+    id: 'prp-8',
     phase: 'implementation-blueprint',
-    number: 15,
-    total: 20,
-    text: 'What is the API design?',
-    guidance: 'List endpoints, HTTP methods, request/response formats',
-    goodExample: 'GET /api/applications - list all. POST /api/applications - create (body: {company, position, dateApplied}). PATCH /api/applications/:id - update status. DELETE /api/applications/:id',
-    badExample: 'API stuff',
-    keywords: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'endpoint', 'route'],
-    requiredElements: ['api-endpoints']
+    number: 8,
+    total: 10,
+    text: 'What is the data model and API design?',
+    guidance: 'Define entities, fields, types, relationships, and list endpoints with HTTP methods and request/response formats',
+    goodExample: 'Application entity: { id: UUID, company: string, position: string, dateApplied: Date, status: enum[applied,interviewing,offer,rejected], userId: UUID (FK) }. Endpoints: GET /api/applications, POST /api/applications, PATCH /api/applications/:id, DELETE /api/applications/:id',
+    badExample: 'Some data and API stuff',
+    keywords: ['entity', 'model', 'schema', 'table', 'fields', 'endpoint', 'route', 'GET', 'POST'],
+    requiredElements: ['data-structure', 'api-endpoints']
   },
   {
-    id: 'prp-16',
+    id: 'prp-9',
     phase: 'implementation-blueprint',
-    number: 16,
-    total: 20,
+    number: 9,
+    total: 10,
     text: 'What edge cases and errors must be handled?',
     guidance: 'List error scenarios, validation rules, and boundary conditions',
     goodExample: 'Handle duplicate applications (same company+position), validate date is not in future, handle network failures gracefully, show error toast on failed submission, validate required fields',
@@ -206,142 +122,70 @@ const prpQuestions = [
     keywords: ['validate', 'error', 'edge case', 'handle', 'boundary', 'exception'],
     requiredElements: ['error-handling']
   },
-  {
-    id: 'prp-17',
-    phase: 'implementation-blueprint',
-    number: 17,
-    total: 20,
-    text: 'What is the technical approach or algorithm?',
-    guidance: 'Describe the core logic, pseudocode, or technical strategy',
-    goodExample: 'Use React Hook Form for form state, validate with Zod schema, debounce search input (300ms), use SWR for data fetching with 30s revalidation, implement optimistic UI updates',
-    badExample: 'Code it',
-    keywords: ['algorithm', 'logic', 'approach', 'strategy', 'pseudocode'],
-    requiredElements: ['technical-approach']
-  },
 
-  // Phase 5: Validation Loop (3 questions)
+  // Phase 5: Validation (1 question)
   {
-    id: 'prp-18',
-    phase: 'validation-loop',
-    number: 18,
-    total: 20,
-    text: 'How do you manually verify this works?',
-    guidance: 'Step-by-step manual testing procedure',
-    goodExample: '1. Load dashboard, verify empty state shows. 2. Click "Add Application", fill form, submit. 3. Verify new application appears in table. 4. Change status dropdown, verify update persists. 5. Test search with company name',
-    badExample: 'Test it',
-    keywords: ['test', 'verify', 'check', 'validate', 'confirm'],
-    requiredElements: ['test-steps']
-  },
-  {
-    id: 'prp-19',
-    phase: 'validation-loop',
-    number: 19,
-    total: 20,
-    text: 'What automated tests are needed?',
-    guidance: 'Specify unit tests, integration tests, or E2E tests',
-    goodExample: 'Unit: ApplicationForm validation logic. Integration: API routes with mocked DB. E2E: Full user flow from adding application to updating status (Playwright)',
-    badExample: 'Tests',
-    keywords: ['unit', 'integration', 'e2e', 'test', 'jest', 'vitest', 'playwright'],
-    requiredElements: ['automated-tests']
-  },
-  {
-    id: 'prp-20',
-    phase: 'validation-loop',
-    number: 20,
-    total: 20,
-    text: 'What is your definition of done?',
-    guidance: 'Checklist of criteria that must be met to consider this complete',
-    goodExample: '✓ All CRUD operations working ✓ Form validation passing ✓ Search/filter functional ✓ 80% test coverage ✓ No TypeScript errors ✓ Responsive on mobile ✓ Documentation updated',
-    badExample: 'When it works',
-    keywords: ['criteria', 'checklist', 'complete', 'done', 'finished'],
-    requiredElements: ['acceptance-criteria']
+    id: 'prp-10',
+    phase: 'validation',
+    number: 10,
+    total: 10,
+    text: 'What is your testing strategy and definition of done?',
+    guidance: 'Specify manual test steps, automated tests (unit/integration/E2E), and the checklist of criteria for completion',
+    goodExample: 'Manual: Load dashboard, add application, verify in table, change status. Automated: Unit tests for validation logic, integration tests for API routes, E2E for full user flow (Playwright). Done: All CRUD working, 80% coverage, no TS errors, responsive on mobile, docs updated.',
+    badExample: 'Test it and done',
+    keywords: ['test', 'verify', 'unit', 'integration', 'e2e', 'coverage', 'criteria', 'checklist', 'done'],
+    requiredElements: ['test-steps', 'automated-tests', 'acceptance-criteria']
   }
 ];
 
 // Balanced Framework Questions (Level 2: OpenSpec)
 const balancedQuestions = [
-  ...prpQuestions, // Include all PRP questions
+  ...prpQuestions, // Include all PRP questions (1-10)
 
-  // Constitution Block (6 questions)
+  // Constitution Block (3 questions)
   {
-    id: 'bal-21',
+    id: 'bal-11',
     phase: 'constitution',
-    number: 21,
-    total: 50,
-    text: 'What are your code quality standards?',
-    guidance: 'Define linting rules, formatting conventions, and code review expectations',
-    goodExample: 'ESLint with Airbnb config, Prettier with 2-space tabs, strict TypeScript mode, no any types, max function length 50 lines, require JSDoc for public APIs',
-    badExample: 'Good code',
-    keywords: ['eslint', 'prettier', 'linting', 'formatting', 'standards'],
-    requiredElements: ['quality-standards']
+    number: 11,
+    total: 25,
+    text: 'What are your code quality and documentation standards?',
+    guidance: 'Define linting rules, formatting conventions, code review expectations, and what documentation is required',
+    goodExample: 'ESLint with Airbnb config, Prettier with 2-space tabs, strict TypeScript mode, no any types, max function length 50 lines. JSDoc for all public functions, README per module, API docs in OpenAPI format, update docs in same PR as code.',
+    badExample: 'Good code with some docs',
+    keywords: ['eslint', 'prettier', 'linting', 'formatting', 'standards', 'jsdoc', 'readme', 'documentation'],
+    requiredElements: ['quality-standards', 'doc-standards']
   },
   {
-    id: 'bal-22',
+    id: 'bal-12',
     phase: 'constitution',
-    number: 22,
-    total: 50,
-    text: 'What are your testing requirements?',
+    number: 12,
+    total: 25,
+    text: 'What are your security and accessibility requirements?',
+    guidance: 'Define security practices (input sanitization, auth, CSP) and accessibility standards (WCAG level, keyboard nav)',
+    goodExample: 'Input sanitization on all user data, parameterized SQL queries, JWT with 15min expiry, HTTPS only, CSP headers, rate limiting. WCAG 2.1 AA, keyboard navigation for all interactions, loading states max 200ms, mobile-first responsive.',
+    badExample: 'Secure and accessible',
+    keywords: ['security', 'sanitization', 'auth', 'https', 'csp', 'wcag', 'accessibility', 'a11y', 'responsive'],
+    requiredElements: ['security-standards', 'ux-standards']
+  },
+  {
+    id: 'bal-13',
+    phase: 'constitution',
+    number: 13,
+    total: 25,
+    text: 'What are your testing requirements and coverage targets?',
     guidance: 'Specify coverage targets, testing pyramid, and test types required',
     goodExample: '80% code coverage minimum, unit tests for all business logic, integration tests for API routes, E2E for critical user flows, run tests in CI before merge',
     badExample: 'Some tests',
     keywords: ['coverage', 'unit', 'integration', 'e2e', 'ci'],
     requiredElements: ['test-requirements']
   },
-  {
-    id: 'bal-23',
-    phase: 'constitution',
-    number: 23,
-    total: 50,
-    text: 'What are your documentation standards?',
-    guidance: 'Define what documentation is required and where it lives',
-    goodExample: 'JSDoc comments for all public functions, README per module, API documentation in OpenAPI format, inline comments for complex logic, update docs in same PR as code',
-    badExample: 'Some docs',
-    keywords: ['jsdoc', 'readme', 'comments', 'documentation'],
-    requiredElements: ['doc-standards']
-  },
-  {
-    id: 'bal-24',
-    phase: 'constitution',
-    number: 24,
-    total: 50,
-    text: 'What are your UX/accessibility principles?',
-    guidance: 'Define user experience and accessibility requirements',
-    goodExample: 'WCAG 2.1 AA compliance, keyboard navigation for all interactions, loading states max 200ms, error messages actionable, mobile-first responsive design',
-    badExample: 'Good UX',
-    keywords: ['wcag', 'accessibility', 'a11y', 'responsive', 'ux'],
-    requiredElements: ['ux-standards']
-  },
-  {
-    id: 'bal-25',
-    phase: 'constitution',
-    number: 25,
-    total: 50,
-    text: 'What are your security standards?',
-    guidance: 'Define security requirements and practices',
-    goodExample: 'Input sanitization on all user data, parameterized SQL queries, JWT with 15min expiry, HTTPS only, CSP headers, rate limiting on API routes, security headers with helmet',
-    badExample: 'Secure',
-    keywords: ['security', 'sanitization', 'auth', 'https', 'csp'],
-    requiredElements: ['security-standards']
-  },
-  {
-    id: 'bal-26',
-    phase: 'constitution',
-    number: 26,
-    total: 50,
-    text: 'What are your decision-making guidelines?',
-    guidance: 'How are technical decisions made and tradeoffs evaluated?',
-    goodExample: 'Prefer boring technology, optimize for developer experience, document all major decisions in ADR format, prefer composition over inheritance, 2-person approval for architecture changes',
-    badExample: 'We decide',
-    keywords: ['decision', 'tradeoff', 'guidelines', 'adr'],
-    requiredElements: ['decision-process']
-  },
 
-  // Detailed Specification (Additional 10 questions beyond PRP)
+  // Specification Block (5 questions)
   {
-    id: 'bal-27',
+    id: 'bal-14',
     phase: 'specification',
-    number: 27,
-    total: 50,
+    number: 14,
+    total: 25,
     text: 'What are ALL features in scope with priorities?',
     guidance: 'Complete feature list with P0 (must-have), P1 (should-have), P2 (nice-to-have)',
     goodExample: 'P0: Add/edit/delete applications, status tracking, basic search. P1: Email reminders, CSV import, analytics dashboard. P2: Chrome extension, mobile app, AI resume matching',
@@ -350,23 +194,23 @@ const balancedQuestions = [
     requiredElements: ['feature-priorities']
   },
   {
-    id: 'bal-28',
+    id: 'bal-15',
     phase: 'specification',
-    number: 28,
-    total: 50,
-    text: 'For each high-priority feature, describe expected behavior',
-    guidance: 'Detail what each P0/P1 feature should do',
-    goodExample: 'Add Application: User clicks "New", fills form (company req, position req, date optional, notes optional), validates, saves to DB, shows in table immediately with success toast',
-    badExample: 'It works',
-    keywords: ['behavior', 'flow', 'interaction', 'expected'],
-    requiredElements: ['feature-behavior']
+    number: 15,
+    total: 25,
+    text: 'For each high-priority feature, describe expected behavior and user workflow',
+    guidance: 'Detail what each P0/P1 feature should do and the step-by-step user journey',
+    goodExample: 'Add Application: User clicks "New", fills form (company req, position req, date optional), validates, saves to DB, shows in table with success toast. Full flow: Login → Dashboard → Click "Add" → Modal with form → Submit → Modal closes → New row in table → Confirmation email',
+    badExample: 'It works and they use it',
+    keywords: ['behavior', 'flow', 'interaction', 'expected', 'workflow', 'journey', 'steps'],
+    requiredElements: ['feature-behavior', 'user-workflow']
   },
   {
-    id: 'bal-29',
+    id: 'bal-16',
     phase: 'specification',
-    number: 29,
-    total: 50,
-    text: 'What is explicitly OUT of scope for v1?',
+    number: 16,
+    total: 25,
+    text: 'What is explicitly out of scope for v1?',
     guidance: 'List features that will NOT be in the first version',
     goodExample: 'Not in v1: AI-powered resume tailoring, integration with LinkedIn API, team collaboration features, advanced analytics, mobile apps',
     badExample: 'Other stuff',
@@ -374,46 +218,22 @@ const balancedQuestions = [
     requiredElements: ['out-of-scope']
   },
   {
-    id: 'bal-30',
-    phase: 'specification',
-    number: 30,
-    total: 50,
-    text: 'What are the integration requirements?',
-    guidance: 'External APIs, services, or systems to integrate with',
-    goodExample: 'SendGrid for email notifications, Google Calendar API for interview scheduling, optional: LinkedIn API for company data enrichment',
-    badExample: 'Integrations',
-    keywords: ['api', 'integration', 'external', 'service'],
-    requiredElements: ['integrations']
-  },
-  {
-    id: 'bal-31',
-    phase: 'specification',
-    number: 31,
-    total: 50,
-    text: 'What is the detailed user workflow?',
-    guidance: 'Step-by-step flow of main user journey',
-    goodExample: '1. User logs in 2. Sees dashboard with applications table 3. Clicks "Add Application" 4. Modal opens with form 5. Fills required fields 6. Submits 7. Modal closes 8. New row appears in table 9. Receives confirmation email',
-    badExample: 'They use it',
-    keywords: ['workflow', 'journey', 'flow', 'steps'],
-    requiredElements: ['user-workflow']
-  },
-  {
-    id: 'bal-32',
+    id: 'bal-17',
     phase: 'specification',
-    number: 32,
-    total: 50,
-    text: 'What edge cases and scenarios need to be handled?',
-    guidance: 'Unusual situations, error cases, boundary conditions',
-    goodExample: 'Duplicate detection, offline mode, network timeout, invalid date, SQL injection attempts, very long company names (>100 chars), concurrent edits, deleted user sessions',
-    badExample: 'Edge cases',
-    keywords: ['edge case', 'scenario', 'error', 'boundary'],
-    requiredElements: ['edge-cases']
+    number: 17,
+    total: 25,
+    text: 'What are the integration requirements and third-party services?',
+    guidance: 'External APIs, services, SDKs, or systems to integrate with and their approach',
+    goodExample: 'SendGrid for email notifications (@sendgrid/mail), Google Calendar API for interview scheduling, Sentry for error tracking, PostHog for analytics. Optional: LinkedIn API for company data enrichment',
+    badExample: 'Integrations and cloud stuff',
+    keywords: ['api', 'integration', 'external', 'service', 'sdk'],
+    requiredElements: ['integrations', 'third-party']
   },
   {
-    id: 'bal-33',
+    id: 'bal-18',
     phase: 'specification',
-    number: 33,
-    total: 50,
+    number: 18,
+    total: 25,
     text: 'What are the UI/UX specifications?',
     guidance: 'Design system, component library, visual specifications',
     goodExample: 'Use shadcn/ui components, Tailwind with custom theme (primary: #3B82F6), responsive breakpoints at 640/768/1024px, Geist font, dark mode support',
@@ -421,49 +241,13 @@ const balancedQuestions = [
     keywords: ['ui', 'ux', 'design', 'components', 'theme'],
     requiredElements: ['ui-specs']
   },
-  {
-    id: 'bal-34',
-    phase: 'specification',
-    number: 34,
-    total: 50,
-    text: 'What assumptions are you making?',
-    guidance: 'List all assumptions explicitly',
-    goodExample: 'Assume users have modern browsers (Chrome 90+), stable internet, English language only for v1, max 1000 applications per user, users understand job application process',
-    badExample: 'Assumptions',
-    keywords: ['assume', 'assumption', 'expect', 'presume'],
-    requiredElements: ['assumptions']
-  },
-  {
-    id: 'bal-35',
-    phase: 'specification',
-    number: 35,
-    total: 50,
-    text: 'What open questions remain?',
-    guidance: 'What needs to be decided or researched before implementation',
-    goodExample: 'Q: Should we support multiple resume versions per application? Q: Email frequency limits? Q: Data retention policy? Q: Should status changes be logged with history?',
-    badExample: 'None',
-    keywords: ['question', 'tbd', 'decide', 'research'],
-    requiredElements: ['open-questions']
-  },
 
-  // Technical Planning (8 questions)
-  {
-    id: 'bal-36',
-    phase: 'technical-plan',
-    number: 36,
-    total: 50,
-    text: 'Why did you choose this technology stack?',
-    guidance: 'Justify each major technology decision',
-    goodExample: 'Next.js for SSR/SEO benefits and API routes, TypeScript for type safety, PostgreSQL for relational data with complex queries, Tailwind for rapid styling, Vercel for easy deployment',
-    badExample: 'Its good',
-    keywords: ['because', 'reason', 'choice', 'justify'],
-    requiredElements: ['tech-justification']
-  },
+  // Technical Plan Block (4 questions)
   {
-    id: 'bal-37',
+    id: 'bal-19',
     phase: 'technical-plan',
-    number: 37,
-    total: 50,
+    number: 19,
+    total: 25,
     text: 'What architectural pattern and why?',
     guidance: 'Describe architecture style with rationale',
     goodExample: 'Monolithic Next.js app with API routes (simpler for small team, easier debugging), MVC pattern on backend, Container/Presenter on frontend, event-driven for notifications',
@@ -472,34 +256,10 @@ const balancedQuestions = [
     requiredElements: ['architecture-pattern']
   },
   {
-    id: 'bal-38',
-    phase: 'technical-plan',
-    number: 38,
-    total: 50,
-    text: 'What is the database design?',
-    guidance: 'Tables/collections, relationships, indexes',
-    goodExample: 'Tables: users, applications (FK to users), reminders (FK to applications). Indexes: applications.userId, applications.dateApplied, applications.status. Use UUIDs for IDs',
-    badExample: 'Database',
-    keywords: ['table', 'schema', 'index', 'foreign key', 'relationship'],
-    requiredElements: ['database-design']
-  },
-  {
-    id: 'bal-39',
+    id: 'bal-20',
     phase: 'technical-plan',
-    number: 39,
-    total: 50,
-    text: 'What is the complete API design?',
-    guidance: 'All endpoints with request/response schemas',
-    goodExample: 'POST /api/auth/login {email,password} → {token,user}. GET /api/applications?status=applied → [{id,company,...}]. Full OpenAPI spec in docs/api.yaml',
-    badExample: 'REST API',
-    keywords: ['endpoint', 'route', 'request', 'response', 'schema'],
-    requiredElements: ['api-design']
-  },
-  {
-    id: 'bal-40',
-    phase: 'technical-plan',
-    number: 40,
-    total: 50,
+    number: 20,
+    total: 25,
     text: 'What is the authentication/authorization approach?',
     guidance: 'Auth method, session management, role-based access',
     goodExample: 'NextAuth.js with credentials provider, JWT stored in httpOnly cookie, 15min access token, 7day refresh token, middleware protects /dashboard routes, no RBAC needed (all users equal)',
@@ -508,35 +268,23 @@ const balancedQuestions = [
     requiredElements: ['auth-design']
   },
   {
-    id: 'bal-41',
-    phase: 'technical-plan',
-    number: 41,
-    total: 50,
-    text: 'What third-party services and SDKs?',
-    guidance: 'External services with integration approach',
-    goodExample: 'Vercel for hosting, Supabase for PostgreSQL + Auth, SendGrid for emails (@sendgrid/mail), Sentry for error tracking, PostHog for analytics',
-    badExample: 'Cloud stuff',
-    keywords: ['service', 'sdk', 'api', 'integration'],
-    requiredElements: ['third-party']
-  },
-  {
-    id: 'bal-42',
+    id: 'bal-21',
     phase: 'technical-plan',
-    number: 42,
-    total: 50,
-    text: 'What is the deployment architecture?',
-    guidance: 'Infrastructure, CI/CD, environments',
+    number: 21,
+    total: 25,
+    text: 'What is the deployment architecture and CI/CD?',
+    guidance: 'Infrastructure, CI/CD pipeline, environments',
     goodExample: 'Vercel for Next.js (auto-deploy from main branch), Supabase for DB (production instance), GitHub Actions for tests, staging environment on Vercel preview deployments',
     badExample: 'Cloud',
     keywords: ['deploy', 'infrastructure', 'ci/cd', 'environment'],
     requiredElements: ['deployment']
   },
   {
-    id: 'bal-43',
+    id: 'bal-22',
     phase: 'technical-plan',
-    number: 43,
-    total: 50,
-    text: 'What is the performance strategy?',
+    number: 22,
+    total: 25,
+    text: 'What is the performance and caching strategy?',
     guidance: 'Caching, optimization, performance targets',
     goodExample: 'Target: <200ms API responses, <2s page load. Strategy: Next.js ISR for dashboard (revalidate 60s), React Query for client caching, DB indexes on query columns, image optimization with next/image',
     badExample: 'Fast',
@@ -544,13 +292,13 @@ const balancedQuestions = [
     requiredElements: ['performance']
   },
 
-  // Task Breakdown (7 questions - reduced from original 8 to make total 50)
+  // Task Breakdown Block (3 questions)
   {
-    id: 'bal-44',
+    id: 'bal-23',
     phase: 'task-breakdown',
-    number: 44,
-    total: 50,
-    text: 'What are ALL implementation tasks in dependency order?',
+    number: 23,
+    total: 25,
+    text: 'What are all implementation tasks in dependency order?',
     guidance: 'Complete task list showing what must be done before what',
     goodExample: '1. Setup project + DB 2. Auth system 3. Create applications API 4. Build dashboard UI 5. Add search/filter 6. Email reminders 7. CSV import 8. Testing 9. Deploy',
     badExample: 'Tasks',
@@ -558,71 +306,23 @@ const balancedQuestions = [
     requiredElements: ['task-list']
   },
   {
-    id: 'bal-45',
-    phase: 'task-breakdown',
-    number: 45,
-    total: 50,
-    text: 'What is the critical path?',
-    guidance: 'Tasks that block other tasks and must be done first',
-    goodExample: 'Critical path: Setup → Auth → Applications API → Dashboard. These block everything else. Search/filter and emails can be parallel after dashboard',
-    badExample: 'Important tasks',
-    keywords: ['critical', 'blocker', 'dependency', 'blocks'],
-    requiredElements: ['critical-path']
-  },
-  {
-    id: 'bal-46',
-    phase: 'task-breakdown',
-    number: 46,
-    total: 50,
-    text: 'What tasks can be done in parallel?',
-    guidance: 'Independent tasks that can be worked on simultaneously',
-    goodExample: 'After dashboard done: (1) Search/filter + (2) Email system + (3) CSV import can all be parallel. Testing and docs can start anytime',
-    badExample: 'Some',
-    keywords: ['parallel', 'concurrent', 'independent', 'simultaneous'],
-    requiredElements: ['parallel-tasks']
-  },
-  {
-    id: 'bal-47',
-    phase: 'task-breakdown',
-    number: 47,
-    total: 50,
-    text: 'What are the key milestones?',
-    guidance: 'Major checkpoints that indicate progress',
-    goodExample: 'M1: Auth working (Week 1). M2: CRUD functional (Week 2). M3: Search + reminders (Week 3). M4: Testing complete (Week 4). M5: Production deploy (Week 4)',
-    badExample: 'Milestones',
-    keywords: ['milestone', 'checkpoint', 'deliverable', 'phase'],
-    requiredElements: ['milestones']
-  },
-  {
-    id: 'bal-48',
-    phase: 'task-breakdown',
-    number: 48,
-    total: 50,
-    text: 'What is the testing strategy per task?',
-    guidance: 'How each major task will be tested',
-    goodExample: 'Auth: Unit tests for JWT logic + E2E for login flow. API: Integration tests with test DB. UI: Component tests + E2E with Playwright. Email: Mock SendGrid + test emails',
-    badExample: 'Test it',
-    keywords: ['test', 'unit', 'integration', 'e2e'],
-    requiredElements: ['test-strategy']
-  },
-  {
-    id: 'bal-49',
+    id: 'bal-24',
     phase: 'task-breakdown',
-    number: 49,
-    total: 50,
-    text: 'What is the estimated effort per major task?',
-    guidance: 'Time/effort estimates (hours or days)',
-    goodExample: 'Setup: 4h. Auth: 8h. Applications API: 12h. Dashboard UI: 16h. Search: 6h. Reminders: 8h. CSV: 6h. Testing: 12h. Deploy: 4h. Total: ~76h',
-    badExample: 'Some time',
-    keywords: ['estimate', 'effort', 'hours', 'days'],
-    requiredElements: ['estimates']
+    number: 24,
+    total: 25,
+    text: 'What are the key milestones and critical path?',
+    guidance: 'Major checkpoints and tasks that block other tasks (must be done first)',
+    goodExample: 'Critical path: Setup → Auth → Applications API → Dashboard (blocks everything else). Milestones: M1: Auth working (Week 1). M2: CRUD functional (Week 2). M3: Search + reminders (Week 3). M4: Production deploy (Week 4)',
+    badExample: 'Important milestones',
+    keywords: ['milestone', 'checkpoint', 'critical', 'blocker', 'dependency', 'blocks'],
+    requiredElements: ['milestones', 'critical-path']
   },
   {
-    id: 'bal-50',
+    id: 'bal-25',
     phase: 'task-breakdown',
-    number: 50,
-    total: 50,
-    text: 'What is the definition of done for the entire project?',
+    number: 25,
+    total: 25,
+    text: 'What is the project definition of done?',
     guidance: 'Complete checklist for project completion',
     goodExample: '✓ All P0 features working ✓ 80% test coverage ✓ No critical bugs ✓ Performance targets met ✓ Docs complete ✓ Deployed to production ✓ Users can sign up and track applications ✓ Email reminders working',
     badExample: 'Done',
@@ -633,15 +333,7 @@ const balancedQuestions = [
 
 // Comprehensive Framework Questions (Level 3: Agent-Native)
 const bmadQuestions = [
-  ...balancedQuestions, // Include all 50 Balanced questions
-
-  // BMAD-specific additions start here...
-  // This would continue with the full BMAD question set
-  // For now, I'll add the structure showing it extends Balanced
-
-  // Note: Full BMAD implementation would add 50 more questions here
-  // covering Business Analysis, Market Analysis, Advanced Architecture, etc.
-  // Keeping file size manageable for now - can expand if needed
+  ...balancedQuestions // Include all 25 Balanced questions
 ];
 
 module.exports = {