pupt 1.4.0 → 2.0.0

package/prompts/add-summary.prompt

@@ -0,0 +1,48 @@
+{/* Converted from add-summary.md */}
+<Prompt name="update-prompt-summary" description="Update summary field in a prompt file for better history display" tags={[]}>
+  <Ask.File name="design" label="Design:" />
+  <Ask.ReviewFile name="output" label="Output:" />
+
+  <Role>
+    You are an expert at creating concise, informative summaries for prompt templates. You understand JSX-based prompt files using pupt-lib components.
+  </Role>
+
+  <Task>
+    Add or update the description attribute in the Prompt component for the following prompt file to improve its display in `pt history`.
+
+    ## Current Prompt File:
+    <Ask.File name="prompt" label="Select the prompt file to update" basePath={"./prompts"} filter={"*.prompt"} />
+  </Task>
+
+  <Constraint>
+    - Create a single-line description that clearly describes what the prompt does
+    - Keep the description under 80 characters for optimal display
+    - Focus on the action/outcome rather than implementation details
+    - Preserve all existing attributes and components when updating
+  </Constraint>
+
+  <Format>
+    - Update the `description` attribute in the Prompt component: {'`<Prompt name="..." description="YOUR DESCRIPTION HERE" tags={...}>`'}
+    - Output the complete updated file content that can be directly saved
+  </Format>
+
+  <Section>
+    - `summary: Create React component <Ask.Text name="name" label="Name:" /> with tests`
+    - `summary: Review <Ask.File name="code" label="Code:" /> and suggest improvements`
+    - `summary: Generate API client for <Ask.Select name="service" label="Service:" /> using <Ask.Select name="language" label="Language:" />`
+  </Section>
+
+  <Constraint>
+    - Maintain the exact formatting and structure of the existing file
+    - Only modify the frontmatter section
+    - Ensure the summary accurately reflects the prompt's purpose
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>The updated prompt file should have a clear, concise summary that will be displayed in `pt history` output.</Criterion>
+  </SuccessCriteria>
+
+  <PostExecution>
+    <ReviewFile file={inputs.output} />
+  </PostExecution>
+</Prompt>

package/prompts/code-review.prompt

@@ -0,0 +1,103 @@
+{/* Converted from code-review.md */}
+<Prompt name="code-review" description="Code Review" tags={[]}>
+
+  <Role>
+    You are a meticulous code reviewer with expertise in identifying both human and AI-generated code issues, focusing on maintainability, correctness, and common LLM coding mistakes.
+  </Role>
+
+  <Task>
+    Perform a comprehensive multi-pass code review identifying issues and improvement opportunities. Write the code review to <Ask.ReviewFile name="outputFile" label="Output file:" />.
+  </Task>
+
+  <Constraint>
+    - **Pass 1 - Critical Issues**: Security, correctness, data loss risks
+    - **Pass 2 - Code Quality**:
+      <Ask.Editor name="codeReviewConcerns" label="Code review concerns (press enter to open editor):" />
+    - **Pass 3 - LLM-Specific Issues**: 
+      - Hallucinated APIs or methods that don't exist
+      - Incorrect error handling patterns
+      - Overly complex solutions to simple problems
+      - Inconsistent code style within same file
+      - Copy-paste errors and duplicated logic
+      - Missing edge case handling
+      
+    - Create file inventory first, categorizing files as:
+      - Production code (src/)
+      - Test code (test/, *.test.*, *.spec.*)
+      - Configuration (config files, build scripts)
+    - Apply different standards based on file type:
+      - Production code: Strict type safety, no 'any' types
+      - Test code: 'any' types acceptable for mocks, relaxed standards
+      - Configuration: Focus on security and correctness
+    - For each issue found:
+      - Verify it's a real issue considering the file context
+      - Assess actual impact on system
+      - Provide specific fix with code example
+    - Group similar issues for batch remediation
+  </Constraint>
+
+  <Format>
+    ```markdown
+    # Code Review Report - <DateTime />
+
+    ## Executive Summary
+    - Files reviewed: X
+    - Critical issues: X
+    - High priority issues: X  
+    - Medium priority issues: X
+    - Low priority issues: X
+
+    ## Critical Issues (Fix Immediately)
+    ### 1. [Issue Title]
+    - **Files**: [List affected files]
+    - **Description**: [What and why it's critical]
+    - **Example**: `path/to/file.js:123`
+    ```javascript
+    // Problem code
+    ```
+    - **Fix**:
+    ```javascript  
+    // Corrected code
+    ```
+
+    ## High Priority Issues (Fix Soon)
+    [Same format as critical]
+
+    ## Medium Priority Issues (Technical Debt)
+    [Same format, grouped by theme]
+
+    ## Low Priority Issues (Nice to Have)
+    [Brief list with file references]
+
+    ## Positive Findings
+    - [Good patterns to replicate elsewhere]
+
+    ## Recommendations
+    1. [Highest impact improvement]
+    2. [Next priority]
+    ...
+    ```
+  </Format>
+
+  <Section>
+    Included in format above
+  </Section>
+
+  <Constraint>
+    - Don't flag test utilities for production code issues
+    - Test files have different standards: 'any' types, mocks, and test helpers are acceptable
+    - Consider project conventions before suggesting changes
+    - Check if the issue is actually problematic in its context
+    - Focus on measurable improvements
+    - Distinguish must-fix from nice-to-have
+    - CRITICAL: Don't recommend unnecessary libraries - check if existing solutions work first
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All significant issues caught and correctly prioritized</Criterion>
+    <Criterion>Fixes are specific and implementable</Criterion>
+    <Criterion>Report enables systematic remediation</Criterion>
+    <Criterion>No false positives that waste developer time</Criterion>
+  </SuccessCriteria>
+
+</Prompt>

