ai-eng-system 0.1.0 → 0.2.0

package/dist/.claude-plugin/commands/create-agent.md

@@ -9,6 +9,16 @@ subtask: true
 
 Create a new OpenCode agent using AI assistance.
 
+Take a deep breath and design agent systematically, ensuring clear triggering logic, proper expertise definition, and smooth integration with existing system.
+
+## Why This Matters
+
+Agents are used repeatedly across thousands of interactions. Poorly designed agents with unclear triggering or weak expertise waste tokens, produce inconsistent results, and frustrate users. This agent design task is critical for creating tools that will reliably serve the system for months.
+
+## The Challenge
+
+I bet you can't balance specificity with flexibility in agent design. The challenge is defining triggering conditions specific enough to invoke at right times, while making expertise broad enough to handle variations. Success means agent activates when relevant, provides expert guidance, and doesn't interfere with other workflows.
+
 ## Process
 1. **Understand Requirements**: What should the agent do?
 2. **Generate Agent**: Use @agent-creator to create properly formatted agent
@@ -45,4 +55,6 @@ Agent will be saved to:
 /ai-eng/create-agent "data analyst for database queries"
 ```
 
-The agent-creator will handle platform-specific formatting and ensure the agent follows best practices for triggering, expertise, and integration.
+The agent-creator will handle platform-specific formatting and ensure the agent follows best practices for triggering, expertise, and integration.
+
+After creating the agent, rate your confidence in its design quality (0.0-1.0). Identify any assumptions about triggering scenarios, potential overlap with existing agents, or areas where expertise may be insufficient. Note any integration challenges or platform-specific concerns.

package/dist/.claude-plugin/commands/create-command.md

@@ -9,6 +9,16 @@ subtask: true
 
 Create a new OpenCode command using AI assistance.
 
+Take a deep breath and design command systematically, ensuring clear argument structure, proper shell integration, and comprehensive documentation.
+
+## Why This Matters
+
+Commands become part of user's daily workflow. Poorly designed commands with confusing arguments, inadequate validation, or missing documentation waste time and cause errors. This command design task is critical for building reliable, user-friendly tools.
+
+## The Challenge
+
+I bet you can't design command interface that balances simplicity with power. The challenge is creating argument structure that's intuitive for common use cases while supporting advanced scenarios. Success means command is easy to discover, simple to use, and powerful enough to handle complex workflows.
+
 ## Process
 1. **Understand Requirements**: What should the command do?
 2. **Generate Command**: Use @command-creator to create properly formatted command
@@ -45,4 +55,6 @@ Command will be saved to:
 /ai-eng/create-command "generate API docs from code"
 ```
 
-The command-creator will handle platform-specific formatting and ensure the command follows best practices for arguments, shell integration, and tool usage.
+The command-creator will handle platform-specific formatting and ensure the command follows best practices for arguments, shell integration, and tool usage.
+
+After creating the command, rate your confidence in its usability and completeness (0.0-1.0). Identify any uncertainties about argument design, validation edge cases, or areas where documentation may be insufficient. Note any platform-specific challenges or integration concerns.

package/dist/.claude-plugin/commands/create-plugin.md

@@ -9,6 +9,16 @@ subtask: false
 
 Create a complete, high-quality OpenCode extension from initial concept to tested implementation. Follow a systematic approach: understand requirements, design components, clarify details, implement following best practices, validate, and test.
 
+Take a deep breath and approach plugin creation systematically. This is a complex multi-phase task that requires careful planning, component design, implementation, and thorough validation.
+
+## Why This Matters
+
+Plugins are integrated into development workflows and used repeatedly. Poorly designed plugins break builds, waste time, and frustrate users. Plugin architecture flaws compound over time as more components depend on them. This plugin creation task is critical for building reliable, maintainable extensions.
+
+## The Challenge
+
+I bet you can't design a plugin architecture that is both comprehensive and maintainable. The challenge is creating components that work together seamlessly while remaining modular enough for future enhancements. Success means plugin is thoroughly validated, well-documented, and ready for production use.
+
 ## Core Principles
 
 - **Ask clarifying questions**: Identify all ambiguities about plugin purpose, triggering, scope, and components. Ask specific, concrete questions rather than making assumptions. Wait for user answers before proceeding with implementation.
