If you can afford to hire consultants, and you're keeping a little for profit, you're probably able to hire full-time employees. That's making some assumptions about lags between jobs, what the employees expect in terms of "bench time" and corresponding pay.
You may not be able to hire the same consultants as employees at the same rates, as you may have to reduce your pay rate to cover some of the employee overhead. Reasonable contractors willing to work full-time should be able to accept this as they would then not have the same responsibility for accounting for their own taxes, and may appreciate whatever benefits you may be able to offer.
Consider not only the obvious things like health insurance, but also the PTO and sick days where you have to pay even when they aren't earning; built into the overhead correctly, it still comes out of the billable hours. It may be that you have to offer a package that includes a "base" rate that covers what they'll get paid on the bench, and a "job" rate that pays more while they're working; it might be that you have to do some math and figure out that less pay means more bench buffer; perhaps even build in a "profit sharing" mechanism that returns that buffer to the employee if the bench fund isn't used. None of this is new; check around the Interwebs for what other small houses do.
As for the bugs, I would stake a cross-country ride on the back of my motorcycle that at least some of the time something changes, and that's why there are bugs.
You hear the customer requests and from these you make outstanding designs and documents. After whatever negotiation and complete requirements gathering and design review they accept the designs and documents and your bid. Your programmers see and understand these documents, and their code reflects them beautifully. Then the customer sees the work at the delivery points, and perhaps finds things that aren't right. Maybe they see what has been delivered is right, but want a little more; or they see that it works in the cases everyone thought of, but not in the cases no one thought of; or they see that you've built what they said, but not what they wanted.
This could be the result of an iterative development cycle, communications, or straight-up missed things. This could be because something was done right, then a change was made (a new idea, incremental development, or previously undiscovered use case)...now the code and plan and customer are out of sync.
The hard reality is that bugs occur.
I understand the sentiment of avoiding developers who make bugs to extend contracts, but you have to realize that none of us is perfect, as hard as we may try, and any time another party is involved, there's an increase in opportunity for things to not go right. Work hard to compromise on fixing the things that have gone wrong (charge the customer, pay the developer) and things that are "malicious" or otherwise on purpose with an intent of dragging on contracts.
Be critical and strict with your developers, and keep them in line in terms of design compliance and coding standards, and make sure they aren't trying to stretch contracts; mitigate it with TDD or TDD-like practices like using unit tests to conform code to contracted specs. Also be aware of customer changes that sneak in...even little things like "that should be over more or bluer or say this instead of that" can introduce both distraction and unintended changes that can lead to the deviations from existing code or on code for which future work may depend.
It's a chore, but you can either build some "bug time" into your estimates and project plans, be hyper-vigilant about change control, or be super-strict about deviating from the plan. Somewhere between the first two is where reality lies, if you were thinking about the last two.