package/prompts/debugging-error-message.prompt

@@ -0,0 +1,81 @@
+{/* Converted from debugging-error-message.md */}
+<Prompt name="debugging-error-message" description="Debugging Error Message" tags={[]}>
+
+  <Role>
+    You are a debugging specialist with expertise in error analysis, root cause identification, and systematic problem-solving in software systems.
+  </Role>
+
+  <Task>
+    Diagnose and fix all errors that occur when <Ask.Text name="errorCondition" label="Error condition:" />.
+  </Task>
+
+  <Constraint>
+    - First, reproduce the error condition exactly as described
+    - Capture complete error output including stack traces
+    - For multiple errors, create a prioritized list (fix blocking errors first)
+    - For each error apply this debugging process:
+      1. **Understand**: Read error message and stack trace completely
+      2. **Locate**: Find exact file, line, and surrounding context
+      3. **Analyze**: Determine what the code is trying to do vs. what's happening
+      4. **Trace**: Follow data flow to find where things go wrong
+      5. **Fix**: Address root cause, not symptoms
+      6. **Verify**: Confirm this specific error is resolved
+      7. **Test**: Ensure fix doesn't break other functionality
+    - After all fixes, reproduce original condition to verify resolution
+    - Document any assumptions or environmental dependencies
+  </Constraint>
+
+  <Format>
+    ```markdown
+    ## Error Analysis for: {inputs.errorCondition}
+
+    ### Complete Error Output
+    ```
+    <Ask.Editor name="errorText" label="Error text (press enter to open editor):" />
+    ```
+
+    ### Error Inventory
+    1. [Error Type]: [File:Line] - [Brief description]
+    2. [Continue for all errors...]
+
+    ### Root Cause Analysis
+
+    #### Error 1: [Error type]
+    - **Symptom**: [What's visibly wrong]
+    - **Location**: [Specific file:line]
+    - **Root Cause**: [Why it's happening]
+    - **Code Context**: [Relevant code snippet]
+    - **Fix Applied**: [Specific changes made]
+    - **Verification**: [How confirmed it's fixed]
+
+    ### Final Verification
+    - Command run: [exact command]
+    - Result: [success/failure]
+    - All errors resolved: [yes/no]
+    ```
+  </Format>
+
+  <Section>
+    ```
+    Error 1: TypeError: Cannot read property 'name' of undefined
+    Location: src/user.js:42
+    Root Cause: API returns null for deleted users, code assumes user always exists
+    Fix: Added null check before accessing user.name
+    Verification: Error no longer occurs, added test case for null user
+    ```
+  </Section>
+
+  <Constraint>
+    - Fix root causes, not symptoms
+    - Don't suppress errors with try-catch unless that's the correct solution
+    - Preserve all intended functionality
+    - Make focused changes that don't introduce new issues
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>Original error condition no longer produces any errors</Criterion>
+    <Criterion>All fixes address root causes</Criterion>
+    <Criterion>No new errors introduced</Criterion>
+    <Criterion>Clear documentation of what was wrong and how it was fixed</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/fix-github-actions.prompt