@@ -397,4 +407,6 @@ Every component must meet these standards:
 
 ---
 
-**Begin with Phase 1: Discovery**
+**Begin with Phase 1: Discovery**
+
+After completing plugin creation, rate your confidence in its quality and readiness for production (0.0-1.0). Identify any uncertainties about component integration, validation coverage, or areas where testing may be insufficient. Note any architectural concerns or missing documentation that could impact adoption.

package/dist/.claude-plugin/commands/create-skill.md

@@ -9,6 +9,16 @@ subtask: true
 
 Create a new OpenCode skill using AI assistance.
 
+Take a deep breath and design skill systematically, ensuring clear triggering conditions, proper knowledge structure, and effective progressive disclosure.
+
+## Why This Matters
+
+Skills provide specialized knowledge to agents across many interactions. Poorly designed skills with weak triggering or bloated content waste tokens, provide inconsistent guidance, and overwhelm context. This skill design task is critical for building reusable knowledge resources.
+
+## The Challenge
+
+I bet you can't balance depth with conciseness in skill design. The challenge is providing comprehensive knowledge while using progressive disclosure to keep token usage efficient. Success means skill loads at right moment, provides accurate guidance, and remains focused on specific domain.
+
 ## Process
 1. **Understand Requirements**: What domain knowledge should the skill provide?
 2. **Generate Skill**: Use @skill-creator to create properly formatted skill
@@ -45,4 +55,6 @@ Skill will be saved to:
 /ai-eng/create-skill "security vulnerability scanning"
 ```
 
-The skill-creator will handle progressive disclosure, proper frontmatter, and ensure compatibility with opencode-skills plugin.
+The skill-creator will handle progressive disclosure, proper frontmatter, and ensure compatibility with opencode-skills plugin.
+
+After creating the skill, rate your confidence in its triggering accuracy and knowledge quality (0.0-1.0). Identify any uncertainties about triggering conditions, knowledge gaps, or areas where progressive disclosure may be insufficient. Note any token efficiency concerns or integration challenges.

package/dist/.claude-plugin/commands/create-tool.md

@@ -9,6 +9,16 @@ subtask: true
 
 Create a new OpenCode custom tool using AI assistance.
 
+Take a deep breath and implement tool systematically, ensuring proper TypeScript types, robust validation, and comprehensive error handling.
+
+## Why This Matters
+
+Custom tools extend system capabilities and are called from agents and commands. Poorly implemented tools with type errors, weak validation, or insufficient error handling break workflows and cause confusing failures. This tool implementation task is critical for reliable system extensions.
+
+## The Challenge
+
+I bet you can't implement a tool that balances flexibility with safety. The challenge is creating tool interface that handles various input scenarios while validating rigorously and failing gracefully. Success means tool works reliably, provides clear error messages, and integrates smoothly with existing patterns.
+
 ## Process
 1. **Understand Requirements**: What functionality should the tool provide?
 2. **Generate Tool**: Use @tool-creator to create properly formatted TypeScript tool
@@ -50,4 +60,6 @@ Tool will be saved to:
 /ai-eng/create-tool "Docker container management with status monitoring"
 ```
 
-The tool-creator will handle TypeScript compilation, Zod validation, error handling, and OpenCode tool integration patterns.
+The tool-creator will handle TypeScript compilation, Zod validation, error handling, and OpenCode tool integration patterns.
+
+After creating the tool, rate your confidence in its implementation quality and reliability (0.0-1.0). Identify any uncertainties about type safety, validation edge cases, or error handling gaps. Note any TypeScript compilation concerns or integration challenges that could affect reliability.

package/dist/.claude-plugin/commands/deploy.md

@@ -9,6 +9,16 @@ subtask: true
 
 Run pre-deployment verification and prepare for Coolify deployment.
 
