diff --git a/.claude/agents/architect.md b/.claude/agents/architect.md index 544a832..cc727b7 100644 --- a/.claude/agents/architect.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/dba.md b/.claude/agents/dba.md index ad28d94..22611b6 100644 --- a/.claude/agents/dba.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/designer.md b/.claude/agents/designer.md index 91d4397..bfa134e 100644 --- a/.claude/agents/designer.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/devops.md b/.claude/agents/devops.md index f794da6..a92e936 100644 --- a/.claude/agents/devops.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/docwriter.md b/.claude/agents/docwriter.md index 6e127fd..d449e5e 100644 --- a/.claude/agents/docwriter.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/engineer.md b/.claude/agents/engineer.md index e369f0b..b5b5e8c 100644 --- a/.claude/agents/engineer.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/principal.md b/.claude/agents/principal.md index e512ba0..5c50866 100644 --- a/.claude/agents/principal.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/reviewer.md b/.claude/agents/reviewer.md index 73b97a0..c0dc438 100644 --- a/.claude/agents/reviewer.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/security.md b/.claude/agents/security.md index 80d7457..0b6531b 100644 --- a/.claude/agents/security.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/tester.md b/.claude/agents/tester.md index 757b33a..d2f7fa1 100644 --- a/.claude/agents/tester.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/agents/verifier.md b/.claude/agents/verifier.md index 4ea20f5..b710baa 100644 --- a/.claude/agents/verifier.md +++ b/.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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/architect/SKILL.md b/.claude/skills/architect/SKILL.md index fbc67f2..7393a6e 100644 --- a/.claude/skills/architect/SKILL.md +++ b/.claude/skills/architect/SKILL.md @@ -29,3 +29,12 @@ before finalizing. Keep recommendations concrete — name the option you'd pick Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/dba/SKILL.md b/.claude/skills/dba/SKILL.md index 29a348e..b2b608a 100644 --- a/.claude/skills/dba/SKILL.md +++ b/.claude/skills/dba/SKILL.md @@ -30,3 +30,12 @@ server. Present schema diffs before applying. End with `## Next`. Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/designer/SKILL.md b/.claude/skills/designer/SKILL.md index 7b3b13c..7a4cc1c 100644 --- a/.claude/skills/designer/SKILL.md +++ b/.claude/skills/designer/SKILL.md @@ -29,3 +29,12 @@ visual direction, show the option and check in once. End with `## Next`. Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/devops/SKILL.md b/.claude/skills/devops/SKILL.md index dae036d..d8545eb 100644 --- a/.claude/skills/devops/SKILL.md +++ b/.claude/skills/devops/SKILL.md @@ -31,3 +31,12 @@ user sign-off (deploy to the NAS is not a drive-by). End with `## Next`. Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/docwriter/SKILL.md b/.claude/skills/docwriter/SKILL.md index 49e46e1..4863ab0 100644 --- a/.claude/skills/docwriter/SKILL.md +++ b/.claude/skills/docwriter/SKILL.md @@ -28,3 +28,12 @@ Keep **Time Machine**'s docs true (see `CLAUDE.md`). Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/engineer/SKILL.md b/.claude/skills/engineer/SKILL.md index cc704f2..4821d4e 100644 --- a/.claude/skills/engineer/SKILL.md +++ b/.claude/skills/engineer/SKILL.md @@ -36,3 +36,12 @@ Trivial one-liner → just do it. Non-trivial → short plan, one check-in, exec Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/principal/SKILL.md b/.claude/skills/principal/SKILL.md index 8e17d86..c0f5ee9 100644 --- a/.claude/skills/principal/SKILL.md +++ b/.claude/skills/principal/SKILL.md @@ -38,3 +38,12 @@ secrets, or deploy to the NAS without explicit sign-off. End with a summary + `# Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/reviewer/SKILL.md b/.claude/skills/reviewer/SKILL.md index cd5656d..10cbff2 100644 --- a/.claude/skills/reviewer/SKILL.md +++ b/.claude/skills/reviewer/SKILL.md @@ -28,3 +28,12 @@ secrets, or deploy — route those to `/dba`, `/security`, `/devops`. End with ` Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/security/SKILL.md b/.claude/skills/security/SKILL.md index 05d9236..37043b6 100644 --- a/.claude/skills/security/SKILL.md +++ b/.claude/skills/security/SKILL.md @@ -30,3 +30,12 @@ Ranked findings (critical → minor), each with file:line, impact, and a fix own Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/tester/SKILL.md b/.claude/skills/tester/SKILL.md index c2578c5..f30dbb8 100644 --- a/.claude/skills/tester/SKILL.md +++ b/.claude/skills/tester/SKILL.md @@ -30,3 +30,12 @@ End with `## Next`. Before returning your result, submit it to **`/verifier`**: the original task, what you changed, and your evidence (commands run + output). If it returns `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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/.claude/skills/verifier/SKILL.md b/.claude/skills/verifier/SKILL.md index 911544e..a4eedfb 100644 --- a/.claude/skills/verifier/SKILL.md +++ b/.claude/skills/verifier/SKILL.md @@ -68,3 +68,12 @@ full rubric. Read-only: return the job, never fix it. There is **no round cap** progress**, add `## Escalate: principal` so principal can change the approach — to get unstuck and continue toward PASS, never to give up. Hold the bar at *perfect for the task* — approve because it's right, not because it's close. + +## 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/` — and build the new feature on that branch; +**never commit directly to `main`**. Commit at the end and `git push -u origin `. +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. diff --git a/claude_artifacts/INDEX.md b/claude_artifacts/INDEX.md index ad6186f..b76a628 100644 --- a/claude_artifacts/INDEX.md +++ b/claude_artifacts/INDEX.md @@ -1,4 +1,5 @@ # Artifact index +- [principal-20260829-122943](principal-20260829-122943.md) — Team policy: appended "Git workflow (every task)" rule to all 11 agents + 11 skills (commit+push unpushed work → branch from `main` → feature on new branch; mid-chain/read-only agents stay on the branch). Docs/tooling only, no version bump. verifier PASS. - [engineer-20260829-122201](engineer-20260829-122201.md) — PM Insights: category items in "Alert categories" + "Watch list" now full-width single-column accordions with more space (grid→flex column, roomier card/row padding). CSS-only. v2.3.2. verifier PASS. - [engineer-20260829-120746](engineer-20260829-120746.md) — PM Insights: "Alert categories" + "Watch list" now collapsible accordions (new `Section`, `ChevronIcon`, `.grid[hidden]` collapse, `aria-expanded`/`aria-controls`). v2.3.1. verifier PASS. - [engineer-20260827-190753](engineer-20260827-190753.md) — Jira statusDurations+movements + chart #17 (Active tab), /api/analytics/jira-durations, seed-enriched from board_state. v2.3.0. diff --git a/claude_artifacts/principal-20260829-122943.md b/claude_artifacts/principal-20260829-122943.md new file mode 100644 index 0000000..d01f08f --- /dev/null +++ b/claude_artifacts/principal-20260829-122943.md @@ -0,0 +1,31 @@ +# principal — team-wide "Git workflow (every task)" rule + +**Date:** 2026-08-29 · branch `chore/agent-git-workflow` · docs/tooling only (no app version bump) + +## Change +User asked to bake the git discipline into the team so it's followed automatically: +*"every new task → ask to commit and push not-pushed code → branch from master → build the +feature on the new branch."* User chose scope: **all 11 agents + all 11 skills** (22 files). + +Appended one identical `## Git workflow (every task)` section to the end of every +`.claude/agents/*.md` and `.claude/skills/*/SKILL.md`. The rule: +- At the **start of a new task**, if the tree has uncommitted/unpushed work, **ask the user + to commit and push it first**. +- Then **branch off `main`** (`git checkout -b feature/`), build the feature there, + **never commit directly to `main`**, commit at the end, `git push -u origin `. +- **Mid-chain auto-spawned** agents and **read-only** agents (reviewer/verifier/security) + **stay on the task's branch — don't re-branch**, and leave the final commit to the task owner. + (This clause prevents the engineer→reviewer→verifier chain from each re-branching.) + +## Not shipped code +`.claude/` is developer tooling, not part of the built app (the Docker build copies `server/` ++ `client/`), so **no version bump / CHANGELOG / build** — an artifact + INDEX line + the +verifier gate are the appropriate audit trail here. + +## Verified +- `grep -c "## Git workflow (every task)"` across the 22 targets → exactly 1 each (22 total). +- Spot-checked a read-only agent (`verifier.md`) and a writer skill (`engineer/SKILL.md`): + clean append, frontmatter intact, wording fits both roles. +- verifier: (see verifier-log entry for 2026-08-29). + +## Next: done. diff --git a/claude_artifacts/verifier-log.md b/claude_artifacts/verifier-log.md index ca4161a..11e3206 100644 --- a/claude_artifacts/verifier-log.md +++ b/claude_artifacts/verifier-log.md @@ -18,3 +18,4 @@ - 2026-08-29 11:20 · devops · SSH NAS host → mycloud.dp.ua:2323 · VERDICT: PASS · re-ran: grep 192.168.50.2 (only comment+artifact), grep NAS_HOST (all mycloud), bash -n push-to-nas.sh OK · probed: all ssh/scp/rsync hops use $NAS_HOST not hardcoded IP; port 2323 preserved; illustrative comment+historical artifact intentional · PASS - 2026-08-29 12:07 · engineer · Insights alert/watch sections as accordions · VERDICT: PASS · re-ran: tsc -p (clean), vite build (139 modules, exit 0), grep compiled CSS (.grid[hidden]{display:none} present, specificity/order beats .grid), token defs in globals.scss · probed: collapse hides grid via hidden+override; aria-controls id always-rendered (no dangling ref when collapsed); unique slugs alert-categories/watch-list (no dup id); per-card open state diff-unchanged (no regression); chevron rotate(90deg) bound to aria-expanded=true · PASS - 2026-08-29 12:23 · designer/engineer · Insights full-width accordion items (CSS) · VERDICT: PASS · re-ran: vite build OK, tsc clean, npm test 9/9 (client 6 + root 3), grepped dist CSS · probed: section hidden-collapse specificity (.grid[hidden] 0,2,0 beats .grid 0,1,0 → display:none wins), flex-column full-width via default align-items:stretch, .row internal grid columns intact + tokens compile (sass would error if undefined) · PASS +- 2026-08-29 12:31 · docwriter/tooling · git-workflow rule appended to 22 agent+skill files · VERDICT: PASS · re-ran: grep -c=1 all 22; md5 of each block → 22 identical; head-1=--- x22, tail-1 identical x22; git branch -a (no master, default main); porcelain=22 targets+INDEX+artifact only · probed: mid-chain re-branch clause (exempts reviewer/verifier/security — holds), master→main mapping (no master branch — correct), block-drift/frontmatter-corruption (none) · PASS