pupt 2.2.1 → 2.3.0

package/prompts/git-commit-comment.prompt

@@ -1,61 +0,0 @@
-{/* Converted from git-commit-comment.md */}
-<Prompt name="git-commit-comment" description="Git Commit Comment" tags={["git", "commit", "version-control"]}>
-  <Role preset="engineer" extend expertise="git, conventional commits">
-    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>
-
-  <Constraints extend>
-    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
-  </Constraints>
-
-  <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>
-
-  <Examples>
-    <Example>
-    ```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."
-    ```
-    </Example>
-  </Examples>
-
-  <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

@@ -1,53 +0,0 @@
-{/* Converted from implementation-phase.md */}
-<Prompt name="implement-phase" description="Implement Phase" tags={[]}>
-
-  <Role preset="engineer" extend expertise="test-driven development, clean code practices">
-    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>
-
-  <Constraints extend>
-    - 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
-  </Constraints>
-
-  <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>
-
-  <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

@@ -1,101 +0,0 @@
-{/* Converted from implementation-plan.md */}
-<Prompt name="implementation-plan" description="Implementation Plan" tags={[]}>
-
-  <Role preset="architect" extend expertise="test-driven development, modular design">
-    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>
-
-  <Constraints extend>
-    - 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
-  </Constraints>
-
-  <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>
-
-  <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

@@ -1,89 +0,0 @@
-{/* Converted from new-feature.md */}
-<Prompt name="new-feature" description="New Feature" tags={[]}>
-
-  <Role preset="architect" extend>
-    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>
-
-  <Constraints extend>
-    - 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
-  </Constraints>
-
-  <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>
-
-  <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>

package/prompts/new-project.prompt

@@ -1,9 +0,0 @@
-{/* Converted from new-project.md */}
-<Prompt name="new-project" description="New Project" tags={[]}>
-  <Section>
-    Create a design for a new project called <Ask.Text name="projectName" label="Project name:" />. The project is written in <Ask.Text name="programmingLanguage" label="Programming language:" />. The purpose of the project is to: <Ask.Text name="projectPurpose" label="Project purpose:" />. The requirements for the project are:
-    <Ask.Editor name="requirements" label="Requirements (press enter to open editor):" />
-
-    The design will use the current directory as the base for the project, do not create a directory under this one. The design should include scaffolding for the project for building, linting, testing, and code coverage. My preferred tools are: <Ask.Text name="preferredTools" label="Preferred tools:" />. Create the design in <Ask.Text name="designFile" label="Design file:" />. List all the tools that will be used for the scaffolding near the top of the file. Make sure the design file is easy for a human to read and edit, but it should include sufficient detail for AI tooling to create an implementation plan.
-  </Section>
-</Prompt>

package/prompts/one-shot-change.prompt