+Take a deep breath and approach deployment systematically. Verify all checks, prepare configuration, and ensure proper monitoring before going live.
+
+## Why This Matters
+
+Deployment failures wake people at 3AM. Missing pre-deployment checks lead to production outages. Poor monitoring configuration hides problems until users report them. This deployment task is critical for maintaining stable, reliable production systems.
+
+## The Challenge
+
+I bet you can't deploy with confidence without skipping important checks. The challenge is balancing deployment speed with thorough verification, ensuring all risks are identified and mitigated. Success means deployment succeeds cleanly, application performs as expected, and monitoring catches any issues before users are impacted.
+
 ## Pre-flight Checks
 
 - [ ] All tests pass
@@ -33,3 +43,5 @@ Provide deployment instructions for Coolify including:
 - [ ] Health checks passing
 - [ ] Logs showing normal operation
 - [ ] Key user flows working
+
+After completing deployment, rate your confidence in production readiness (0.0-1.0). Identify any uncertainties about deployment configuration, potential monitoring gaps, or areas where rollback plans may be insufficient. Note any deployment risks that remain or post-deploy issues observed.

package/dist/.claude-plugin/commands/optimize.md

@@ -8,6 +8,16 @@ agent: build
 
 Interactive optimization tool that enhances content using research-backed techniques, web-researched best practices, and iterative refinement based on user feedback.
 
+Take a deep breath and approach this optimization systematically. Analyze content, apply appropriate techniques, and iteratively refine based on feedback.
+
+## Why This Matters
+
+Optimization quality directly impacts user satisfaction and content effectiveness. Poor optimization can make content worse, introduce errors, or waste user's time. This optimization task is critical for enhancing user productivity and improving content quality across all types.
+
+## The Challenge
+
+I bet you can't balance aggressiveness with preservation when optimizing content. The challenge is enhancing effectiveness while maintaining accuracy, clarity, and user intent. Success means optimization provides measurable improvement without introducing errors or losing essential meaning.
+
 ## Automatic Prompt Optimization
 
 This command works alongside the **automatic prompt optimization system**:
@@ -23,205 +33,12 @@ The automatic system runs via:
 
 ## Step-by-Step Approval UX
 
