chore(agents): add "Git workflow (every task)" rule to all agents + skills

Bakes the branching discipline into the team so it's followed automatically:
at the start of a new task, ask the user to commit + push any unpushed work,
then branch off main and build the feature on the new branch (never commit to
main), commit + push at the end. Mid-chain auto-spawned agents and read-only
agents (reviewer/verifier/security) stay on the task's branch and don't
re-branch, leaving the final commit to the task owner.

Appended one identical "## Git workflow (every task)" section to all 11
.claude/agents/*.md and all 11 .claude/skills/*/SKILL.md (22 files). Docs/
tooling only (.claude/ is not in the built app) — no version bump / CHANGELOG.

principal artifact + INDEX line; verifier PASS (all 22 blocks byte-identical,
frontmatter intact, scope limited to .claude + audit files, mid-chain clause
behaviorally sound).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VEsaHQx8cXr1hFrKU42UK6

.claude/agents/architect.md

@@ -26,3 +26,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/dba.md

@@ -29,3 +29,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/designer.md

@@ -28,3 +28,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/devops.md

@@ -31,3 +31,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/docwriter.md

@@ -23,3 +23,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/engineer.md

@@ -32,3 +32,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/principal.md

@@ -29,3 +29,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/reviewer.md

@@ -27,3 +27,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/security.md

@@ -31,3 +31,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/tester.md

@@ -26,3 +26,12 @@ task, what you changed, and your evidence (the commands you ran + their output).
 `VERDICT: REDO`, fix every listed gap and resubmit; only return once it returns `VERDICT: PASS`.
 There is no round cap — keep looping until PASS (the bar is *perfect for the task*); if the same gap persists across rounds with no progress, pull in `principal` to change approach, then keep going until PASS. Never skip this (`verifier`
 itself is exempt, to avoid recursion).
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.

.claude/agents/verifier.md

@@ -78,3 +78,12 @@ There is **no round cap** — hold the bar at *perfect for the task* and keep re
 progress**, add an `## Escalate: principal` note so principal can bring a different approach or
 specialist — that is to get the work unstuck and keep it moving toward PASS, **never** to give up
 or accept less than perfect.
+
+## Git workflow (every task)
+At the **start of a new task**: if the working tree has uncommitted or not-yet-pushed
+changes from earlier work, **ask the user to commit and push them first**. Then branch off
+`main` — `git checkout -b feature/<slug>` — and build the new feature on that branch;
+**never commit directly to `main`**. Commit at the end and `git push -u origin <branch>`.
+If you were auto-spawned mid-chain, or are a read-only agent (e.g. reviewer, verifier,
+security), you are already on the task's branch — **stay on it, don't re-branch**, and leave
+the final commit to the task owner.