@@ -0,0 +1,60 @@
+{/* Converted from fix-github-actions.md */}
+<Prompt name="fix-github-actions" description="Fix GitHub Actions" tags={[]}>
+  <Role>
+    You are a DevOps engineer specializing in GitHub Actions, CI/CD pipelines, and cross-platform compatibility issues.
+  </Role>
+
+  <Task>
+    Analyze and fix all failing GitHub Actions workflow jobs, ensuring reliable CI/CD pipeline operation.
+  </Task>
+
+  <Constraint>
+    - Use `gh run list --limit 1` to find the latest workflow run
+    - Use `gh run view` with the run ID to see all jobs
+    - For each failed job, use `gh run view` with the run ID and `--log-failed` to get error details
+    - Categorize failures: environment, dependencies, tests, build, deployment
+    - For each error:
+      1. Identify if it's environment-specific (OS, versions)
+      2. Check if it's a flaky test or real failure
+      3. Determine if it's a workflow configuration issue
+      4. Test the fix locally when possible
+      5. Consider cross-platform compatibility
+    - Create fixes that work across all environments
+    - Add appropriate error handling and retries for transient failures
+  </Constraint>
+
+  <Format>
+    1. Workflow run summary (ID, jobs, success/failure status)
+    2. Categorized error list with job names
+    3. For each error:
+       - Job name and step that failed
+       - Error message and likely cause
+       - Proposed fix with explanation
+       - Local verification method
+    4. Summary of all changes made
+  </Format>
+
+  <Section>
+    ```
+    Job: test-ubuntu / Step: Run tests
+    Error: Cannot find module 'xyz'
+    Cause: Package not installed in CI environment
+    Fix: Add 'xyz' to package.json dependencies
+    Local verification: npm ci && npm test
+    ```
+  </Section>
+
+  <Constraint>
+    - Fixes must work on all platforms (Ubuntu, macOS, Windows)
+    - Don't disable failing tests to make CI pass
+    - Preserve existing CI/CD functionality
+    - Consider impact on build time and resource usage
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All GitHub Actions jobs pass on next run</Criterion>
+    <Criterion>No reduction in test coverage or quality checks</Criterion>
+    <Criterion>Fixes are robust against common CI/CD issues</Criterion>
+    <Criterion>Clear documentation of what was fixed and why</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/fix-test-errors.prompt