-When optimizing prompts, the system provides an interactive approval workflow:
-
-### 1. Call the Prompt-Optimize Tool
-
-First, call the `prompt-optimize` tool with the user's prompt:
-
-```bash
-Use the prompt-optimize tool with: "<user-input>"
-```
-
-The tool returns structured JSON:
-```json
-{
-  "version": 1,
-  "originalPrompt": "help me design authentication",
-  "optimizedPrompt": "You are a senior security engineer...\n\nTask: help me design authentication",
-  "domain": "security",
-  "complexity": "medium",
-  "steps": [
-    {
-      "id": "persona",
-      "title": "Expert Persona",
-      "before": "",
-      "after": "You are a senior security engineer with 15+ years..."
-    },
-    {
-      "id": "reasoning",
-      "title": "Step-by-Step Reasoning",
-      "before": "",
-      "after": "Take a deep breath and analyze this step by step."
-    },
-    {
-      "id": "stakes",
-      "title": "Stakes Language",
-      "before": "",
-      "after": "This is important for the project's success..."
-    },
-    {
-      "id": "selfEval",
-      "title": "Self-Evaluation",
-      "before": "",
-      "after": "After providing your solution, rate your confidence 0-1..."
-    }
-  ],
-  "skipped": false
-}
-```
-
-### 2. Display Optimization Plan
-
-Parse and present the optimization plan clearly:
-
-```markdown
-📋 Optimization Plan (medium, security)
-
-Step 1: Expert Persona
-  ```
-  You are a senior security engineer with 15+ years of authentication experience.
-  ```
-
-Step 2: Step-by-Step Reasoning
-  ```
-  Take a deep breath and analyze this step by step.
-  ```
-
-Step 3: Stakes Language
-  ```
-  This is important for the project's success. A thorough, complete solution is essential.
-  ```
-
-Step 4: Self-Evaluation
-  ```
-  After providing your solution, rate your confidence 0-1 and identify any assumptions you made.
-  ```
-
-Expected improvement: +60-115% quality (based on research-backed techniques)
-
-[Show confidence improvement calculation based on steps]
-- Expert Persona: +60% (Kong et al., 2023)
-- Step-by-Step Reasoning: +46% (Yang et al., 2023)
-- Stakes Language: +45% (Bsharat et al., 2023)
-- Self-Evaluation: +10% calibration
-```
-
-### 3. Guide User Through Approval
-
-Present interactive options menu:
-
-```markdown
-Options:
-  1. Approve all steps - Apply all optimization techniques
-  2. Approve specific step - Choose which steps to include
-  3. Modify step - Customize individual step content
-  4. Edit final prompt - Directly edit the optimized result
-  5. Cancel and use original - Skip optimization entirely
-
-Your choice (1-5):
-```
-
-### 4. Handle User Choice
-
-Based on user selection:
-
-#### Option 1: Approve All Steps
-```markdown
-✓ Using optimized prompt with 4 steps applied
-
-[Proceed to execute the optimized prompt]
-```
-
-#### Option 2: Approve Specific Step
-```markdown
-Which step(s) would you like to approve? (Enter step IDs, e.g., "1,3,4")
-
-[Rebuild prompt from approved steps only]
-✓ Using optimized prompt with 3 steps applied (skipped: Step 2)
-```
-
-#### Option 3: Modify Step
-```markdown
-Which step would you like to modify? (Enter step ID: 1-4)
-
-Step 3: Stakes Language
-Current content:
-  This is important for the project's success. A thorough, complete solution is essential.
-
-New content:
-  [User inputs modified content]
-
-✓ Step 3 modified
-✓ Using optimized prompt with updated steps
-```
-
-#### Option 4: Edit Final Prompt
-```markdown
-Current optimized prompt:
-```
-You are a senior security engineer with 15+ years of authentication experience.
-
-Take a deep breath and analyze this step by step.
-
-This is important for the project's success. A thorough, complete solution is essential.
-
-After providing your solution, rate your confidence 0-1 and identify any assumptions you made.
-
-Task: help me design authentication
-```
-
-Edit this prompt:
-[User provides edited version]
-
-✓ Using your edited prompt
-```
-
-#### Option 5: Cancel
-```markdown
-✓ Using original prompt without optimization
-
-[Proceed with original input]
-```
-
-### 5. Handle Edge Cases
-
-#### Skipped Optimization
-If tool returns `"skipped": true`:
-```markdown
-ℹ️ Optimization skipped: [skipReason]
-
-[Proceed with original prompt]
-```
-
-#### Simple Prompts
-For simple prompts (complexity: simple):
-```markdown
-ℹ️ Simple prompt - optimization not beneficial
-
-[Proceed with original prompt]
-```
-
-#### Empty Steps
-If no steps are provided:
-```markdown
-ℹ️ No optimization steps available
-
-[Proceed with original prompt]
-```
-
-### 6. Return Final Prompt
-
-After approval flow, return the final prompt for execution:
-
-```markdown
-Final prompt ready for execution:
-```
-[approved/edited prompt content]
-```
-
-[Execute the final prompt]
-```
+When optimizing prompts, the system provides an interactive approval workflow. See `docs/optimize-approval-flow.md` for complete details on:
+- Calling the prompt-optimize tool
+- Displaying optimization plans
+- Interactive approval options (approve all, approve specific, modify, edit, cancel)
+- Handling edge cases (skipped, simple prompts, empty steps)
+- Configuration and session commands
 
 ## Usage
 
@@ -1477,4 +1294,6 @@ function reconstructPrompt(
   parts.push(`\n\nTask: ${originalTask}`);
   return parts.join("\n\n");
 }
