feat(task): implement strict TCR (Test-Commit-Revert) protocol for working on tasks

Author: apiad

.gemini/commands/task.toml

@@ -13,14 +13,35 @@ Add a new task to `TASKS.md`.
 5. Ensure the task follows the existing formatting conventions and verify the file after the update.
 
 ### **Action: Work**
-Mark a task as 'In Progress' and assign user to it.
-1. Identify the target task from the arguments or context.
-2. Read `TASKS.md` and locate the corresponding entry.
-3. Update its status to `[/]` In Progress.
-4. Append the tag "(@!{{ git config user.email | cut -d'@' -f1 }})" to the task line.
-5. Ensure you don't overwrite existing assignments unless requested.
-6. If there is a plan for the task, use `ask_user` to confirm the next steps and start working on it.
-7. Otherwise, suggest user to invoke `/plan` command to create a plan before starting work.
+Implement a task using a strict Test-Commit-Revert (TCR) protocol on a feature branch.
+1. **Pre-flight Verification:**
+   - Verify `git status --porcelain` is empty (clean tree).
+   - Verify `git branch --show-current` is `main`.
+   - Run `make test` and ensure all tests pass. If any fail, notify the user and stop.
+2. **Task Setup:**
+   - Identify the target task from arguments or context.
+   - Mark it as `[/] In Progress (@!{{ git config user.email | cut -d'@' -f1 }})` in `TASKS.md`.
+   - Generate a descriptive kebab-case branch name (e.g., `feature/task-description`).
+   - Create and switch to the branch: `git checkout -b <branch-name>`.
+3. **The TCR Loop:**
+   - Break the task into granular, testable steps.
+   - For each step:
+     - **Red:** Write a failing test. Run `make test` to confirm it fails specifically for the new case.
+     - **Green:** Implement the minimal code needed to pass the test.
+     - **Verify:** Run `make test`.
+       - **If Pass:** Run `git add . && git commit -m "Step: <description of changes>"`.
+       - **If Fail:** Attempt one quick fix. If it still fails, run `git checkout .` to revert to the last green state.
+     - **Check-in:** Use `ask_user` to report the step's result (Commit or Revert) and confirm the next step.
+4. **Integration & Finalization:**
+   - Once all steps are complete, run a full `make test`.
+   - Use `ask_user` to request permission to merge back to `main`.
+   - If approved:
+     - Switch to `main`: `git checkout main`.
+     - Merge/Rebase the branch: `git merge <branch-name>`.
+     - Run `make test` on `main`.
+     - Delete the feature branch: `git branch -d <branch-name>`.
+   - Update `TASKS.md` to reflect the current state (mark as `[x] Done` if complete).
+5. **Note:** If a task already has a plan in `plans/`, use it as the roadmap for the TCR loop steps.
 
 ### **Action: Report**
 Produce a strategic report of current tasks.

plans/implement-tcr-task-command.md

@@ -0,0 +1,49 @@
+# Plan: Implement TCR Workflow for `/task`
+
+## Objective
+Refactor the `task` command in `.gemini/commands/task.toml` to prioritize a strict Test-Commit-Revert (TCR) protocol for the 'Work' action, ensuring all development happens on feature branches with granular, verified commits.
+
+## Context & Requirements
+- **Strict Pre-requisites:** Clean working tree, on `main` branch, all tests pass (`make`).
+- **Isolation:** All work must occur on an auto-generated feature/bugfix branch.
+- **TCR Protocol:**
+  - Break tasks into granular steps.
+  - **Red:** Write a failing test and verify failure.
+  - **Green:** Implement solution.
+  - **Commit:** If tests pass, commit immediately.
+  - **Revert:** If tests fail (after brief leeway), revert to the last green state.
+- **User Interaction:** Frequent checkpoints using `ask_user` after each step and before final merge.
+- **Finalization:** Full test run on branch before merging/rebasing to `main`.
+
+## Proposed Changes
+
+### 1. Refactor `.gemini/commands/task.toml`
+Update the `Action: Work` section of the prompt to explicitly define the TCR workflow phases:
+
+- **Phase 1: Pre-flight Verification**
+  - Use `git status --porcelain` to ensure a clean tree.
+  - Use `git branch --show-current` to ensure the branch is `main`.
+  - Run `make` to establish a green baseline.
+- **Phase 2: Task Setup**
+  - Update `TASKS.md` status.
+  - Generate a kebab-case branch name from the task description.
+  - Create and switch to the branch (`git checkout -b <branch-name>`).
+- **Phase 3: The TCR Loop**
+  - Divide the task into small, testable increments.
+  - For each increment:
+    1. Write a failing test.
+    2. Run tests to confirm failure.
+    3. Implement the minimal code to pass.
+    4. Run `make`.
+    5. If pass: `git add . && git commit -m "Step: <step-description>"`.
+    6. If fail: Attempt quick fix; if failure persists, `git checkout .` to revert.
+    7. Use `ask_user` to report status and confirm the next increment.
+- **Phase 4: Integration**
+  - Run the full test suite one final time.
+  - Use `ask_user` to request permission to merge/rebase.
+  - Perform the merge/rebase to `main`, switch back to `main`, and clean up the feature branch.
+
+## Verification Strategy
+- **Logical Consistency:** Review the prompt to ensure instructions are unambiguous and cover all edge cases (e.g., failure during merge).
+- **Manual Walkthrough:** Simulate the workflow with a dummy task to verify the agent correctly identifies when to commit versus revert.
+- **Git State Audit:** Confirm that the final state results in a clean `main` branch with all tests passing.