@@ -1,79 +0,0 @@
-{/* Converted from one-shot-change.md */}
-<Prompt name="one-shot-change" description="One Shot Change" tags={["development", "implementation", "quick-fix"]}>
-
-  <Role preset="engineer" extend>
-    You are a precise software engineer focused on making targeted changes with minimal impact while ensuring code quality and test integrity.
-  </Role>
-
-  <Task>
-    Implement the specific changes requested below, then verify the implementation meets all quality standards.
-  </Task>
-
-  <Constraints extend>
-    1. **Analyze the requested changes**:
-       - Understand the exact scope and intent
-       - Identify affected files and components
-       - Consider potential side effects
-
-    2. **Implement with precision**:
-       - Make ONLY the changes necessary to fulfill the request
-       - Preserve existing functionality unless explicitly changing it
-       - Follow existing code patterns and conventions
-       - Maintain consistent code style
-
-    3. **Verify implementation** (MANDATORY):
-       - Run `npm test` and ensure ALL tests pass (show output with "0 failing")
-       - Run `npm run lint` and fix any errors (must show "0 errors")
-       - Run `npm run build` and ensure successful completion
-       - If any command fails, fix the issues and re-run ALL verification steps
-
-    4. **Handle errors systematically**:
-       - If tests fail, determine if implementation or test needs updating
-       - Make MINIMAL changes to fix errors
-       - Document any assumptions made
-       - Re-verify after each fix
-
-    **Requested Changes**:
-    <Ask.Editor name="changes" label="Changes (press enter to open editor):" />
-  </Constraints>
-
-  <Format>
-    1. Brief analysis of the requested changes
-    2. List of files to be modified
-    3. Implementation of changes
-    4. Verification results showing:
-       - Test output with "0 failing"
-       - Lint output with "0 errors"
-       - Build output showing success
-    5. Summary of changes made
-  </Format>
-
-  <Examples>
-    <Example>
-    ```
-    Requested: Add validation to user input
-    Analysis: Need to add input validation to prevent empty strings
-    Files affected: src/user.js, test/user.test.js
-    Implementation: Added validation check with appropriate error
-    Verification: All tests passing (0 failing), no lint errors, build successful
-    ```
-    </Example>
-  </Examples>
-
-  <Constraint>
-    - DO NOT make unrelated "improvements" or refactoring
-    - DO NOT modify test expectations unless the change requires it
-    - DO NOT skip or disable any tests
-    - DO NOT use @ts-ignore or eslint-disable comments
-    - Changes must be minimal and focused
-  </Constraint>
-
-  <SuccessCriteria>
-    <Criterion>✅ Requested changes are fully implemented</Criterion>
-    <Criterion>✅ All tests pass (npm test shows "0 failing")</Criterion>
-    <Criterion>✅ No lint errors (npm run lint shows "0 errors")</Criterion>
-    <Criterion>✅ Build succeeds (npm run build completes without errors)</Criterion>
-    <Criterion>✅ No functionality is broken</Criterion>
-    <Criterion>✅ Changes are minimal and targeted</Criterion>
-  </SuccessCriteria>
-</Prompt>

package/prompts/pupt-prompt-improvement.prompt