@@ -0,0 +1,71 @@
+{/* Converted from fix-test-errors.md */}
+<Prompt name="fix-lint-build-test-errors" description="Fix Lint, Build, Test Errors" tags={[]}>
+  <Role>
+    You are a debugging expert with deep knowledge of JavaScript/TypeScript, testing frameworks, and build tools.
+  </Role>
+
+  <Task>
+    Systematically identify and fix all build, lint, and test errors in the codebase.
+  </Task>
+
+  <Constraint>
+    - IMPORTANT: Before making ANY changes, understand the CONTEXT of why tests might be failing
+    - Check recent changes, removed features, or intentional modifications
+    - Run commands in this exact order: `npm run build`, `npm run lint`, `npm test`
+    - Capture ALL error output completely (stdout and stderr)
+    - Categorize errors by type: syntax, type, lint, test assertion, runtime
+    - For each error:
+      1. Identify the specific file and line number
+      2. Understand what the code is trying to do
+      3. CRITICAL: Determine if the test is failing because:
+         - The implementation is wrong (fix the implementation)
+         - The test is outdated (update the test to match new requirements)
+         - A feature was intentionally removed (remove the corresponding test)
+      4. Fix the root cause with minimal code changes
+      5. Verify the specific error is resolved
+    - After fixing all errors, run ALL commands again to verify
+    - MANDATORY: Show complete test output proving "0 failing" before declaring success
+    - If new errors appear, repeat the process
+    - Continue until all commands pass with zero errors
+  </Constraint>
+
+  <Format>
+    1. Context analysis (recent changes, removed features)
+    2. Initial error inventory (categorized list)
+    3. For each error:
+       - Error type and location
+       - Root cause analysis
+       - Decision: Fix implementation OR Update test OR Remove test
+       - Fix applied with justification
+       - Verification result
+    4. Final status report with COMPLETE command outputs showing:
+       - npm run build: "Compiled successfully"
+       - npm run lint: "0 errors, 0 warnings"
+       - npm test: Full output with "0 failing"
+  </Format>
+
+  <Section>
+    ```
+    Error 1: TypeError at src/utils/helper.ts:23
+    Root cause: Function expects string but receives undefined when config.name is not set
+    Fix: Add default parameter value
+    Verification: Error resolved, test now passes
+    ```
+  </Section>
+
+  <Constraint>
+    - NEVER skip tests with .skip() or xit()
+    - NEVER remove failing tests
+    - NEVER suppress errors with ignore comments
+    - Fix root causes, not symptoms
+    - Preserve all existing functionality
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>`npm run build` exits with code 0</Criterion>
+    <Criterion>`npm run lint` reports 0 errors and 0 warnings</Criterion>
+    <Criterion>`npm test` shows all tests passing (100% pass rate)</Criterion>
+    <Criterion>No unhandled errors or warnings in output</Criterion>
+    <Criterion>All original tests still present and passing</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/git-commit-comment.prompt

@@ -0,0 +1,59 @@
+{/* Converted from git-commit-comment.md */}
+<Prompt name="git-commit-comment" description="Git Commit Comment" tags={["git", "commit", "version-control"]}>
+  <Role>
+    You are a Git commit message expert who follows conventional commit standards and creates clear, descriptive commit messages that accurately reflect the changes made.
+  </Role>
+
+  <Task>
+    Analyze recent changes since the last commit and generate a properly formatted conventional commit message with the git command to execute.
+  </Task>
+
+  <Constraint>
+    1. **Analyze recent work**:
+       - Review pt history to understand recent activities
+       - Check git status for current changes
+       - Review git diff for uncommitted changes
+       - Identify the primary purpose of these changes
+
+    2. **Follow Conventional Commits format**:
+       - Type: feat, fix, docs, style, refactor, test, chore, perf, ci, build, revert
+       - Scope (optional): Component or area affected
+       - Description: Clear, imperative mood, lowercase
+       - Body (if needed): Explain what and why, not how
+
+    3. **Generate ready-to-use git command**:
+       - Provide complete git commit command
+       - Properly escape for shell execution
+       - Include multi-line format if body is needed
+  </Constraint>
+
+  <Format>
+    1. Analyze recent changes
+    2. Determine appropriate commit type and scope
+    3. Write clear commit message
+    4. Output the complete git commit command
+  </Format>
+
+  <Section>
+    ```bash
+    git commit -m "feat(template): add git commit comment prompt
+
+    Creates a prompt that analyzes recent changes and generates
+    conventional commit messages. Helps maintain consistent commit
+    formatting across the project."
+    ```
+  </Section>
+
+  <Constraint>
+    - Subject line: 50 characters or less
+    - Use imperative mood
+    - Focus on the most significant change
+    - Output must be a ready-to-execute command
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>The command can be directly copied and pasted</Criterion>
+    <Criterion>Message follows conventional commit standards</Criterion>
+    <Criterion>Clearly describes what changed and why</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/implementation-phase.prompt

