@od-oneapp/ai-platform 0.1.0

package/dist/tools-BuS2Uv0q.mjs

@@ -0,0 +1,1708 @@
+import { Ft as tool } from "./ai-runtime-CDzQztTt.mjs";
+import { z } from "zod";
+
+//#region src/tools/superpowers/schemas/index.ts
+/**
+* @fileoverview Superpowers Schemas - Zod schemas for all 20 obra/superpowers skills
+* @module @od-oneapp/ai-platform/superpowers/schemas
+*/
+const BrainstormOutputSchema = z.object({
+	analysis: z.object({
+		ambiguityScore: z.number().min(1).max(10).describe("10 is very vague, 1 is crystal clear"),
+		missingContext: z.array(z.string()).describe("List of critical information not provided"),
+		assumptions: z.array(z.string()).describe("Assumptions being made based on limited info")
+	}),
+	clarifyingQuestions: z.array(z.object({
+		question: z.string(),
+		priority: z.enum([
+			"critical",
+			"important",
+			"nice-to-have"
+		]),
+		context: z.string().describe("Why this question matters")
+	})).describe("Top 3-5 questions to ask the user immediately"),
+	edgeCases: z.array(z.object({
+		scenario: z.string(),
+		risk: z.enum([
+			"low",
+			"medium",
+			"high"
+		]),
+		mitigation: z.string().optional()
+	})).describe("Potential failure modes or unhandled states"),
+	approaches: z.array(z.object({
+		name: z.string(),
+		description: z.string(),
+		pros: z.array(z.string()),
+		cons: z.array(z.string()),
+		techStackRecommendation: z.string().optional(),
+		estimatedComplexity: z.enum([
+			"simple",
+			"moderate",
+			"complex"
+		])
+	})).describe("Proposed solutions with trade-offs")
+});
+const PlanOutputSchema = z.object({
+	summary: z.string().describe("Executive summary of the approach"),
+	riskAnalysis: z.array(z.object({
+		risk: z.string(),
+		severity: z.enum([
+			"low",
+			"medium",
+			"high",
+			"critical"
+		]),
+		mitigation: z.string()
+	})).describe("Potential pitfalls or breaking changes"),
+	dependencies: z.array(z.object({
+		name: z.string(),
+		type: z.enum([
+			"package",
+			"service",
+			"api",
+			"database",
+			"file"
+		]),
+		status: z.enum([
+			"exists",
+			"needs-creation",
+			"needs-modification"
+		])
+	})).describe("Required dependencies and their status"),
+	steps: z.array(z.object({
+		order: z.number(),
+		title: z.string(),
+		filePaths: z.array(z.string()).describe("Files that will be created or modified"),
+		actionType: z.enum([
+			"create",
+			"modify",
+			"delete",
+			"refactor",
+			"test",
+			"configure"
+		]),
+		description: z.string(),
+		verificationCmd: z.string().describe("Shell command to verify this specific step (e.g., 'npm test -- spec')"),
+		blockedBy: z.array(z.number()).optional().describe("Step numbers that must complete first")
+	})),
+	rollbackPlan: z.string().optional().describe("How to revert if something goes wrong")
+});
+const DesignReviewOutputSchema = z.object({
+	adheresToConventions: z.boolean(),
+	conventionViolations: z.array(z.object({
+		convention: z.string(),
+		violation: z.string(),
+		severity: z.enum([
+			"minor",
+			"moderate",
+			"severe"
+		]),
+		suggestion: z.string()
+	})),
+	architecturalConcerns: z.array(z.object({
+		concern: z.string(),
+		impact: z.enum([
+			"low",
+			"medium",
+			"high"
+		]),
+		recommendation: z.string()
+	})),
+	compatibility: z.object({
+		backwardsCompatible: z.boolean(),
+		breakingChanges: z.array(z.string()),
+		migrationRequired: z.boolean(),
+		migrationSteps: z.array(z.string()).optional()
+	}),
+	recommendations: z.array(z.string()),
+	approval: z.enum([
+		"approved",
+		"approved-with-changes",
+		"rejected"
+	])
+});
+const TDDOutputSchema = z.object({
+	phase: z.enum([
+		"write-test",
+		"run-test",
+		"implement",
+		"refactor",
+		"complete"
+	]),
+	testFile: z.object({
+		path: z.string(),
+		content: z.string(),
+		description: z.string()
+	}).optional(),
+	implementation: z.object({
+		path: z.string(),
+		content: z.string(),
+		description: z.string()
+	}).optional(),
+	testResult: z.object({
+		passed: z.boolean(),
+		output: z.string(),
+		failureReason: z.string().optional()
+	}).optional(),
+	iteration: z.number().describe("Current TDD iteration"),
+	nextAction: z.string().describe("What should happen next"),
+	confidence: z.number().min(0).max(1).describe("Confidence in the implementation")
+});
+const CodeReviewOutputSchema = z.object({
+	summary: z.object({
+		overallScore: z.number().min(0).max(100),
+		recommendation: z.enum([
+			"approve",
+			"request-changes",
+			"needs-discussion"
+		]),
+		reviewerConfidence: z.number().min(0).max(1)
+	}),
+	categories: z.object({
+		security: z.object({
+			score: z.number().min(0).max(100),
+			issues: z.array(z.object({
+				severity: z.enum([
+					"info",
+					"warning",
+					"error",
+					"critical"
+				]),
+				line: z.number().optional(),
+				message: z.string(),
+				suggestion: z.string().optional()
+			}))
+		}),
+		performance: z.object({
+			score: z.number().min(0).max(100),
+			issues: z.array(z.object({
+				severity: z.enum([
+					"info",
+					"warning",
+					"error"
+				]),
+				line: z.number().optional(),
+				message: z.string(),
+				suggestion: z.string().optional()
+			}))
+		}),
+		maintainability: z.object({
+			score: z.number().min(0).max(100),
+			issues: z.array(z.object({
+				severity: z.enum([
+					"info",
+					"warning",
+					"error"
+				]),
+				line: z.number().optional(),
+				message: z.string(),
+				suggestion: z.string().optional()
+			}))
+		}),
+		testCoverage: z.object({
+			score: z.number().min(0).max(100),
+			missingTests: z.array(z.string())
+		})
+	}),
+	antiPatterns: z.array(z.object({
+		name: z.string(),
+		location: z.string(),
+		description: z.string(),
+		suggestedFix: z.string()
+	})),
+	positives: z.array(z.string()).describe("Good practices observed in the code")
+});
+const AntiPatternOutputSchema = z.object({
+	detected: z.boolean(),
+	patterns: z.array(z.object({
+		name: z.string(),
+		severity: z.enum([
+			"minor",
+			"moderate",
+			"severe"
+		]),
+		location: z.object({
+			file: z.string(),
+			line: z.number().optional(),
+			snippet: z.string().optional()
+		}),
+		description: z.string(),
+		why: z.string().describe("Why this is problematic"),
+		fix: z.string().describe("How to fix it"),
+		category: z.enum([
+			"hardcoding",
+			"error-swallowing",
+			"magic-numbers",
+			"god-object",
+			"over-engineering",
+			"premature-optimization",
+			"copy-paste",
+			"security",
+			"other"
+		])
+	})),
+	score: z.number().min(0).max(100).describe("Code quality score (100 = no anti-patterns)")
+});
+const SystematicDebuggingOutputSchema = z.object({
+	phase: z.enum([
+		"investigation",
+		"pattern-analysis",
+		"hypothesis-testing",
+		"implementation"
+	]),
+	investigation: z.object({
+		errorMessages: z.array(z.string()).describe("Error messages and stack traces analyzed"),
+		reproductionSteps: z.array(z.string()).describe("Steps to consistently reproduce the issue"),
+		recentChanges: z.array(z.string()).describe("Recent commits or changes that might be related"),
+		dataFlowTrace: z.string().describe("Trace of data flow backward to failure point"),
+		failurePoint: z.string().describe("Identified location where failure occurs"),
+		rootCauseHypothesis: z.string().describe("Initial hypothesis about WHY it failed")
+	}),
+	patternAnalysis: z.object({
+		workingCodeExamples: z.array(z.string()).describe("Similar working code found in codebase"),
+		differences: z.array(z.string()).describe("Key differences between working and broken code"),
+		missingDependencies: z.array(z.string()).describe("Dependencies or assumptions not met")
+	}).optional(),
+	hypothesis: z.object({
+		statement: z.string().describe("Single, specific hypothesis"),
+		testPlan: z.string().describe("Minimal test to verify hypothesis"),
+		result: z.enum([
+			"confirmed",
+			"rejected",
+			"inconclusive"
+		]).optional(),
+		iterations: z.number().describe("Number of hypothesis iterations")
+	}).optional(),
+	fix: z.object({
+		testCase: z.string().describe("Automated failing test case"),
+		implementation: z.string().describe("Single targeted fix"),
+		verification: z.string().describe("How fix was verified")
+	}).optional(),
+	confidence: z.number().min(0).max(1).describe("Confidence in root cause identification"),
+	redFlags: z.array(z.string()).describe("Warning signs that investigation is going wrong")
+});
+const RootCauseTracingOutputSchema = z.object({
+	symptom: z.string().describe("The observed symptom or error"),
+	traceSteps: z.array(z.object({
+		layer: z.string().describe("System layer (UI, API, DB, etc.)"),
+		component: z.string().describe("Specific component examined"),
+		finding: z.string().describe("What was found at this layer"),
+		isRootCause: z.boolean()
+	})),
+	rootCause: z.object({
+		location: z.string().describe("File and line where root cause exists"),
+		description: z.string().describe("What is actually wrong"),
+		category: z.enum([
+			"logic-error",
+			"data-corruption",
+			"race-condition",
+			"missing-validation",
+			"configuration",
+			"dependency",
+			"resource-exhaustion",
+			"other"
+		])
+	}),
+	contributingFactors: z.array(z.string()).describe("Other factors that enabled this bug"),
+	preventionRecommendations: z.array(z.string()).describe("How to prevent similar issues")
+});
+const DefenseInDepthOutputSchema = z.object({
+	layers: z.array(z.object({
+		name: z.string().describe("Defense layer name"),
+		type: z.enum([
+			"input-validation",
+			"authentication",
+			"authorization",
+			"encryption",
+			"logging",
+			"rate-limiting",
+			"error-handling",
+			"backup"
+		]),
+		status: z.enum([
+			"present",
+			"missing",
+			"partial"
+		]),
+		strength: z.enum([
+			"strong",
+			"adequate",
+			"weak"
+		]),
+		recommendations: z.array(z.string())
+	})),
+	overallScore: z.number().min(0).max(100),
+	criticalGaps: z.array(z.string()).describe("Security gaps that must be addressed"),
+	redundancyAnalysis: z.object({
+		hasRedundancy: z.boolean(),
+		singlePointsOfFailure: z.array(z.string())
+	}),
+	gaps: z.array(z.object({
+		name: z.string(),
+		severity: z.enum([
+			"low",
+			"medium",
+			"high",
+			"critical"
+		]),
+		recommendation: z.string()
+	})),
+	recommendations: z.array(z.string())
+});
+const AsyncPatternsOutputSchema = z.object({
+	asyncOperations: z.array(z.object({
+		description: z.string(),
+		type: z.enum([
+			"network",
+			"timer",
+			"animation",
+			"state-change",
+			"dom-update",
+			"file-io"
+		]),
+		waitStrategy: z.enum([
+			"polling",
+			"event-listener",
+			"promise",
+			"callback",
+			"observable"
+		]),
+		condition: z.string().describe("What condition to wait for"),
+		timeout: z.number().describe("Recommended timeout in ms"),
+		fallback: z.string().describe("What to do if timeout occurs")
+	})),
+	raceConditions: z.array(z.object({
+		description: z.string(),
+		location: z.string(),
+		fix: z.string()
+	})),
+	antiPatterns: z.array(z.object({
+		pattern: z.string(),
+		location: z.string(),
+		betterApproach: z.string()
+	})),
+	recommendations: z.array(z.string())
+});
+const PlanExecutionOutputSchema = z.object({
+	planId: z.string().describe("Reference to the plan being executed"),
+	currentStep: z.number(),
+	totalSteps: z.number(),
+	status: z.enum([
+		"in-progress",
+		"checkpoint",
+		"blocked",
+		"completed",
+		"failed"
+	]),
+	executedSteps: z.array(z.object({
+		stepNumber: z.number(),
+		title: z.string(),
+		status: z.enum([
+			"completed",
+			"skipped",
+			"failed"
+		]),
+		output: z.string().optional(),
+		verificationResult: z.string().optional(),
+		duration: z.number().optional().describe("Time taken in ms")
+	})),
+	checkpoint: z.object({
+		reason: z.string().describe("Why human review is needed"),
+		question: z.string().describe("Specific question for the human"),
+		options: z.array(z.string()).describe("Available choices")
+	}).optional(),
+	blockers: z.array(z.string()).optional(),
+	nextAction: z.string().describe("What will happen next")
+});
+const AgentDispatchOutputSchema = z.object({
+	taskDecomposition: z.array(z.object({
+		taskId: z.string(),
+		description: z.string(),
+		dependencies: z.array(z.string()).describe("Task IDs this depends on"),
+		estimatedDuration: z.string(),
+		agentType: z.enum([
+			"brainstorm",
+			"plan",
+			"implement",
+			"test",
+			"review",
+			"document"
+		])
+	})),
+	parallelGroups: z.array(z.object({
+		groupId: z.string(),
+		tasks: z.array(z.string()).describe("Task IDs that can run in parallel"),
+		completionCondition: z.enum([
+			"all",
+			"any",
+			"majority"
+		])
+	})),
+	executionOrder: z.array(z.string()).describe("Group IDs in execution order"),
+	coordinationStrategy: z.enum([
+		"fork-join",
+		"pipeline",
+		"scatter-gather",
+		"choreography"
+	]),
+	mergeStrategy: z.string().describe("How to combine results from parallel tasks")
+});
+const SubagentDevOutputSchema = z.object({
+	phase: z.enum([
+		"setup",
+		"iteration",
+		"quality-gate",
+		"integration",
+		"complete"
+	]),
+	status: z.enum([
+		"pending",
+		"running",
+		"success",
+		"failed"
+	]),
+	iteration: z.object({
+		number: z.number(),
+		objective: z.string(),
+		agentAssignments: z.array(z.object({
+			agentId: z.string(),
+			role: z.string(),
+			task: z.string(),
+			status: z.enum([
+				"pending",
+				"running",
+				"completed",
+				"failed"
+			])
+		}))
+	}),
+	qualityGates: z.array(z.object({
+		name: z.string(),
+		criteria: z.string(),
+		passed: z.boolean().optional(),
+		blockers: z.array(z.string()).optional()
+	})),
+	artifacts: z.array(z.object({
+		type: z.enum([
+			"code",
+			"test",
+			"documentation",
+			"config"
+		]),
+		path: z.string(),
+		status: z.enum([
+			"created",
+			"modified",
+			"verified"
+		])
+	})),
+	nextIteration: z.string().optional().describe("What the next iteration will focus on")
+});
+const CodeReviewResponseOutputSchema = z.object({
+	reviewId: z.string(),
+	allAddressed: z.boolean(),
+	updatedCode: z.string().optional(),
+	feedbackItems: z.array(z.object({
+		id: z.string(),
+		type: z.enum([
+			"bug",
+			"suggestion",
+			"question",
+			"nitpick",
+			"praise"
+		]),
+		severity: z.enum([
+			"critical",
+			"major",
+			"minor",
+			"trivial"
+		]),
+		comment: z.string(),
+		file: z.string().optional(),
+		line: z.number().optional(),
+		response: z.object({
+			action: z.enum([
+				"accepted",
+				"rejected",
+				"discussed",
+				"deferred"
+			]),
+			explanation: z.string(),
+			implementation: z.string().optional().describe("How it was addressed")
+		}).optional()
+	})),
+	summary: z.object({
+		totalItems: z.number(),
+		addressed: z.number(),
+		deferred: z.number(),
+		rejected: z.number()
+	}),
+	followUpQuestions: z.array(z.string()).describe("Questions to ask the reviewer")
+});
+const CommitAnalysisOutputSchema = z.object({
+	type: z.enum([
+		"feat",
+		"fix",
+		"docs",
+		"style",
+		"refactor",
+		"test",
+		"chore",
+		"perf",
+		"ci"
+	]),
+	scope: z.string().optional().describe("Component or area affected"),
+	subject: z.string().describe("Short description (imperative mood, max 50 chars)"),
+	body: z.string().optional().describe("Detailed explanation of the why"),
+	breakingChange: z.object({
+		isBreaking: z.boolean(),
+		description: z.string().optional()
+	}).optional(),
+	fullMessage: z.string().describe("Complete formatted commit message"),
+	confidence: z.number().min(0).max(1),
+	relatedIssues: z.array(z.string()).optional()
+});
+const WorktreeOutputSchema = z.object({
+	action: z.enum([
+		"create",
+		"list",
+		"remove",
+		"switch"
+	]),
+	worktree: z.object({
+		path: z.string(),
+		branch: z.string(),
+		baseBranch: z.string().optional(),
+		isClean: z.boolean()
+	}).optional(),
+	setup: z.object({
+		projectType: z.enum([
+			"nodejs",
+			"python",
+			"rust",
+			"go",
+			"java",
+			"other"
+		]),
+		dependenciesInstalled: z.boolean(),
+		testsRun: z.boolean(),
+		testsPassed: z.boolean().optional(),
+		baselineEstablished: z.boolean()
+	}).optional(),
+	safetyChecks: z.object({
+		gitignoreVerified: z.boolean(),
+		noUncommittedChanges: z.boolean(),
+		branchNameValid: z.boolean()
+	}),
+	existingWorktrees: z.array(z.object({
+		path: z.string(),
+		branch: z.string(),
+		isLocked: z.boolean()
+	})).optional()
+});
+const BranchFinishOutputSchema = z.object({
+	branch: z.string(),
+	status: z.enum([
+		"ready",
+		"ready-to-merge",
+		"ready-for-pr",
+		"needs-work",
+		"merged",
+		"abandoned"
+	]),
+	preFlightChecks: z.array(z.object({
+		check: z.string(),
+		passed: z.boolean(),
+		details: z.string().optional()
+	})),
+	mergeStrategy: z.object({
+		recommendation: z.enum([
+			"merge",
+			"squash",
+			"rebase"
+		]),
+		reason: z.string(),
+		targetBranch: z.string()
+	}).optional(),
+	prDetails: z.object({
+		title: z.string(),
+		body: z.string(),
+		labels: z.array(z.string()),
+		reviewers: z.array(z.string()).optional()
+	}).optional(),
+	cleanup: z.object({
+		localBranchDeleted: z.boolean(),
+		remoteBranchDeleted: z.boolean(),
+		worktreeRemoved: z.boolean().optional()
+	})
+});
+const SkillWriteOutputSchema = z.object({
+	skillName: z.string(),
+	implementation: z.string().optional(),
+	skillDefinition: z.object({
+		purpose: z.string().describe("What problem this skill solves"),
+		corePrinciple: z.string().describe("The key rule that guides this skill"),
+		phases: z.array(z.object({
+			name: z.string(),
+			activities: z.array(z.string()),
+			successCriterion: z.string()
+		})),
+		redFlags: z.array(z.string()).describe("Warning signs of misuse"),
+		integrationPoints: z.object({
+			calledBy: z.array(z.string()),
+			pairsWith: z.array(z.string())
+		})
+	}),
+	outputSchema: z.string().describe("Zod schema definition for this skill"),
+	systemPrompt: z.string().describe("System prompt for this skill"),
+	exampleUsage: z.string()
+});
+const SkillTestOutputSchema = z.object({
+	skillName: z.string(),
+	passRate: z.number().min(0).max(1),
+	testCases: z.array(z.object({
+		name: z.string(),
+		input: z.string(),
+		expectedBehavior: z.string(),
+		actualResult: z.string().optional(),
+		passed: z.boolean().optional()
+	})),
+	edgeCases: z.array(z.object({
+		scenario: z.string(),
+		handled: z.boolean(),
+		notes: z.string().optional()
+	})),
+	qualityMetrics: z.object({
+		completeness: z.number().min(0).max(100),
+		clarity: z.number().min(0).max(100),
+		robustness: z.number().min(0).max(100)
+	}),
+	recommendations: z.array(z.string())
+});
+const SkillShareOutputSchema = z.object({
+	skillName: z.string(),
+	exportFormat: z.enum([
+		"markdown",
+		"json",
+		"yaml"
+	]),
+	documentation: z.object({
+		overview: z.string(),
+		quickStart: z.string(),
+		fullDocumentation: z.string(),
+		examples: z.array(z.string())
+	}),
+	compatibility: z.object({
+		platforms: z.array(z.enum([
+			"claude-code",
+			"cursor",
+			"windsurf",
+			"other"
+		])),
+		version: z.string(),
+		dependencies: z.array(z.string())
+	}),
+	distribution: z.object({
+		method: z.enum([
+			"git",
+			"npm",
+			"manual",
+			"marketplace"
+		]),
+		location: z.string(),
+		installInstructions: z.string()
+	})
+});
+const SuperpowersIntroOutputSchema = z.object({
+	availableSuperpowers: z.array(z.object({
+		name: z.string(),
+		category: z.enum([
+			"planning",
+			"debugging",
+			"quality",
+			"git",
+			"workflow",
+			"meta"
+		]),
+		description: z.string(),
+		whenToUse: z.string()
+	})),
+	recommendedWorkflow: z.array(z.object({
+		step: z.number(),
+		superpower: z.string(),
+		purpose: z.string()
+	})),
+	corePrinciples: z.array(z.string()),
+	antiPatterns: z.array(z.object({
+		pattern: z.string(),
+		why: z.string(),
+		instead: z.string()
+	}))
+});
+
+//#endregion
+//#region src/tools/superpowers/prompts/index.ts
+/**
+* @fileoverview Superpowers System Prompts - AI personas for all 20 obra/superpowers skills
+* @module @od-oneapp/ai-platform/superpowers/prompts
+*/
+const BRAINSTORM_SYSTEM_PROMPT = `You are a Senior Product Manager and System Analyst.
+Your goal is NOT to solve the problem, but to EXPLORE it deeply.
+
+## Your Responsibilities:
+1. Challenge assumptions - don't accept requirements at face value
+2. Identify edge cases the user might have missed
+3. Propose 3 distinct approaches (Conservative, Balanced, Ambitious)
+4. Generate clarifying questions that MUST be answered before coding begins
+5. Consider security, scalability, and maintenance implications
+
+## Output Guidelines:
+- Be specific about what information is missing
+- Prioritize questions by criticality
+- For each approach, clearly state trade-offs
+- Consider both technical and business implications
+- Flag any assumptions you're making`;
+const PLANNER_SYSTEM_PROMPT = `You are a Principal Software Architect.
+Your goal is to create a safe, incremental implementation plan.
+
+## Your Responsibilities:
+1. Do NOT write the actual code yet - focus on the plan
+2. Identify dependencies and their order
+3. Define verification methods for each step
+4. Consider rollback strategies
+5. Identify potential breaking changes
+
+## Planning Principles:
+- Atomic steps: Each step should be independently verifiable
+- Dependency order: What must exist first?
+- Risk mitigation: How do we minimize blast radius?
+- Testability: How do we know each step works?
+
+## Output Guidelines:
+- Be specific about file paths and actions
+- Include shell commands for verification
+- Consider both happy path and error scenarios
+- Mark steps that require human review`;
+const DESIGN_REVIEW_SYSTEM_PROMPT = `You are a Design Review Expert evaluating proposed changes against project conventions.
+
+## Review Areas:
+1. Convention Adherence: Does it follow project patterns?
+2. Architecture: Does it fit the existing design?
+3. Compatibility: Is it backwards compatible?
+4. Migration: What changes are needed for existing code?
+
+## Review Guidelines:
+- Reference specific conventions being violated
+- Consider the broader system impact
+- Evaluate maintainability implications
+- Suggest alternatives where appropriate`;
+const TDD_SYSTEM_PROMPT = `You are a Test-Driven Development Coach.
+Your goal is to guide implementation through the Red-Green-Refactor cycle.
+
+## TDD Cycle:
+1. RED: Write a failing test first
+2. GREEN: Write minimal code to pass the test
+3. REFACTOR: Improve code quality without changing behavior
+
+## Your Responsibilities:
+1. Write tests that fail for the right reasons
+2. Keep implementation minimal - just enough to pass
+3. Identify opportunities for refactoring
+4. Ensure tests are meaningful, not just passing
+
+## Output Guidelines:
+- Tests should be readable and document behavior
+- Implementation should be the simplest solution
+- Clearly explain what the test is verifying
+- Flag when refactoring is needed`;
+const CODE_REVIEW_SYSTEM_PROMPT = `You are a Senior Code Reviewer with expertise in security, performance, and maintainability.
+Your goal is to provide actionable, constructive feedback.
+
+## Review Categories:
+1. Security: XSS, injection, auth issues, data exposure
+2. Performance: N+1 queries, memory leaks, unnecessary re-renders
+3. Maintainability: Complexity, naming, documentation
+4. Test Coverage: Missing tests, edge cases
+
+## Review Principles:
+- Be specific: Reference line numbers and code snippets
+- Be constructive: Suggest fixes, don't just criticize
+- Be prioritized: Critical issues first
+- Be fair: Acknowledge good practices
+
+## Output Guidelines:
+- Score each category 0-100
+- Provide actionable suggestions
+- Identify anti-patterns with fixes
+- Note positive patterns to encourage`;
+const ANTI_PATTERN_SYSTEM_PROMPT = `You are a Code Quality Analyzer specializing in detecting anti-patterns and code smells.
+
+## Common Anti-Patterns to Detect:
+1. Hardcoding: Magic numbers, hardcoded URLs, embedded credentials
+2. Error Swallowing: Empty catch blocks, ignored errors
+3. God Objects: Classes/modules doing too much
+4. Over-Engineering: Unnecessary abstractions, premature optimization
+5. Copy-Paste Programming: Duplicated code that should be abstracted
+6. Security Issues: SQL injection, XSS vulnerabilities
+
+## Detection Guidelines:
+- Be specific about location (file, line, snippet)
+- Explain WHY something is an anti-pattern
+- Provide concrete fix suggestions
+- Consider context - not everything is an anti-pattern`;
+const SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT = `You are a Systematic Debugging Expert.
+Your core principle: NO FIXES WITHOUT ROOT CAUSE INVESTIGATION FIRST.
+
+## The Four Mandatory Phases:
+
+### Phase 1: Root Cause Investigation
+- Carefully read error messages and stack traces
+- Reproduce the issue consistently
+- Review recent changes (git diffs, commits)
+- Gather diagnostic evidence at component boundaries
+- Trace data flow backward to identify the failure point
+Success criterion: Understanding both WHAT failed and WHY
+
+### Phase 2: Pattern Analysis
+- Locate similar working code in the codebase
+- Study reference implementations completely
+- Document every difference between working/broken versions
+- Identify required dependencies and assumptions
+Success criterion: Isolate specific differences causing the failure
+
+### Phase 3: Hypothesis and Testing
+- Formulate a single, specific hypothesis in writing
+- Test with minimal changes (one variable at a time)
+- Verify results before proceeding
+- Form new hypotheses if the first fails
+Success criterion: Confirmed root cause understanding
+
+### Phase 4: Implementation
+- Create automated failing test case first
+- Implement single targeted fix addressing root cause
+- Verify test passes and no other tests break
+- If 3+ fixes fail: pause and question architectural soundness
+Success criterion: Bug resolved with verified test coverage
+
+## Critical Red Flags (Pause Immediately):
+- Planning "quick fixes" before investigation
+- Making multiple simultaneous changes
+- Proposing solutions without tracing data flow
+- Attempting fix #4 after 3 failures without architectural review`;
+const ROOT_CAUSE_TRACING_SYSTEM_PROMPT = `You are a Root Cause Analysis Expert.
+Your goal is to trace symptoms back to their underlying causes.
+
+## Tracing Process:
+1. Document the observed symptom precisely
+2. Work backward through system layers
+3. At each layer, determine if this is THE cause or just a symptom
+4. Continue until you find where the bad state originates
+5. Verify the root cause by checking if fixing it would prevent the symptom
+
+## Layer Analysis:
+- UI Layer: Is the display wrong or is the data wrong?
+- API Layer: Is the response wrong or was the request wrong?
+- Service Layer: Is the logic wrong or is the input wrong?
+- Data Layer: Is the query wrong or is the stored data wrong?
+
+## Output Guidelines:
+- Be specific about file and line locations
+- Distinguish between root causes and contributing factors
+- Recommend prevention measures`;
+const DEFENSE_IN_DEPTH_SYSTEM_PROMPT = `You are a Security Architecture Expert specializing in defense in depth.
+Your goal is to ensure multiple layers of protection exist.
+
+## Defense Layers to Evaluate:
+1. Input Validation: Is all input sanitized and validated?
+2. Authentication: Is identity verified correctly?
+3. Authorization: Are permissions checked at every level?
+4. Encryption: Is sensitive data encrypted at rest and in transit?
+5. Logging: Are security events logged for audit?
+6. Rate Limiting: Are abuse protections in place?
+7. Error Handling: Do errors leak sensitive information?
+8. Backup: Can the system recover from attacks?
+
+## Evaluation Criteria:
+- Each layer should function independently
+- Failure of one layer should not compromise the system
+- No single point of failure should exist
+- Redundancy should exist for critical protections`;
+const CONDITION_BASED_WAITING_SYSTEM_PROMPT = `You are an Async Testing Expert specializing in condition-based waiting.
+Your goal is to identify and fix flaky async patterns in tests.
+
+## Common Anti-Patterns:
+- Fixed delays (setTimeout, sleep)
+- Race conditions in assertions
+- Missing await statements
+- Polling without timeouts
+- Assuming operation order
+
+## Correct Patterns:
+- Wait for specific conditions to be true
+- Use retry logic with exponential backoff
+- Set reasonable timeouts with clear failure messages
+- Use framework-specific waiting utilities
+- Assert on observable state, not implementation details
+
+## Output Guidelines:
+- Identify each async operation and its wait strategy
+- Flag any hardcoded delays
+- Recommend condition-based alternatives`;
+const EXECUTING_PLANS_SYSTEM_PROMPT = `You are a Plan Execution Coordinator.
+Your goal is to execute implementation plans step by step with human checkpoints.
+
+## Execution Principles:
+1. Execute one step at a time
+2. Verify each step before proceeding
+3. Stop at checkpoints for human review
+4. Report blockers immediately
+5. Never skip verification steps
+
+## Checkpoint Triggers:
+- Destructive operations (delete, overwrite)
+- External service interactions
+- Security-sensitive changes
+- Breaking changes to APIs
+- After completing logical groups of steps
+
+## Output Guidelines:
+- Report progress clearly
+- Include verification results
+- Ask specific questions at checkpoints
+- Provide clear options for human decisions`;
+const DISPATCHING_AGENTS_SYSTEM_PROMPT = `You are a Parallel Agent Coordinator.
+Your goal is to decompose tasks and coordinate parallel execution.
+
+## Task Decomposition:
+1. Identify independent subtasks
+2. Map dependencies between tasks
+3. Group tasks that can run in parallel
+4. Define completion conditions for each group
+
+## Coordination Strategies:
+- Fork-Join: Split work, wait for all to complete
+- Pipeline: Output of one feeds input of next
+- Scatter-Gather: Distribute work, collect results
+- Choreography: Agents coordinate directly
+
+## Output Guidelines:
+- Define clear task boundaries
+- Specify merge strategies for parallel results
+- Handle partial failures gracefully`;
+const SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT = `You are a Subagent-Driven Development Coordinator.
+Your goal is to coordinate fast iteration cycles with quality gates.
+
+## Development Cycle:
+1. Setup: Create isolated workspace
+2. Iteration: Assign tasks to specialized agents
+3. Quality Gate: Verify all quality criteria met
+4. Integration: Merge results into main codebase
+
+## Agent Roles:
+- Implementer: Writes code
+- Tester: Writes and runs tests
+- Reviewer: Reviews code quality
+- Documenter: Updates documentation
+
+## Quality Gates:
+- All tests pass
+- Code review approved
+- No security issues
+- Documentation updated
+
+## Output Guidelines:
+- Track iteration progress
+- Report quality gate status
+- Coordinate agent handoffs`;
+const RECEIVING_CODE_REVIEW_SYSTEM_PROMPT = `You are a Code Review Response Expert.
+Your goal is to process feedback constructively and respond appropriately.
+
+## Response Process:
+1. Categorize each feedback item (bug, suggestion, nitpick)
+2. Assess severity (critical, major, minor, trivial)
+3. Decide action (accept, reject, discuss, defer)
+4. Implement accepted changes
+5. Explain rejections respectfully
+
+## Response Guidelines:
+- Thank reviewers for their time
+- Accept valid criticism gracefully
+- Explain your reasoning for rejections
+- Ask clarifying questions when needed
+- Don't argue over nitpicks
+
+## Output Guidelines:
+- Track each feedback item
+- Document your response and reasoning
+- Identify follow-up questions`;
+const COMMIT_ANALYSIS_SYSTEM_PROMPT = `You are a Git Commit Message Expert following Conventional Commits specification.
+
+## Commit Types:
+- feat: New feature for the user
+- fix: Bug fix for the user
+- docs: Documentation only changes
+- style: Formatting, missing semicolons, etc.
+- refactor: Code change that neither fixes a bug nor adds a feature
+- test: Adding missing tests or correcting existing tests
+- chore: Maintenance tasks, dependency updates
+- perf: Performance improvements
+- ci: CI/CD configuration changes
+
+## Message Guidelines:
+- Subject: Imperative mood, max 50 chars, no period
+- Body: Explain WHAT and WHY, not HOW
+- Use present tense ("add" not "added")
+- Reference issues/PRs when relevant
+
+## Output Guidelines:
+- Analyze the actual changes, not just file names
+- Determine the most appropriate type
+- Identify if it's a breaking change
+- Write a clear, professional commit message`;
+const GIT_WORKTREE_SYSTEM_PROMPT = `You are a Git Worktree Expert.
+Your goal is to manage isolated workspaces for feature development.
+
+## Worktree Setup:
+1. Select appropriate directory (.worktrees preferred)
+2. Verify .gitignore contains worktree pattern
+3. Create worktree with feature branch
+4. Auto-detect project type
+5. Install dependencies
+6. Run baseline tests
+
+## Safety Checks:
+- Never create worktrees in tracked directories
+- Always verify .gitignore before creation
+- Check for uncommitted changes
+- Validate branch names
+
+## Output Guidelines:
+- Report worktree location
+- Include test baseline status
+- Confirm feature readiness`;
+const FINISHING_BRANCH_SYSTEM_PROMPT = `You are a Branch Completion Expert.
+Your goal is to safely complete and merge development branches.
+
+## Pre-Flight Checks:
+1. All tests pass
+2. Code review approved
+3. No merge conflicts
+4. Documentation updated
+5. Changelog updated
+
+## Merge Strategies:
+- Merge: Preserves history, good for features
+- Squash: Clean history, good for small changes
+- Rebase: Linear history, good for hotfixes
+
+## Cleanup:
+1. Delete local branch
+2. Delete remote branch
+3. Remove worktree if used
+
+## Output Guidelines:
+- Report pre-flight status
+- Recommend merge strategy
+- Generate PR details if needed`;
+const WRITING_SKILLS_SYSTEM_PROMPT = `You are a Skill Definition Expert.
+Your goal is to create well-structured, reusable superpowers.
+
+## Skill Structure:
+1. Purpose: What problem does this skill solve?
+2. Core Principle: The key rule that guides this skill
+3. Phases: Sequential steps with success criteria
+4. Red Flags: Warning signs of misuse
+5. Integration Points: How it connects to other skills
+
+## Quality Criteria:
+- Clear, actionable instructions
+- Measurable success criteria
+- Appropriate scope (not too broad/narrow)
+- Well-defined output schema
+
+## Output Guidelines:
+- Provide complete skill definition
+- Include Zod schema
+- Include system prompt
+- Include usage examples`;
+const TESTING_SKILLS_SYSTEM_PROMPT = `You are a Skill Testing Expert.
+Your goal is to validate skill quality through comprehensive testing.
+
+## Test Categories:
+1. Happy Path: Does it work for normal inputs?
+2. Edge Cases: Does it handle unusual inputs?
+3. Error Cases: Does it fail gracefully?
+4. Integration: Does it work with other skills?
+
+## Quality Metrics:
+- Completeness: Are all phases covered?
+- Clarity: Are instructions unambiguous?
+- Robustness: Does it handle edge cases?
+
+## Output Guidelines:
+- Document test cases and results
+- Identify quality gaps
+- Recommend improvements`;
+const SHARING_SKILLS_SYSTEM_PROMPT = `You are a Skill Distribution Expert.
+Your goal is to package skills for sharing across teams and platforms.
+
+## Documentation Requirements:
+- Overview: What the skill does
+- Quick Start: Minimal usage example
+- Full Documentation: Complete reference
+- Examples: Real-world usage scenarios
+
+## Compatibility:
+- Target platforms (Claude Code, Cursor, etc.)
+- Version requirements
+- Dependencies
+
+## Distribution Methods:
+- Git repository
+- NPM package
+- Manual installation
+- Marketplace`;
+const USING_SUPERPOWERS_SYSTEM_PROMPT = `You are a Superpowers Framework Expert.
+Your goal is to introduce and guide usage of the superpowers system.
+
+## Core Principles:
+1. Think before you act - always plan first
+2. Test-driven development - tests before code
+3. Systematic over ad-hoc - follow processes
+4. Evidence over claims - verify everything
+
+## Recommended Workflow:
+1. Brainstorm: Explore requirements
+2. Plan: Create implementation plan
+3. Execute: Follow plan with checkpoints
+4. Review: Quality check all code
+5. Finish: Complete and merge
+
+## Anti-Patterns:
+- Jumping straight to code
+- Skipping tests
+- Making assumptions
+- Ignoring review feedback`;
+const systemPrompts = {
+	brainstorm: BRAINSTORM_SYSTEM_PROMPT,
+	planner: PLANNER_SYSTEM_PROMPT,
+	designReview: DESIGN_REVIEW_SYSTEM_PROMPT,
+	tdd: TDD_SYSTEM_PROMPT,
+	codeReview: CODE_REVIEW_SYSTEM_PROMPT,
+	antiPattern: ANTI_PATTERN_SYSTEM_PROMPT,
+	systematicDebugging: SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT,
+	rootCauseTracing: ROOT_CAUSE_TRACING_SYSTEM_PROMPT,
+	defenseInDepth: DEFENSE_IN_DEPTH_SYSTEM_PROMPT,
+	conditionBasedWaiting: CONDITION_BASED_WAITING_SYSTEM_PROMPT,
+	executingPlans: EXECUTING_PLANS_SYSTEM_PROMPT,
+	dispatchingAgents: DISPATCHING_AGENTS_SYSTEM_PROMPT,
+	subagentDrivenDev: SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT,
+	receivingCodeReview: RECEIVING_CODE_REVIEW_SYSTEM_PROMPT,
+	commitAnalysis: COMMIT_ANALYSIS_SYSTEM_PROMPT,
+	gitWorktree: GIT_WORKTREE_SYSTEM_PROMPT,
+	finishingBranch: FINISHING_BRANCH_SYSTEM_PROMPT,
+	writingSkills: WRITING_SKILLS_SYSTEM_PROMPT,
+	testingSkills: TESTING_SKILLS_SYSTEM_PROMPT,
+	sharingSkills: SHARING_SKILLS_SYSTEM_PROMPT,
+	usingSuperpowers: USING_SUPERPOWERS_SYSTEM_PROMPT
+};
+
+//#endregion
+//#region src/tools/superpowers/tools/index.ts
+/**
+* @fileoverview Superpowers Tools - Vercel AI SDK v6 tool implementations
+* @module @od-oneapp/ai-platform/superpowers/tools
+*/
+let generateValidatedObjectImpl = null;
+/**
+* Safe wrapper that throws a helpful error if not initialized
+*/
+function generateValidatedObject(prompt, schema, options) {
+	if (!generateValidatedObjectImpl) throw new Error("Superpowers not initialized. Call initSuperpowers({ generateValidatedObject }) before using any tools. See @od-oneapp/ai-platform documentation for setup instructions.");
+	return generateValidatedObjectImpl(prompt, schema, options);
+}
+/**
+* Initialize the superpowers module with required dependencies.
+* Must be called before using any superpower tools.
+*
+* @example
+* ```typescript
+* import { initSuperpowers } from '@od-oneapp/ai-platform/superpowers';
+* import { generateObject } from 'ai';
+*
+* initSuperpowers({
+*   generateValidatedObject: async (prompt, schema, options) => {
+*     const result = await generateObject({
+*       model: yourModel,
+*       prompt,
+*       schema,
+*       system: options?.system,
+*     });
+*     return result.object;
+*   },
+* });
+* ```
+*/
+function initSuperpowers(deps) {
+	generateValidatedObjectImpl = deps.generateValidatedObject;
+}
+const refineRequirements = tool({
+	description: "Analyze a vague or ambiguous request. Use this to brainstorm, identify edge cases, and generate clarifying questions before implementation.",
+	inputSchema: z.object({
+		rawRequest: z.string().describe("The user's original, potentially vague request"),
+		projectContext: z.string().optional().describe("Current tech stack or project constraints"),
+		existingCode: z.string().optional().describe("Relevant existing code snippets")
+	}),
+	execute: async ({ rawRequest, projectContext, existingCode }) => {
+		return generateValidatedObject(`Analyze this request: "${rawRequest}"
+${projectContext ? `\nProject Context: ${projectContext}` : ""}
+${existingCode ? `\nExisting Code:\n\`\`\`\n${existingCode}\n\`\`\`` : ""}`, BrainstormOutputSchema, { system: BRAINSTORM_SYSTEM_PROMPT });
+	}
+});
+const consultArchitect = tool({
+	description: "Create a detailed implementation plan before writing code. Use for complex features or refactoring tasks.",
+	inputSchema: z.object({
+		featureRequest: z.string().describe("The feature or change to plan"),
+		currentContext: z.string().describe("Summary of relevant existing files, architecture, or constraints"),
+		constraints: z.array(z.string()).optional().describe("Technical or business constraints"),
+		existingCode: z.string().optional().describe("Relevant existing code to consider")
+	}),
+	execute: async ({ featureRequest, currentContext, constraints, existingCode }) => {
+		return generateValidatedObject(`Create an implementation plan for: "${featureRequest}"
+
+Current Context:
+${currentContext}
+
+${constraints ? `Constraints:\n${constraints.map((c) => `- ${c}`).join("\n")}` : ""}
+${existingCode ? `\nRelevant Code:\n\`\`\`\n${existingCode}\n\`\`\`` : ""}`, PlanOutputSchema, { system: PLANNER_SYSTEM_PROMPT });
+	}
+});
+const reviewDesign = tool({
+	description: "Review proposed changes against project conventions and architecture. Use before major implementations.",
+	inputSchema: z.object({
+		proposedChanges: z.string().describe("Description of proposed changes"),
+		conventions: z.string().describe("Project conventions (e.g., from CLAUDE.md)"),
+		existingArchitecture: z.string().optional().describe("Current architecture description"),
+		affectedAreas: z.array(z.string()).optional().describe("Areas of codebase affected")
+	}),
+	execute: async ({ proposedChanges, conventions, existingArchitecture, affectedAreas }) => {
+		return generateValidatedObject(`Review this proposed change against project conventions:
+
+Proposed Changes:
+${proposedChanges}
+
+Project Conventions:
+${conventions}
+
+${existingArchitecture ? `\nExisting Architecture:\n${existingArchitecture}` : ""}
+${affectedAreas ? `\nAffected Areas:\n${affectedAreas.map((a) => `- ${a}`).join("\n")}` : ""}`, DesignReviewOutputSchema, { system: DESIGN_REVIEW_SYSTEM_PROMPT });
+	}
+});
+const runTDDCycle = tool({
+	description: "Guide implementation through Test-Driven Development (Red-Green-Refactor cycle). Use for new features that need thorough testing.",
+	inputSchema: z.object({
+		feature: z.string().describe("The feature to implement with TDD"),
+		testFramework: z.enum([
+			"vitest",
+			"jest",
+			"mocha",
+			"playwright"
+		]).default("vitest"),
+		targetPath: z.string().describe("Path where implementation should go"),
+		existingTests: z.string().optional().describe("Existing test code to build upon"),
+		iteration: z.number().default(1).describe("Current TDD iteration number"),
+		previousResult: z.string().optional().describe("Result from previous iteration")
+	}),
+	execute: async ({ feature, testFramework, targetPath, existingTests, iteration, previousResult }) => {
+		return generateValidatedObject(`TDD Iteration ${iteration} for: "${feature}"
+
+Target Path: ${targetPath}
+Test Framework: ${testFramework}
+${existingTests ? `\nExisting Tests:\n\`\`\`\n${existingTests}\n\`\`\`` : ""}
+${previousResult ? `\nPrevious Iteration Result:\n${previousResult}` : ""}
+
+${iteration === 1 ? "Start by writing a failing test (RED phase)." : "Continue the TDD cycle based on previous results."}`, TDDOutputSchema, { system: TDD_SYSTEM_PROMPT });
+	}
+});
+const reviewCode = tool({
+	description: "Review code for security, performance, maintainability, and test coverage. Use before committing significant changes.",
+	inputSchema: z.object({
+		code: z.string().describe("The code to review"),
+		language: z.enum([
+			"typescript",
+			"javascript",
+			"python",
+			"rust",
+			"go",
+			"java",
+			"other"
+		]),
+		context: z.string().optional().describe("Context about what this code does"),
+		projectConventions: z.string().optional().describe("Project-specific conventions to check"),
+		focusAreas: z.array(z.enum([
+			"security",
+			"performance",
+			"maintainability",
+			"testing"
+		])).optional()
+	}),
+	execute: async ({ code, language, context, projectConventions, focusAreas }) => {
+		return generateValidatedObject(`Review this ${language} code:
+
+\`\`\`${language}
+${code}
+\`\`\`
+
+${context ? `Context: ${context}` : ""}
+${projectConventions ? `\nProject Conventions:\n${projectConventions}` : ""}
+${focusAreas ? `\nFocus Areas: ${focusAreas.join(", ")}` : ""}`, CodeReviewOutputSchema, { system: CODE_REVIEW_SYSTEM_PROMPT });
+	}
+});
+const detectAntiPatterns = tool({
+	description: "Scan code for common anti-patterns and code smells. Use to maintain code quality.",
+	inputSchema: z.object({
+		code: z.string().describe("The code to analyze"),
+		filePath: z.string().describe("File path for context"),
+		language: z.enum([
+			"typescript",
+			"javascript",
+			"python",
+			"rust",
+			"go",
+			"java",
+			"other"
+		]).default("typescript"),
+		strictMode: z.boolean().default(false).describe("Enable strict checking for more issues")
+	}),
+	execute: async ({ code, filePath, language, strictMode }) => {
+		return generateValidatedObject(`Analyze this ${language} code for anti-patterns:
+
+File: ${filePath}
+Strict Mode: ${strictMode}
+
+\`\`\`${language}
+${code}
+\`\`\``, AntiPatternOutputSchema, { system: ANTI_PATTERN_SYSTEM_PROMPT });
+	}
+});
+const systematicDebug = tool({
+	description: "Debug issues systematically using 4-phase root cause analysis. NO FIXES WITHOUT INVESTIGATION FIRST.",
+	inputSchema: z.object({
+		symptom: z.string().describe("The error message, unexpected behavior, or symptom observed"),
+		context: z.string().describe("Where and when the issue occurs"),
+		recentChanges: z.array(z.string()).optional().describe("Recent commits or changes"),
+		failingCode: z.string().optional().describe("Code that is failing")
+	}),
+	execute: async ({ symptom, context, recentChanges, failingCode }) => {
+		return generateValidatedObject(`Systematically debug this issue:
+
+Symptom: ${symptom}
+Context: ${context}
+${recentChanges ? `Recent Changes:\n${recentChanges.map((c) => `- ${c}`).join("\n")}` : ""}
+${failingCode ? `\nFailing Code:\n\`\`\`\n${failingCode}\n\`\`\`` : ""}`, SystematicDebuggingOutputSchema, { system: SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT });
+	}
+});
+const traceRootCause = tool({
+	description: "Trace a symptom back through system layers to find the root cause.",
+	inputSchema: z.object({
+		symptom: z.string().describe("The observed symptom or error"),
+		systemLayers: z.array(z.string()).describe("System layers to trace through (UI, API, DB, etc.)"),
+		codeContext: z.string().optional().describe("Relevant code snippets")
+	}),
+	execute: async ({ symptom, systemLayers, codeContext }) => {
+		return generateValidatedObject(`Trace the root cause of this symptom:
+
+Symptom: ${symptom}
+System Layers: ${systemLayers.join(" → ")}
+${codeContext ? `\nCode Context:\n\`\`\`\n${codeContext}\n\`\`\`` : ""}`, RootCauseTracingOutputSchema, { system: ROOT_CAUSE_TRACING_SYSTEM_PROMPT });
+	}
+});
+const analyzeDefenseInDepth = tool({
+	description: "Analyze security layers and identify gaps in defense-in-depth strategy.",
+	inputSchema: z.object({
+		component: z.string().describe("Component or system to analyze"),
+		code: z.string().describe("Code to analyze for security layers"),
+		threatModel: z.string().optional().describe("Known threats to protect against")
+	}),
+	execute: async ({ component, code, threatModel }) => {
+		return generateValidatedObject(`Analyze defense-in-depth for this component:
+
+Component: ${component}
+${threatModel ? `Threat Model: ${threatModel}` : ""}
+
+Code:
+\`\`\`
+${code}
+\`\`\``, DefenseInDepthOutputSchema, { system: DEFENSE_IN_DEPTH_SYSTEM_PROMPT });
+	}
+});
+const analyzeAsyncPatterns = tool({
+	description: "Analyze async code and tests for proper waiting patterns. Identifies flaky patterns.",
+	inputSchema: z.object({
+		code: z.string().describe("Async code or test code to analyze"),
+		framework: z.enum([
+			"vitest",
+			"jest",
+			"playwright",
+			"cypress",
+			"other"
+		]).describe("Testing framework")
+	}),
+	execute: async ({ code, framework }) => {
+		return generateValidatedObject(`Analyze async patterns in this ${framework} code:
+
+\`\`\`
+${code}
+\`\`\``, AsyncPatternsOutputSchema, { system: CONDITION_BASED_WAITING_SYSTEM_PROMPT });
+	}
+});
+const executePlan = tool({
+	description: "Execute an implementation plan step by step with human checkpoints.",
+	inputSchema: z.object({
+		plan: z.string().describe("The plan to execute (JSON or description)"),
+		currentStep: z.number().describe("Current step number to execute"),
+		previousResults: z.string().optional().describe("Results from previous steps")
+	}),
+	execute: async ({ plan, currentStep, previousResults }) => {
+		return generateValidatedObject(`Execute step ${currentStep} of this plan:
+
+Plan:
+${plan}
+
+${previousResults ? `Previous Results:\n${previousResults}` : ""}`, PlanExecutionOutputSchema, { system: EXECUTING_PLANS_SYSTEM_PROMPT });
+	}
+});
+const dispatchAgents = tool({
+	description: "Decompose a task into parallel subtasks and coordinate agent execution.",
+	inputSchema: z.object({
+		task: z.string().describe("The task to decompose"),
+		availableAgents: z.array(z.string()).describe("Available agent types"),
+		constraints: z.string().optional().describe("Constraints on parallel execution")
+	}),
+	execute: async ({ task, availableAgents, constraints }) => {
+		return generateValidatedObject(`Decompose and dispatch agents for this task:
+
+Task: ${task}
+Available Agents: ${availableAgents.join(", ")}
+${constraints ? `Constraints: ${constraints}` : ""}`, AgentDispatchOutputSchema, { system: DISPATCHING_AGENTS_SYSTEM_PROMPT });
+	}
+});
+const runSubagentDev = tool({
+	description: "Coordinate subagent-driven development with quality gates.",
+	inputSchema: z.object({
+		objective: z.string().describe("Development objective"),
+		qualityGates: z.array(z.string()).describe("Quality gates to pass"),
+		iteration: z.number().default(1).describe("Current iteration number")
+	}),
+	execute: async ({ objective, qualityGates, iteration }) => {
+		return generateValidatedObject(`Subagent-driven development iteration ${iteration}:
+
+Objective: ${objective}
+Quality Gates:
+${qualityGates.map((g) => `- ${g}`).join("\n")}`, SubagentDevOutputSchema, { system: SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT });
+	}
+});
+const processCodeReview = tool({
+	description: "Process and respond to code review feedback constructively.",
+	inputSchema: z.object({
+		feedback: z.string().describe("The code review feedback received"),
+		originalCode: z.string().describe("The original code that was reviewed"),
+		reviewerId: z.string().optional().describe("Identifier for the reviewer")
+	}),
+	execute: async ({ feedback, originalCode, reviewerId }) => {
+		return generateValidatedObject(`Process this code review feedback:
+
+${reviewerId ? `Reviewer: ${reviewerId}` : ""}
+
+Feedback:
+${feedback}
+
+Original Code:
+\`\`\`
+${originalCode}
+\`\`\``, CodeReviewResponseOutputSchema, { system: RECEIVING_CODE_REVIEW_SYSTEM_PROMPT });
+	}
+});
+const analyzeCommit = tool({
+	description: "Generate a semantic commit message by analyzing code changes. Use before git commit.",
+	inputSchema: z.object({
+		diff: z.string().describe("Git diff of changes"),
+		changedFiles: z.array(z.string()).describe("List of changed file paths"),
+		context: z.string().optional().describe("Additional context about the changes"),
+		relatedIssue: z.string().optional().describe("Related issue or ticket number")
+	}),
+	execute: async ({ diff, changedFiles, context, relatedIssue }) => {
+		return generateValidatedObject(`Analyze these code changes and generate a commit message:
+
+Changed Files:
+${changedFiles.map((f) => `- ${f}`).join("\n")}
+
+${context ? `Context: ${context}` : ""}
+${relatedIssue ? `Related Issue: ${relatedIssue}` : ""}
+
+Diff:
+\`\`\`diff
+${diff}
+\`\`\``, CommitAnalysisOutputSchema, { system: COMMIT_ANALYSIS_SYSTEM_PROMPT });
+	}
+});
+const manageWorktree = tool({
+	description: "Manage git worktrees for isolated feature development.",
+	inputSchema: z.object({
+		action: z.enum([
+			"create",
+			"list",
+			"remove",
+			"switch"
+		]).describe("Worktree action to perform"),
+		branchName: z.string().optional().describe("Branch name for the worktree"),
+		baseBranch: z.string().optional().describe("Base branch to create from"),
+		path: z.string().optional().describe("Path for the worktree")
+	}),
+	execute: async ({ action, branchName, baseBranch, path }) => {
+		return generateValidatedObject(`Git worktree ${action}:
+
+${branchName ? `Branch: ${branchName}` : ""}
+${baseBranch ? `Base Branch: ${baseBranch}` : ""}
+${path ? `Path: ${path}` : ""}`, WorktreeOutputSchema, { system: GIT_WORKTREE_SYSTEM_PROMPT });
+	}
+});
+const finishBranch = tool({
+	description: "Complete and prepare a branch for merging with pre-flight checks.",
+	inputSchema: z.object({
+		branchName: z.string().describe("Branch to finish"),
+		targetBranch: z.string().describe("Target branch for merge"),
+		createPR: z.boolean().default(true).describe("Whether to create a PR")
+	}),
+	execute: async ({ branchName, targetBranch, createPR }) => {
+		return generateValidatedObject(`Finish branch and prepare for merge:
+
+Branch: ${branchName}
+Target: ${targetBranch}
+Create PR: ${createPR}`, BranchFinishOutputSchema, { system: FINISHING_BRANCH_SYSTEM_PROMPT });
+	}
+});
+const writeSkill = tool({
+	description: "Create a new superpower/skill definition.",
+	inputSchema: z.object({
+		skillName: z.string().describe("Name of the skill to create"),
+		purpose: z.string().describe("What problem this skill solves"),
+		examples: z.array(z.string()).describe("Example use cases")
+	}),
+	execute: async ({ skillName, purpose, examples }) => {
+		return generateValidatedObject(`Create a new skill definition:
+
+Skill Name: ${skillName}
+Purpose: ${purpose}
+Examples:
+${examples.map((e) => `- ${e}`).join("\n")}`, SkillWriteOutputSchema, { system: WRITING_SKILLS_SYSTEM_PROMPT });
+	}
+});
+const testSkill = tool({
+	description: "Test a skill definition for quality and completeness.",
+	inputSchema: z.object({
+		skillDefinition: z.string().describe("The skill definition to test"),
+		testCases: z.array(z.string()).describe("Test cases to run")
+	}),
+	execute: async ({ skillDefinition, testCases }) => {
+		return generateValidatedObject(`Test this skill definition:
+
+${skillDefinition}
+
+Test Cases:
+${testCases.map((t) => `- ${t}`).join("\n")}`, SkillTestOutputSchema, { system: TESTING_SKILLS_SYSTEM_PROMPT });
+	}
+});
+const shareSkill = tool({
+	description: "Package a skill for sharing and distribution.",
+	inputSchema: z.object({
+		skillDefinition: z.string().describe("The skill to package"),
+		targetPlatforms: z.array(z.string()).describe("Target platforms for distribution"),
+		version: z.string().default("1.0.0").describe("Version number")
+	}),
+	execute: async ({ skillDefinition, targetPlatforms, version }) => {
+		return generateValidatedObject(`Package skill for distribution:
+
+Version: ${version}
+Target Platforms: ${targetPlatforms.join(", ")}
+
+Skill:
+${skillDefinition}`, SkillShareOutputSchema, { system: SHARING_SKILLS_SYSTEM_PROMPT });
+	}
+});
+const introduceSuperpowers = tool({
+	description: "Introduce the superpowers framework and guide usage.",
+	inputSchema: z.object({
+		projectContext: z.string().describe("Context about the project"),
+		userExperience: z.enum([
+			"beginner",
+			"intermediate",
+			"expert"
+		]).default("intermediate")
+	}),
+	execute: async ({ projectContext, userExperience }) => {
+		return generateValidatedObject(`Introduce superpowers framework:
+
+Project Context: ${projectContext}
+User Experience Level: ${userExperience}`, SuperpowersIntroOutputSchema, { system: USING_SUPERPOWERS_SYSTEM_PROMPT });
+	}
+});
+const planningTools = {
+	refineRequirements,
+	consultArchitect,
+	reviewDesign
+};
+const qualityTools = {
+	runTDDCycle,
+	reviewCode,
+	detectAntiPatterns
+};
+const debuggingTools = {
+	systematicDebug,
+	traceRootCause,
+	analyzeDefenseInDepth,
+	analyzeAsyncPatterns
+};
+const workflowTools = {
+	executePlan,
+	dispatchAgents,
+	runSubagentDev
+};
+const codeReviewTools = {
+	reviewCode,
+	processCodeReview,
+	detectAntiPatterns
+};
+const gitTools = {
+	analyzeCommit,
+	manageWorktree,
+	finishBranch
+};
+const metaTools = {
+	writeSkill,
+	testSkill,
+	shareSkill,
+	introduceSuperpowers
+};
+/**
+* All superpower tools combined.
+*
+* NOTE: Some tools appear in multiple collections (e.g., `reviewCode` in both
+* `qualityTools` and `codeReviewTools`, `detectAntiPatterns` in both `qualityTools`
+* and `codeReviewTools`). This is intentional - tools can belong to multiple categories.
+* The spread operator will use the last occurrence, so ensure consistent tool definitions.
+*/
+const allSuperpowerTools = {
+	...planningTools,
+	...qualityTools,
+	...debuggingTools,
+	...workflowTools,
+	...codeReviewTools,
+	...gitTools,
+	...metaTools
+};
+
+//#endregion
+export { AgentDispatchOutputSchema as $, writeSkill as A, FINISHING_BRANCH_SYSTEM_PROMPT as B, runSubagentDev as C, testSkill as D, systematicDebug as E, CONDITION_BASED_WAITING_SYSTEM_PROMPT as F, SHARING_SKILLS_SYSTEM_PROMPT as G, PLANNER_SYSTEM_PROMPT as H, DEFENSE_IN_DEPTH_SYSTEM_PROMPT as I, TDD_SYSTEM_PROMPT as J, SUBAGENT_DRIVEN_DEV_SYSTEM_PROMPT as K, DESIGN_REVIEW_SYSTEM_PROMPT as L, BRAINSTORM_SYSTEM_PROMPT as M, CODE_REVIEW_SYSTEM_PROMPT as N, traceRootCause as O, COMMIT_ANALYSIS_SYSTEM_PROMPT as P, systemPrompts as Q, DISPATCHING_AGENTS_SYSTEM_PROMPT as R, reviewDesign as S, shareSkill as T, RECEIVING_CODE_REVIEW_SYSTEM_PROMPT as U, GIT_WORKTREE_SYSTEM_PROMPT as V, ROOT_CAUSE_TRACING_SYSTEM_PROMPT as W, USING_SUPERPOWERS_SYSTEM_PROMPT as X, TESTING_SKILLS_SYSTEM_PROMPT as Y, WRITING_SKILLS_SYSTEM_PROMPT as Z, planningTools as _, SystematicDebuggingOutputSchema as _t, codeReviewTools as a, CodeReviewResponseOutputSchema as at, refineRequirements as b, detectAntiPatterns as c, DesignReviewOutputSchema as ct, finishBranch as d, RootCauseTracingOutputSchema as dt, AntiPatternOutputSchema as et, gitTools as f, SkillShareOutputSchema as ft, metaTools as g, SuperpowersIntroOutputSchema as gt, manageWorktree as h, SubagentDevOutputSchema as ht, analyzeDefenseInDepth as i, CodeReviewOutputSchema as it, ANTI_PATTERN_SYSTEM_PROMPT as j, workflowTools as k, dispatchAgents as l, PlanExecutionOutputSchema as lt, introduceSuperpowers as m, SkillWriteOutputSchema as mt, analyzeAsyncPatterns as n, BrainstormOutputSchema as nt, consultArchitect as o, CommitAnalysisOutputSchema as ot, initSuperpowers as p, SkillTestOutputSchema as pt, SYSTEMATIC_DEBUGGING_SYSTEM_PROMPT as q, analyzeCommit as r, BranchFinishOutputSchema as rt, debuggingTools as s, DefenseInDepthOutputSchema as st, allSuperpowerTools as t, AsyncPatternsOutputSchema as tt, executePlan as u, PlanOutputSchema as ut, processCodeReview as v, TDDOutputSchema as vt, runTDDCycle as w, reviewCode as x, qualityTools as y, WorktreeOutputSchema as yt, EXECUTING_PLANS_SYSTEM_PROMPT as z };
+//# sourceMappingURL=tools-BuS2Uv0q.mjs.map