@@ -1,270 +0,0 @@
-{/* Converted from pupt-prompt-improvement.md */}
-<Prompt name="pupt-prompt-improvement" description="PUPT Prompt Improvement" tags={[]}>
-
-  <Role>
-    You are an expert prompt engineer and performance analyst specializing in identifying failure patterns in AI-assisted development workflows. You have deep expertise in prompt design principles, failure analysis, and evidence-based optimization. You will actively modify prompt files to implement improvements.
-  </Role>
-
-  <Task>
-    Use the `pt review` command to analyze comprehensive usage data for AI prompts and DIRECTLY UPDATE prompt files to:
-    1. Fix documented failure patterns by modifying existing prompt files
-    2. Create new prompt files for repeated Ad Hoc usage patterns
-    3. Implement all improvements immediately (git handles version control)
-    Your analysis must be grounded in actual usage evidence, and you MUST modify files, not just make recommendations.
-  </Task>
-
-  <Constraint>
-    1. **Run the review command**: Execute `pt review --format json > <Ask.Text name="reviewDataFile" label="Review data file path" default={"review.json"} />` to generate comprehensive usage data
-    2. **Read the review data**: Load and analyze the JSON file containing:
-       - Usage statistics with execution outcomes and timing
-       - Active execution time (excluding user input wait time)
-       - User input frequency and patterns
-       - Environment correlations and timing patterns
-       - User annotations with structured issue data
-       - Output capture analysis with error indicators
-       - Detected patterns with frequency and severity metrics
-    3. **Analyze patterns with evidence**:
-       - Focus on patterns with ≥3 occurrences (statistical significance)
-       - Correlate failures with environmental factors
-       - Extract specific evidence quotes from annotations
-       - Calculate pattern impact (frequency × severity)
-       - Identify repeated Ad Hoc prompt content/themes
-       - Detect common prompt structures and workflows
-       - Analyze execution timing patterns:
-         * Prompts requiring excessive user input (high avg_user_inputs)
-         * Prompts with high active time but many failures
-         * Correlation between user input frequency and failure rates
-    4. **Review ALL prompts for completeness and structure**:
-       - Read every prompt file regardless of execution count
-       - Check for proper prompt structure (Role, Objective, Requirements, etc.)
-       - Verify all prompts have:
-         * Clear role and context definition
-         * Specific objective statement
-         * Detailed requirements or steps
-         * Success criteria
-         * Appropriate constraints
-       - Identify minimal or incomplete prompts (e.g., single-line prompts)
-       - Flag prompts missing critical elements like verification steps
-    5. **DIRECTLY UPDATE existing prompt files**:
-       - Use the Edit tool to modify prompts with identified issues
-       - For prompts with usage data: Every change must cite specific evidence
-       - For prompts without usage data: Improve based on best practices
-       - Address root causes, not symptoms
-       - Preserve successful prompt elements
-       - Add verification steps for all implementation prompts
-       - Replace ambiguous terms with measurable criteria
-       - Ensure all prompts follow consistent structure
-       - Confirm each edit is successful before proceeding
-    6. **CREATE new prompt files**:
-       - Use the Write tool to create new prompts for repeated Ad Hoc patterns
-       - Each new prompt must address ≥3 similar Ad Hoc uses
-       - Include proper frontmatter (title, author, tags)
-       - Base templates on common patterns found in Ad Hoc usage
-       - Test that new prompts are discoverable with `pt list`
-  </Constraint>
-
-  <Format>
-    Create <Ask.Text name="promptReviewFile" label="Prompt review output file" default={"design/prompt-review.md"} /> documenting the changes made:
-
-    ```markdown
-    # Prompt Performance Analysis & Implementation Report
-    *Generated: [Current Date]*
-    *Analysis Period: <Ask.Text name="timeframe" label="Analysis timeframe" default={"30d"} />*
-
-    ## Executive Summary
-    - **Prompts Analyzed**: X prompts with Y total executions
-    - **Prompts Modified**: X files updated
-    - **New Prompts Created**: Y new prompt files
-    - **Key Finding**: [Most significant pattern discovered]
-    - **Overall Success Rate**: X% → Y% (after improvements)
-    - **Average Active Execution Time**: Xms → Yms (after improvements)
-    - **Average User Inputs Required**: X → Y (after improvements)
-
-    ## Prompt Completeness Review
-
-    ### Prompts Requiring Structure Improvements
-    | Prompt | Current State | Missing Elements | Priority |
-    |--------|--------------|------------------|----------|
-    | [name] | [e.g., "Minimal 3-line prompt"] | [e.g., "Role, Requirements, Success Criteria"] | [High/Medium/Low] |
-
-    ## Implemented Improvements
-
-    ### 1. [Prompt Name] - [Pattern Type] (Priority: Critical/High/Medium) ✅
-    **Evidence**: 
-    - Pattern frequency: X occurrences across Y executions
-    - Success rate impact: X% → Y% projected improvement
-    - Timing impact: Average active time Xms, with Y user inputs
-    - User quotes: "[specific user feedback]"
-    - Output indicators: [specific failure signals from captured output]
-    - Structure issues: [if applicable, e.g., "Minimal prompt lacking guidance"]
-
-    **Root Cause**: [Specific analysis of why this pattern occurs]
-
-    **Changes Made**:
-    - File: `prompts/[filename].prompt`
-    - Action: Modified using Edit tool
-    - Specific changes:
-      - Added: "[what was added]"
-      - Removed: "[what was removed]"
-      - Modified: "[what was changed]"
-
-    **Before**:
-    ```
-    [Quote problematic sections that were fixed]
-    ```
-
-    **After**:
-    ```
-    [Show the updated sections]
-    ```
-
-    **Expected Impact**: 
-    - Success rate improvement: X% → Y%
-    - Reduced verification gaps: X → Y occurrences
-    - Environmental resilience: [specific improvements]
-    - Reduced user interventions: X → Y inputs per run
-    - Faster execution: Xms → Yms active time
-    - Improved clarity and guidance for users
-
-    [Repeat for each implemented improvement]
-
-    ## New Prompts Created
-
-    ### 1. [Prompt Name] (Addressed X Ad Hoc uses) ✅
-    **Evidence of Need**:
-    - Ad Hoc prompts with similar content: X occurrences
-    - Common phrases: "[repeated text patterns]"
-    - Typical use cases: [list specific scenarios]
-
-    **File Created**: `prompts/[filename].prompt`
-    **Action**: Created using Write tool
-
-    **Prompt Content**:
-    ```jsx
-    <Prompt name="[prompt-name]" description="[Prompt Name]" tags={["relevant", "tags"]}>
-      <Ask.Text name="input" label="Input:" />
-
-      <Role>[Role description]</Role>
-      <Task>[Task description with {inputs.input}]</Task>
-      <Constraint>[Constraints]</Constraint>
-      <SuccessCriteria>
-        <Criterion>[Success criterion]</Criterion>
-      </SuccessCriteria>
-    </Prompt>
-    ```
-
-    **Verification**:
-    - ✅ File created successfully
-    - ✅ Appears in `pt list` output
-    - ✅ Template variables work correctly
-    - ✅ Addresses the identified use cases
-
-    **Expected Benefits**:
-    - Standardizes common workflow covering X% of similar Ad Hoc uses
-    - Reduces prompt creation time from Y minutes to Z seconds
-    - Improves consistency across team members
-
-    [Repeat for each new prompt created]
-
-    ## Ad Hoc Usage Analysis
-    | Pattern | Frequency | Example Content | Proposed Prompt |
-    |---------|-----------|-----------------|-----------------|
-    | ...     | ...       | ...             | ...             |
-
-    ## Implementation Priority Matrix
-    | Prompt | Pattern | Frequency | Impact | Effort | Priority Score |
-    |--------|---------|-----------|---------|--------|----------------|
-    | ...    | ...     | ...       | ...     | ...    | ...            |
-
-    ## Environmental Risk Factors
-    - **Branch-specific failures**: [analysis of git branch correlations]
-    - **Time-based patterns**: [analysis of time-of-day success rates]
-    - **Directory-specific issues**: [analysis of working directory correlations]
-
-    ## Cross-Prompt Patterns
-    - **Pattern**: [Description]  
-      **Affected**: [Prompt names]  
-      **Recommendation**: [Global improvement strategy]
-
-    ## Monitoring Recommendations
-    - Track success rates for improved prompts
-    - Monitor for new pattern emergence
-    - Focus annotation collection on [specific areas]
-    - Track Ad Hoc prompt reuse to validate new prompt recommendations
-    ```
-  </Format>
-
-  <Examples>
-    <Example>
-    ```
-    Pattern: "verification_gap"
-    Evidence: 12 annotations across 5 prompts mention "tests still failing after AI claimed success"
-    Timing Analysis: Affected prompts average 3.2 user inputs (vs 0.8 for successful prompts)
-    Root Cause: Prompts lack explicit verification requirements
-    Fix: Add "After implementation, run 'npm test' and verify output shows '0 failing' before proceeding"
-    Expected Impact: 85% reduction in verification-related partial failures, 60% reduction in user inputs
-    ```
-    </Example>
-    <Example>
-    ```
-    Pattern: "incomplete_task"
-    Evidence: 8 annotations report "stopped at first error" with 15+ subsequent errors found
-    Timing Analysis: Average 5.1 user inputs needed to complete (active time: 4500ms across multiple runs)
-    Root Cause: Prompts use "fix the error" instead of "fix all errors"
-    Fix: Replace with "Continue debugging and fixing ALL errors until none remain"
-    Expected Impact: 70% reduction in incomplete task annotations, 80% faster completion
-    ```
-    </Example>
-    <Example>
-    ```
-    New Prompt Opportunity: "Dependency Update Workflow"
-    Evidence: 15 Ad Hoc prompts in past 30 days containing variations of "update dependencies" or "npm update"
-    Common Pattern: Users repeatedly asking to update packages, check for breaking changes, and run tests
-    Proposed Template: Standardized workflow for dependency updates with automated compatibility checks
-    Expected Impact: Replace 80% of dependency-related Ad Hoc prompts with consistent workflow
-    ```
-    </Example>
-    <Example>
-    ```
-    New Prompt Opportunity: "API Integration Testing"
-    Evidence: 8 Ad Hoc prompts containing "test API", "mock endpoint", or "integration test"
-    Common Pattern: Users creating similar API testing scenarios with slight variations
-    Proposed Template: Parameterized API testing prompt with endpoint, auth, and payload variables
-    Expected Impact: Reduce API testing prompt creation time from 5 minutes to 30 seconds
-    ```
-    </Example>
-  </Examples>
-
-  <Constraint>
-    - For usage-based improvements: Only modify based on patterns with ≥3 documented occurrences
-    - For completeness review: Update ALL prompts that lack proper structure regardless of usage
-    - Only recommend new prompts for Ad Hoc patterns with ≥3 similar occurrences
-    - Maintain original prompt intent and core workflow
-    - Preserve existing successful elements (don't change what works)
-    - Ensure backward compatibility with existing template variables
-    - New prompt recommendations must show clear reuse potential
-    - Minimal prompts (fewer than 5 lines) should be expanded to include full structure
-    - All implementation prompts MUST include verification steps
-  </Constraint>
-
-  <SuccessCriteria>
-    <Criterion>✅ ALL prompts have proper structure (Role, Objective, Requirements, Success Criteria)</Criterion>
-    <Criterion>✅ All minimal prompts (fewer than 5 lines) are expanded with complete structure</Criterion>
-    <Criterion>✅ All implementation prompts include explicit verification steps</Criterion>
-    <Criterion>✅ All high-severity patterns (≥3 occurrences) have corresponding file modifications</Criterion>
-    <Criterion>✅ At least 80% of identified issues result in actual prompt file updates</Criterion>
-    <Criterion>✅ All modifications are verified with successful Edit tool operations</Criterion>
-    <Criterion>✅ New prompt files are created for 70%+ of repeated Ad Hoc patterns</Criterion>
-    <Criterion>✅ Each created prompt is verified to work with `pt list` and `pt run`</Criterion>
-    <Criterion>✅ Report documents all changes made with file paths and specific edits</Criterion>
-    <Criterion>✅ Git status shows modified/new files ready for review and commit</Criterion>
-    <Criterion>Read each prompt file in the prompts directory</Criterion>
-    <Criterion>Identify prompts lacking proper structure</Criterion>
-    <Criterion>Update minimal or incomplete prompts</Criterion>
-    <Criterion>Read the prompt file</Criterion>
-    <Criterion>Apply fixes using Edit tool based on evidence</Criterion>
-    <Criterion>Verify the edit succeeded</Criterion>
-    <Criterion>Create new prompt file using Write tool</Criterion>
-    <Criterion>Verify it appears in `pt list`</Criterion>
-  </SuccessCriteria>
-</Prompt>

package/prompts/simple-test.prompt

@@ -1,8 +0,0 @@
-{/* Converted from simple-test.md */}
-<Prompt name="simple-test" description="Simple Test" tags={[]}>
-  <Section>
-    # Simple Test
-
-    <Ask.Text name="message" label="Message:" default={"Hello from simple test"} />
-  </Section>
-</Prompt>