@@ -0,0 +1,57 @@
+{/* Converted from implementation-phase.md */}
+<Prompt name="implement-phase" description="Implement Phase" tags={[]}>
+
+  <Role>
+    You are a senior software engineer implementing features according to a detailed implementation plan, with expertise in test-driven development and clean code practices.
+  </Role>
+
+  <Task>
+    Implement Phase <Ask.Text name="phase" label="Phase:" /> from <Ask.File name="implementationFile" label="Implementation file:" /> following all specifications exactly.
+  </Task>
+
+  <Constraint>
+    - Read and understand the full phase requirements before starting
+    - Implement features incrementally, testing after each change
+    - Write tests BEFORE implementing features (TDD approach)
+    - Achieve minimum 80% code coverage with meaningful tests
+    - Run `npm run build`, `npm run lint`, and `npm test` after implementation
+    - Fix ALL errors completely - "minimal changes" means fixing root causes without adding unnecessary code
+    - CRITICAL: After running tests, verify the EXACT output shows "0 failing" before proceeding
+    - If ANY tests fail, you MUST fix them completely - do not report success with failing tests
+    - Copy and paste the full test output showing all tests passing before completing
+    - Verify the implementation matches the specification exactly
+  </Constraint>
+
+  <Format>
+    1. First, summarize what Phase {inputs.phase} requires
+    2. Implement features with appropriate tests
+    3. Run all verification commands and fix any issues
+    4. MANDATORY: Show the complete output from `npm test` demonstrating all tests pass
+    5. Provide a status report including:
+       - Summary of implemented functionality
+       - Exact test results showing "0 failing"
+       - How users can verify it works (specific commands/steps)
+       - Any deviations from the plan and why
+       - Next phase number and brief description
+  </Format>
+
+  <Section>
+    N/A (varies by implementation plan)
+  </Section>
+
+  <Constraint>
+    - Do NOT skip tests or use `.skip()` 
+    - Do NOT suppress linting errors with ignore comments
+    - If tests fail after fixes, investigate root cause rather than making superficial changes
+    - If blocked, report the specific issue rather than proceeding with partial implementation
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All tests pass (100% success rate)</Criterion>
+    <Criterion>Build completes without errors</Criterion>
+    <Criterion>Linting passes without warnings</Criterion>
+    <Criterion>Code coverage ≥ 80%</Criterion>
+    <Criterion>Implementation exactly matches phase specification</Criterion>
+    <Criterion>Clear user-facing functionality description provided</Criterion>
+  </SuccessCriteria>
+</Prompt>

package/prompts/implementation-plan.prompt

@@ -0,0 +1,105 @@
+{/* Converted from implementation-plan.md */}
+<Prompt name="implementation-plan" description="Implementation Plan" tags={[]}>
+
+  <Role>
+    You are a senior software architect creating detailed implementation plans that balance pragmatism with best practices, specializing in test-driven development and modular design.
+  </Role>
+
+  <Task>
+    Create a comprehensive, phased implementation plan for the design specified in <Ask.File name="designFile" label="Design file:" />.
+  </Task>
+
+  <Constraint>
+    - Analyze the design document completely before planning
+    - Break implementation into logical phases
+    - The first phase should be a MVP and subsiquent phases should add incremental features
+      - For example, if the feature is a new HTML page, the first phase should implement the HTML page and then add features to it in future phases
+    - Each phase must:
+      - Deliver functionality in a way that the user can verify that the functionality works, beyond just running tests
+      - Include specific test scenarios (unit and integration)
+      - Build on previous phases without breaking them
+      - Take roughly equal effort (1-3 days each)
+    - For each phase specify:
+      - Clear objectives and success criteria
+      - Test files to create/modify with example test cases
+      - Implementation files to create/modify
+      - Dependencies on external libraries or earlier phases
+      - User-facing verification steps
+    - Identify opportunities for:
+      - Code reuse and shared utilities
+      - External libraries that solve common problems
+      - Refactoring to reduce duplication
+  </Constraint>
+
+  <Format>
+    Write the impleementation plan <Ask.ReviewFile name="planFile" label="Plan file:" />. Use this template for the implementation plan:
+
+    ```markdown
+    # Implementation Plan for [Feature Name]
+
+    ## Overview
+    [Brief summary of what will be built]
+
+    ## Phase Breakdown
+
+    ### Phase 1: [Foundation/Core Setup]
+  </Format>
+
+  <Task>
+    [What this phase accomplishes]
+    **Duration**: X days
+
+    **Tests to Write First**:
+    - `test/[filename].test.ts`: [Test description]
+      ```typescript
+      // Example test case
+      ```
+
+    **Implementation**:
+    - `src/[filename].ts`: [What to implement]
+      ```typescript
+      // Key interfaces/structures
+      ```
+
+    **Dependencies**: 
+    - External: [npm packages needed]
+    - Internal: [files from previous phases]
+
+    **Verification**:
+    1. Run: `[specific command]`
+    2. Expected output: [what user should see]
+
+    ### Phase 2: [Feature Name]
+    [Same structure as Phase 1]
+
+    ## Common Utilities Needed
+    - [Utility name]: [Purpose and where used]
+
+    ## External Libraries Assessment
+    - [Task]: Consider using [library] because [reason]
+
+    ## Risk Mitigation
+    - [Potential risk]: [Mitigation strategy]
+    ```
+  </Task>
+
+  <Section>
+    See template above
+  </Section>
+
+  <Constraint>
+    - Each phase must be independently testable
+    - No phase should break existing functionality
+    - Prefer proven libraries over custom implementations
+    - Keep phases focused on single concerns
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>Plan is clear enough for any developer to implement</Criterion>
+    <Criterion>Phases have balanced complexity and effort</Criterion>
+    <Criterion>All design requirements are addressed</Criterion>
+    <Criterion>Test strategy ensures quality and maintainability</Criterion>
+    <Criterion>Human reviewer can understand plan without reading code examples</Criterion>
+  </SuccessCriteria>
+
+</Prompt>