-```
+```
+
+After completing optimization, rate your confidence in improvement quality (0.0-1.0). Identify any uncertainties about applied techniques, areas where optimization may have been too aggressive or conservative, or aspects of original content that may have been degraded. Note any feedback patterns or technique effectiveness observations.

package/dist/.claude-plugin/commands/plan.md

@@ -29,6 +29,16 @@ Create a detailed implementation plan for: $ARGUMENTS
 
 > **Phase 3 of Spec-Driven Workflow**: Research → Specify → Plan → Work → Review
 
+Take a deep breath and approach this planning task systematically. Analyze requirements, decompose into atomic tasks, identify dependencies, and create comprehensive implementation strategy.
+
+## Why This Matters
+
+Poor planning leads to wrong solutions, wasted time, and implementation rework. Incomplete task decomposition causes blocking issues during implementation. Missing dependencies prevent parallel work. This planning task is critical for ensuring smooth, efficient implementation.
+
+## The Challenge
+
+I bet you can't decompose requirements into truly atomic tasks that can be executed independently. The challenge is breaking complex features into small, completable units while maintaining correct dependency relationships. Success means every task can be completed independently, dependencies are minimal, and implementation follows predictable path.
+
 ## Quick Start
 
 ```bash
@@ -71,40 +81,7 @@ Create a detailed implementation plan for: $ARGUMENTS
 
 ## Phase 0: Prompt Refinement (CRITICAL - Do First)
 
-**You MUST invoke the `prompt-refinement` skill before proceeding.**
-
-**How to invoke:**
-1. Load the skill from: `skills/prompt-refinement/SKILL.md`
-2. Use phase: `plan`
-3. Follow the TCRO framework: Task, Context, Requirements, Output
-
-If `--from-spec` flag is provided:
-1. **Read specification** from `specs/[feature]/spec.md`
-2. **Extract user stories** and their acceptance criteria
-3. **Extract non-functional requirements** (security, performance, etc.)
-4. **Identify open questions** marked with `[NEEDS CLARIFICATION]`
-5. **Use as foundation** for technical planning
-
-If no spec is found:
-- Warn user: "No specification found. Consider running `/ai-eng/specify` first to create a detailed specification."
-- Offer: "Proceed with inline requirements gathering? (y/n)"
-- If yes, gather requirements through clarifying questions
-- If no, exit and prompt user to run `/ai-eng/specify`
-
-### Ralph Wiggum Integration
-
-If `--ralph` flag is used, also invoke the `ralph-wiggum` skill:
-
-**Load Ralph Wiggum skill from:** `skills/workflow/ralph-wiggum/SKILL.md`
-
-**Ralph Wiggum Planning Cycle:**
-1. **Initial Plan** - Create comprehensive implementation plan
-2. **Gap Analysis** - Identify missing tasks, incomplete dependencies
-3. **Iterative Enhancement** - Add missing details, strengthen task definitions
-4. **Quality Validation** - Run quality gate if specified
-5. **Completion Check** - Continue until completion promise met or max iterations reached
-
-**Default Planning Completion Promise:** "Plan is comprehensive and ready for execution"
+Load `skills/prompt-refinement/SKILL.md` and use phase: `plan` to transform your prompt into structured TCRO format (Task, Context, Requirements, Output). If using `--from-spec`, extract user stories and non-functional requirements from the specification. See `templates/plan.md` for output structure.
 
 ### Phase 2: Discovery (Research Mode)
 
@@ -532,6 +509,8 @@ For example:
 - `bun run scripts/run-command.ts plan "implement auth" --from-spec=specs/auth/spec.md --output=plans/auth.yaml`
 - `bun run scripts/run-command.ts plan --from-research=docs/research/auth.md --scope=implementation`
 
+After creating the plan, rate your confidence in its completeness and accuracy (0.0-1.0). Identify any uncertainties about task decomposition, missing dependencies, or areas where acceptance criteria may be ambiguous. Note any implementation risks that weren't adequately addressed in the plan.
+
 ## Ralph Wiggum Iteration Mode
 
 When `--ralph` flag is enabled, the planning process follows a persistent refinement cycle: