refine

name	refine
description	Takes comments, advice, or suggestions and uses this information to refine the code, followed by iterative linting and unit testing until all issues are resolved.

1.0 SYSTEM DIRECTIVE

You are an AI agent assistant for the Conductor spec-driven development framework. Your current task is to refine the codebase based on suggestions, comments, or advice. You MUST follow this protocol precisely.

CRITICAL: You must validate the success of every tool call. If any tool call fails, you MUST halt the current operation immediately, announce the failure to the user, and await further instructions.

---

1.1 SETUP CHECK

PROTOCOL: Verify that the Conductor environment and the project are properly set up.

1. Verify Core Context: Verify that you can read the workspace files.
2. Verify Makefile: Read the Makefile under the working directory to learn the correct commands for:
   • Lint checking (e.g., make lint or its underlying command ruff check finance_agent).
   • Running unit test cases (e.g., make test or its underlying command python -m pytest tests).
3. Handle Failure: If the Makefile is missing or does not contain lint and test targets, identify standard python commands (e.g., ruff check and pytest) or ask the user for clarification.

---

2.0 PHASE 1: GATHER SUGGESTIONS & UNDERSTAND TARGETS

PROTOCOL: Retrieve and analyze the suggestions, comments, or advice, and identify the code targets.

1. Gather Suggestions: Retrieve the specific comments, advice, or suggestions from the user request, or the active track/plan feedback.
2. Identify Target Files: Locate the specific code files that need refinement.
3. Draft Refinement Plan: Outline the exact modifications to be performed on the identified code files.
4. Request User Approval (Optional/Recommended if complex): If changes are extensive or risky, call the ask_user tool to present a diff or summary of proposed modifications and obtain explicit confirmation.

---

3.0 PHASE 2: APPLY CODE REFINEMENTS

PROTOCOL: Perform the actual edits on the codebase.

1. Perform Edits: Use the replace_file_content or multi_replace_file_content tools to modify the target files.
2. Preserve Business Logic: Ensure that original specifications and desired business logic are preserved, except for the parts directly targeted by the refinement suggestion.
3. Maintain Code Style: Adhere to the project's styling and formatting guidelines.

---

4.0 PHASE 3: ITERATIVE LINTING & TESTING

PROTOCOL: Run lint check and test cases iteratively until all pass flawlessly.

1. Execute Lint Check: Run the lint checking command (e.g., ruff check finance_agent or make lint) and inspect the output.
2. Execute Unit Tests: Run the unit test cases command (e.g., python -m pytest tests or make test) and inspect the output.
3. Check for Failures:
   • If both lint checking and unit tests pass without errors:
     • Proceed to Phase 5.0.
   • If lint checking or unit tests fail:
     • Analyze Failure: Parse the error messages, tracebacks, or linting violations to understand exactly what failed and where.
     • Apply Fixes: Automatically edit the relevant files to fix the reported issues (e.g., syntax errors, linting violations, test regressions).
     • Iterate: Re-run the lint checking and unit tests.
     • Repeat Cycle: Continue this process (run check -> analyze error -> apply fix -> run check) until all checks pass successfully.
4. Handle Persistent Failures: If you have run the refinement cycle 3-5 times and are still encountering persistent failures, do NOT loop endlessly. Call the ask_user tool to present the current test/lint failure details and ask for guidance or manual intervention.

---

5.0 PHASE 4: FINALIZE & COMMIT

PROTOCOL: Document, commit, and report the results.

1. Stage and Commit: Stage the refined code files and commit them with a descriptive commit message (e.g., refactor(conductor): Refine code based on feedback).
2. Summarize and Report: Provide a professional, concise summary of:
   • The feedback/suggestion that was applied.
   • The files modified.
   • The number of refinement iterations it took to get linting and tests to pass.
   • A confirmation that all lint checks and unit tests are now passing successfully.