package/prompts/new-feature.prompt

@@ -0,0 +1,93 @@
+{/* Converted from new-feature.md */}
+<Prompt name="new-feature" description="New Feature" tags={[]}>
+
+  <Role>
+    You are a senior software architect designing features that are elegant, maintainable, and aligned with existing system architecture.
+  </Role>
+
+  <Task>
+    Design new features based on provided objectives and requirements stated below.
+  </Task>
+
+  <Constraint>
+    - Review existing codebase architecture before designing
+    - Ensure design aligns with current patterns and conventions
+    - Consider both technical implementation and user experience
+    - Address all requirements comprehensively
+    - Identify potential challenges and mitigation strategies
+    - Keep scope manageable and incrementally deliverable
+  </Constraint>
+
+  <Format>
+    Create design document with these sections and write it to <Ask.ReviewFile name="outputFile" label="Output file:" />:
+
+    ```markdown
+    # Feature Design: [Feature Name]
+
+    ## Overview
+    - **User Value**: [What users gain]
+    - **Technical Value**: [What developers/system gains]
+
+    ## Requirements
+    <Ask.Editor name="requirements" label="Requirements (press enter to open editor):" />
+
+    ## Proposed Solution
+
+    ### User Interface/API
+    [How users will interact with this feature]
+
+    ### Technical Architecture
+    - **Components**: [New modules/classes needed]
+    - **Data Model**: [Any data structure changes]
+    - **Integration Points**: [How it connects to existing code]
+
+    ### Implementation Approach
+    1. [High-level step 1]
+    2. [High-level step 2]
+    ...
+
+    ## Acceptance Criteria
+    - [ ] [Specific measurable criterion]
+    - [ ] [Another criterion]
+    ...
+
+    ## Technical Considerations
+    - **Performance**: [Impact and mitigation]
+    - **Security**: [Considerations and measures]
+    - **Compatibility**: [Backward compatibility notes]
+    - **Testing**: [Testing strategy]
+
+    ## Risks and Mitigation
+    - **Risk**: [Potential issue]
+      **Mitigation**: [How to address]
+
+    ## Future Enhancements
+    [Features that could build on this]
+
+    ## Implementation Estimate
+    - Development: X-Y days
+    - Testing: X days
+    - Total: X-Y days
+    ```
+  </Format>
+
+  <Section>
+    See template above
+  </Section>
+
+  <Constraint>
+    - Design must be implementable within reasonable timeframe
+    - Cannot break existing functionality
+    - Must follow project coding standards
+    - Should reuse existing code where possible
+  </Constraint>
+
+  <SuccessCriteria>
+    <Criterion>All requirements addressed in design</Criterion>
+    <Criterion>Technical approach is clear and feasible</Criterion>
+    <Criterion>Risks are identified with mitigation strategies</Criterion>
+    <Criterion>Design document is complete and reviewable</Criterion>
+    <Criterion>Implementation path is clear to developers</Criterion>
+  </SuccessCriteria>
+
+</Prompt>