# Task Completion Enforcer Prover MCP for AI Agents AI Agent Connect > Task Completion Enforcer Prover ensures your AI actually finishes the job. It stops agents from leaving TODO comments, forgetting half your requirements, or declaring a project done when it is only 60% finished. It forces a strict loop of requirement extraction, evidence mapping, and gap closing to guarantee every single request is met before the agent stops working. ## Overview - **Category:** productivity - **Price:** Free - **Endpoint:** https://edge.vinkius.com/vk_preview_TRZuombSa31k5jscX1KCJ089zhMtfMmLCTAbBgKK/ai-agent-connect - **Tags:** task-completion, qa, verification, llm-enforcement, checklist, requirement-tracking, anti-placeholder ## Description You have been there. You ask an agent to build five endpoints, write tests, and update the docs. It gives you three endpoints, leaves TODO comments in the tests, and tells you it is finished. You then spend forty minutes hunting for what is missing. This happens because LLMs often prioritize finishing a generation over finishing a task. This Connector changes that dynamic. It forces your agent to follow a strict verification loop. Instead of just writing code, the agent has to extract every single requirement into an actionable checklist first. It then has to map every line of code or every test result back to those specific requirements. If it finds a gap, it has to fix it immediately before it can move on. It is like having a foreman who will not let the crew leave until every item on the punch list is checked off. This is a common pitfall in software development where the agent settles for the easiest path to a completion signal. It might skip the tedious documentation or the non-obvious edge cases because it does not see the full scope of your request. This Connector forces the agent to be honest about its progress. It creates a hard stop where the agent must identify every missing piece and execute the fix before it can proceed. You no longer have to play detective with your own codebase. You get a reliable, finished result that actually aligns with your original goals. By using this Connector through the Vinkius catalog, you move from guessing if the work is done to having verifiable proof of completion. ## Tools ### validate_task_completion This tool forces the agent to prove it finished every requirement by mapping artifacts to a checklist. It catches placeholders and scope drift before the agent declares the task complete. ## Prompt Examples **Prompt:** ``` I need you to build a login system with 3 endpoints, unit tests, and an updated readme. Use the enforcer tool to make sure you don't miss anything. ``` **Response:** ``` ### Requirement Extraction 1. POST /login endpoint 2. GET /user profile endpoint 3. PUT /update user endpoint 4. Unit tests for all 3 endpoints 5. Update README.md **Status:** Analyzing requirements... I will begin by building the endpoints. I will call the validation tool once the code is written to ensure every test and doc requirement is met. ``` **Prompt:** ``` The agent just told me it's done but I see 'TODO' in the auth file. Use the enforcer to fix this. ``` **Response:** ``` ### Gap Identification - **Requirement:** Full Auth Logic - **Evidence:** Found 'TODO' in auth.py:42 - **Status:** FAILED **Action:** I am now replacing the placeholder with the actual password hashing logic. I will call the validation tool again once complete. ``` **Prompt:** ``` I'm worried you'll forget the specific requirements for the database migration. Please use the enforcer to verify the final plan. ``` **Response:** ``` ### Requirement Checklist - [ ] Create 'users' table - [ ] Migrate existing data - [ ] Update connection string - [ ] Verify data integrity I have mapped these to the migration script. I will verify each step against the original request before declaring completion. ``` ## Capabilities ### Extract requirements into checklists The agent turns your prompt into a numbered list of specific, actionable tasks. ### Map code artifacts to requests Every line of code or test result is linked back to a specific requirement for proof. ### Identify missing tasks The agent admits what it has not done yet instead of pretending the task is finished. ### Execute missing work automatically The agent fixes identified gaps immediately without needing a new prompt. ### Verify final output against prompts A final line-by-line comparison ensures the output matches your original instructions. ## Use Cases ### The Done Lie An agent says it finished 5 APIs but only did 3. Use validate_task_completion to force it to find and build the missing 2. ### Placeholder Cleanup You get a codebase full of TODO comments. Use validate_task_completion to make the agent replace them with real logic. ### Documentation Drift The code is done but the docs are old. The tool ensures the docs are updated as a mandatory requirement before the agent stops. ### Complex Refactors When moving logic between files, the tool ensures every side effect is accounted for and verified against the original plan. ## Benefits - Stop chasing TODOs: The tool identifies placeholder infection early so you do not find FIXME comments in your production code. By using validate_task_completion, your agent actually finishes the logic instead of just leaving notes. - Prevent requirement amnesia: It forces the agent to list every request as a numbered checklist, ensuring nothing gets dropped mid-task. It makes sure the agent does not forget a small but vital instruction from the start of your prompt. - Eliminate scope drift: Your agent stays focused on your actual request instead of solving adjacent problems you did not ask for. This keeps the project on track and prevents the agent from going down unnecessary rabbit holes. - Get verifiable evidence: Every finished item gets mapped to a specific file path or line number for easy review. When you use validate_task_completion, you can see exactly where the work happened without hunting through files. - Automated gap closing: If the agent finds a missing piece, it is forced to execute the work immediately rather than just noting it. This saves you from having to prompt the agent multiple times to fix individual parts. - Final verification: The tool requires a line-by-line comparison between your original prompt and the final output. This ensures that the final delivery is a 1:1 match for what you actually asked for. ## How It Works The bottom line is that your agent stops making excuses and starts finishing every part of your request. 1. Provide your agent with a complex, multi-step instruction. 2. The agent uses the tool to extract requirements and identify missing work. 3. The agent closes all gaps and provides a final verification report. ## Frequently Asked Questions **How does Task Completion Enforcer Prover stop my agent from leaving TODOs?** It forces the agent to identify every requirement as a checklist. If it finds a gap or a placeholder, it is required to fix it immediately before it can move to the next step. **Can Task Completion Enforcer Prover handle complex coding tasks?** Yes. It is specifically designed for multi-step coding projects where missing a single detail like a test case or a specific documentation update causes a headache. **Does Task Completion Enforcer Prover work with Cursor or VS Code?** It works with any MCP-compatible client, including Cursor, VS Code, and Claude, allowing you to use it directly within your existing development environment. **Why does my agent keep saying it's done when it isn't?** LLMs often prioritize finishing a generation over finishing a task. This Connector forces the agent to provide verifiable evidence for every requirement before it is allowed to say it is done. **How does the evidence mapping work in Task Completion Enforcer Prover?** The agent must link every finished requirement to a specific artifact, such as a file path, a line number, or a specific test result, to prove the work was actually completed. **Will Task Completion Enforcer Prover help with documentation?** Yes. It treats documentation as a mandatory requirement. The agent cannot declare the task finished until it provides evidence that the docs have been updated as requested. **Why do LLMs forget requirements?** Autoregressive generation allocates decreasing attention to earlier tokens as output grows. A 10-step task at token 200 competes with 2,000 tokens of generated output for attention. The model literally loses track of requirement #7 while implementing requirement #3. The fix: force a re-read of ALL requirements before declaring completion. **What counts as 'completion evidence'?** Not 'I implemented the function.' Evidence means: 'Requirement 1: POST /users endpoint at src/routes/users.ts lines 15-42, validates email/name/role via Zod schema, returns 201 with user object.' File path, line number, specific behavior. If you cannot point to the exact artifact, it is not done. **What happens when gaps are found?** The LLM MUST close them immediately — not later, not in a follow-up. Do the remaining work NOW. Then call this tool AGAIN to verify the gaps are actually closed. The loop continues until EVERY requirement has concrete evidence. 'I will do it later' is rejected. 'I just did it, here is the evidence' is accepted.