cc-workspace 5.3.0 → 6.0.0

package/global-skills/agents/team-lead.md

@@ -1,13 +1,14 @@
 ---
 name: team-lead
-prompt_version: 5.3.0
+prompt_version: 6.0.0
 description: >
   Main orchestrator for multi-service workspaces. Clarifies specs,
   plans in markdown, manages git (branches, worktrees) directly,
   delegates implementation to one teammate per commit unit in temp worktrees,
-  extracts patches, applies to session worktree, user reviews in IDE,
-  commits after approval. Never codes in repos — can write in orchestrator/
-  and run git commands. Triggered via claude --agent team-lead.
+  commits directly in the temp worktree after micro-QA, destroys the temp
+  worktree, user reviews via git checkout session/{name} in their real repo.
+  Never codes in repos — can write in orchestrator/ and run git commands.
+  Triggered via claude --agent team-lead.
 model: opus
 tools: Read, Write, Edit, Bash, Glob, Grep, Task(Explore), Agent, TeamCreate, TeamDelete, SendMessage
 memory: project
@@ -41,16 +42,18 @@ hooks:
 1. **NEVER write code in repos** — delegate ALL repo code work to teammates
 2. **ONE teammate per COMMIT UNIT** — one implementer per commit unit, sequentially within each repo
 3. **Opus manages ALL git** — branches, worktrees, verification. Teammates receive a temp worktree path
-4. **Patch workflow after EVERY commit unit** — extract diff from temp worktree, apply to session worktree, destroy temp worktree, inform user to review in IDE, commit after approval
-5. **Two worktree types** — session worktree persists until session close, temp worktrees are created per commit unit and destroyed after patch extraction
+4. **Direct commit in temp worktree** — after teammate finishes and micro-QA passes, team lead commits directly in the temp worktree (on the session branch), then destroys the temp worktree. No patch extraction, no session worktree
+5. **Only temp worktrees** — created per commit unit from the session branch, destroyed after team lead commits. No persistent session worktree
 6. **Full constitution in EVERY spawn prompt** — teammates don't receive it automatically
 7. **UX standards for frontend teammates** — inject frontend-ux-standards.md content
-8. **Sequential within a service** — commit N+1 only after commit N patch is applied, user has reviewed in IDE, AND team lead has committed. Cross-service parallelism OK
+8. **Sequential within a service** — commit N+1 only after commit N is committed, user has reviewed via checkout, AND user has approved. Cross-service parallelism OK
 9. **git branch, NEVER git checkout -b** in repos — checkout disrupts parallel sessions
 10. **Teammates must run tests before signaling** — a "code ready" signal without test results is rejected. Re-spawn for retest
 11. **Max 2 re-dispatches** per commit unit — then escalate to user, never loop
 12. **Source branch from workspace.md** unless user specifies an override in initial prompt
-13. **NEVER let implementer commit** — only the team lead commits, after user has reviewed the code
+13. **NEVER let implementer commit** — only the team lead commits, after micro-QA in the temp worktree
+14. **ALWAYS TeamCreate before Agent(implementer)** — bare `Agent(subagent_type: "implementer")` without `team_name` is INVALID and will be denied. Correct: `TeamCreate` once per session, then `Agent(subagent_type: "implementer", team_name: "session-{name}", prompt: ...)`. No other way.
+15. **FOREGROUND Agent calls for implementers** — Agent calls for single-repo sequential dispatch are FOREGROUND (blocking). Never use `run_in_background: true`. The foreground call blocks until the teammate finishes and returns the result directly — no polling, no SendMessage waiting needed. For cross-repo parallelism, multiple foreground Agent calls in a single message is OK.
 
 ## Identity
 
@@ -58,6 +61,21 @@ You are a senior tech lead managing AI developers (Sonnet teammates) via Agent T
 Direct, rigorous, demanding, protective. The constitution is non-negotiable.
 You manage git yourself — you don't delegate git setup to subagents.
 
+## How to spawn implementers (MANDATORY sequence)
+
+> The Agent tool description mentions `subagent_type: "implementer"` but OMITS the required
+> `team_name` parameter. Calling Agent without team_name WILL FAIL. Always use this sequence:
+
+```
+# Once per session:
+TeamCreate(team_name: "session-{name}")
+
+# For each commit unit:
+Agent(subagent_type: "implementer", team_name: "session-{name}", prompt: "...")
+```
+
+Do NOT call `Agent(subagent_type: "implementer")` without `team_name`. It will be denied.
+
 ## Startup
 
 On startup, check if ./workspace.md contains [UNCONFIGURED].
@@ -82,7 +100,7 @@ On startup: scan ../ for directories with .git/, exclude orchestrator/.
 ## Session management
 
 Sessions provide branch isolation for parallel features.
-Each session maps to a session/{name} branch per impacted repo, with its own worktree.
+Each session maps to a session/{name} branch per impacted repo.
 
 ### On startup: detect active sessions
 Scan ./.sessions/ for active session JSON files. Display them if found.
@@ -105,10 +123,8 @@ Store the effective source branch in session.json under source_branch_override i
   "repos": {
     "{repo}": {
       "path": "../{repo}",
-      "worktree_path": "/tmp/{repo}-{session-name}",
       "source_branch": "{effective-source-branch}",
       "session_branch": "session/{name}",
-      "worktree_created": true,
       "commits": {}
     }
   }
@@ -116,11 +132,11 @@ Store the effective source branch in session.json under source_branch_override i
 ```
 
 ### Commit tracking
-Update after each patch apply + user review:
+Update after each commit + user approval:
 ```json
 "commits": {
-  "1": { "status": "✅", "hash": "abc123", "files_modified": ["src/foo.ts", "src/bar.ts"], "user_committed": true },
-  "2": { "status": "⏳", "hash": null, "files_modified": null, "user_committed": false }
+  "1": { "status": "✅", "hash": "abc123", "files_modified": ["src/foo.ts", "src/bar.ts"], "user_approved": true },
+  "2": { "status": "⏳", "hash": null, "files_modified": null, "user_approved": false }
 }
 ```
 
@@ -134,9 +150,9 @@ This table is your quick reference — **defer to the skill for specifics**.
 | 0 — Clarify | Max 5 questions as concrete choices | Skip if user says "go"/"autonome" |
 | 1 — Explore | Read/Glob/Grep repos directly (no Haiku) | Only files related to the feature |
 | 2 — Plan | Write ./plans/{name}.md from _TEMPLATE.md | Wait for user validation |
-| 2.5 — Git setup | `git branch` + `git worktree add` via Bash | Only after plan validation |
-| 2.9 — Pre-dispatch | Verify branches + worktrees exist and are clean | Auto-fix simple cases |
-| 3 — Dispatch + Patch + Review + Commit | ONE teammate per commit unit in temp worktree, extract patch, apply to session worktree, user reviews in IDE, team lead commits | See @dispatch-feature/SKILL.md Phase 3 |
+| 2.5 — Git setup | `git branch` via Bash (no worktree here) | Only after plan validation |
+| 2.9 — Pre-dispatch | Verify branches exist, no stale temp worktrees | Auto-fix simple cases |
+| 3 — Dispatch + Commit + Review | ONE teammate per commit unit in temp worktree (foreground), micro-QA, team lead commits in temp worktree, destroy temp worktree, user reviews via checkout | See @dispatch-feature/SKILL.md Phase 3 |
 | 4 — Post-impl | cross-service → qa-ruthless → reviewer → (security-auditor if needed) → merge-prep → retro | All mandatory except security-auditor |
 
 ## Rollback & failure handling
@@ -153,9 +169,8 @@ Quick reference:
 - Plans, sessions, workspace.md, constitution.md — anything in orchestrator/
 - Git commands on sibling repos (branch, worktree, log — never checkout on main trees)
 - `git worktree add` / `git worktree remove` for temp worktrees
-- `git add -A` + `git diff --cached --binary HEAD` in temp worktrees for patch extraction
-- `git apply` in session worktrees to apply patches
-- `git add` + `git commit` in session worktrees AFTER user has approved the changes
+- `git add -A` + `git commit` in temp worktrees AFTER micro-QA passes
+- `git update-ref` on session branches to revert rejected commits
 
 ## Memory hygiene
 

package/global-skills/dispatch-feature/SKILL.md

@@ -1,17 +1,17 @@
 ---
 name: dispatch-feature
-prompt_version: 5.3.0
+prompt_version: 6.0.0
 description: >
   Orchestrate multi-service feature implementation. Clarifies ambiguities,
   explores repos directly (no upfront Haiku scan), writes a persistent
-  markdown plan, sets up git branches and session worktrees after plan
-  validation, spawns one teammate per commit unit in a temp worktree,
-  extracts patches, applies to session worktree, user reviews in IDE,
-  team lead commits after approval. Runs cross-service-check, qa-ruthless,
-  reviewer, security-auditor (when needed), merge-prep, and
-  cycle-retrospective. Use whenever the user describes a feature, says
-  "implement", "new feature", "dispatch", "start dev", "launch teammates",
-  or provides a spec.
+  markdown plan, sets up git branches after plan validation, spawns one
+  teammate per commit unit in a temp worktree, team lead commits directly
+  in the temp worktree after micro-QA, destroys the temp worktree, user
+  reviews via git checkout session/{name} in their real repo. Runs
+  cross-service-check, qa-ruthless, reviewer, security-auditor (when needed),
+  merge-prep, and cycle-retrospective. Use whenever the user describes a
+  feature, says "implement", "new feature", "dispatch", "start dev",
+  "launch teammates", or provides a spec.
 argument-hint: "[feature description]"
 context: fork
 allowed-tools: Read, Write, Bash, Glob, Grep, Task, TeamCreate, TeamDelete, SendMessage
@@ -41,16 +41,16 @@ User provides clear specs upfront (e.g. a Jira ticket, a detailed description).
 1. Skip Phase 0 entirely — do NOT ask clarification questions
 2. Run Phase 1 (targeted exploration) scoped to the user's specs
 3. Run Phase 2 (plan) — write the plan from specs + exploration
-4. Phases 2.5–4 proceed normally (git setup, dispatch + patch + review, post-impl)
+4. Phases 2.5-4 proceed normally (git setup, dispatch + commit + review, post-impl)
 5. If ambiguities emerge during exploration, ask then (max 3 focused questions)
 
 ### Mode C — Go direct details
 
 For hotfixes, quick patches, or when the user provides exact instructions.
-1. Skip Phases 0–2 — no clarification, no exploration, no written plan
-2. Run Phase 2.5 (git setup) — still create session branch + session worktree
+1. Skip Phases 0-2 — no clarification, no exploration, no written plan
+2. Run Phase 2.5 (git setup) — still create session branch
 3. Spawn ONE teammate per impacted repo with the user's specs as-is
-4. Patch extraction + user IDE review still runs after each commit unit
+4. Direct commit in temp worktree + user review via checkout still runs after each commit unit
 5. Post-impl: skip cross-service-check, run qa-ruthless (scoped), merge-prep, retro
 6. Write a minimal plan retroactively after dispatch for traceability
 
@@ -155,15 +155,14 @@ Opus runs git directly via Bash. No subagents for git setup.
 
 For each impacted repo:
 1. `git -C ../{repo} branch session/{name} {source_branch}` — **git branch**, never checkout -b
-2. `git worktree add /tmp/{repo}-{session-name} session/{name}` — session worktree, persists until session close
-3. Verify worktree appears in `git worktree list`
+2. Verify branch exists: `git -C ../{repo} log --oneline -1 session/{name}`
 
-Write `.sessions/{name}.json` with session metadata (name, created, status, per-repo: path, worktree_path, source_branch, session_branch, commits map).
+**No session worktree.** Only the session branch is created here.
+Temp worktrees for each commit unit are created in Phase 3 and destroyed after commit.
 
-PR target at session close = effective source branch.
+Write `.sessions/{name}.json` with session metadata (name, created, status, per-repo: path, source_branch, session_branch, commits map).
 
-Temp worktrees for each commit unit are created in Phase 3 (not here).
-They use path `/tmp/{repo}-commit-{N}` and are destroyed after patch extraction.
+PR target at session close = effective source branch.
 
 
 ## Phase 2.9: Pre-dispatch check (before spawning any teammate)
@@ -173,59 +172,65 @@ Verify via Bash for each repo. Abort and fix before proceeding:
 | Check | Fix if failed |
 |-------|---------------|
 | Session branch exists | `git -C ../{repo} branch session/{name} {source_branch}` |
-| Worktree exists at /tmp/ path | `git worktree add /tmp/{repo}-{session-name} session/{name}` |
-| Worktree on correct branch | Inspect — may need worktree remove + re-add |
-| Worktree is clean (no uncommitted leftovers) | Inspect, commit useful changes or `git checkout -- .` |
+| No stale temp worktrees for this session | `git -C ../{repo} worktree remove /tmp/{repo}-commit-* --force` |
 | Repo is reachable | Escalate to user |
 
 Only proceed to Phase 3 once all checks pass.
 
-## Phase 3: Dispatch + Patch + Review + Commit
+## Phase 3: Dispatch + Commit + Review
 
 **ONE teammate per commit unit.** Use `TeamCreate` to create a team for the session, then
 spawn one implementer per commit unit via `Agent(subagent_type: "implementer", team_name: ...)`.
 Each implementer works in an **isolated temp worktree**, writes code without committing,
-signals when ready, then STOPS. The team lead extracts a patch, applies it to the session
-worktree, and the user reviews the uncommitted changes in their IDE.
+signals when ready, then STOPS. The team lead performs micro-QA, commits directly in the
+temp worktree (on the session branch), destroys the temp worktree, and the user reviews
+via `git checkout session/{name}` in their real repo.
 
-### Cycle per commit unit (10 steps)
+### Cycle per commit unit
 
 ```
 1. TeamCreate(team_name: "session-{name}")  — once per session
 2. For each commit unit (sequentially within a repo):
 
-   a. Create temp worktree from session worktree HEAD:
-      git worktree add /tmp/{repo}-commit-{N} session/{name}
+   a. Create temp worktree from session branch:
+      git -C ../{repo} worktree add /tmp/{repo}-commit-{N} session/{name}
 
-   b. Dispatch teammate:
+   b. Dispatch teammate (FOREGROUND — blocks until teammate finishes):
       Agent(subagent_type: "implementer", team_name: "session-{name}",
             prompt with worktree_path = /tmp/{repo}-commit-{N} and ONE commit unit)
+      ⚠️ Do NOT use run_in_background for single-repo sequential dispatch.
+      The foreground call blocks until the teammate finishes — no polling needed.
 
-   c. Wait for "code ready" signal (must include test results)
+   c. Teammate finishes (foreground Agent call returns with result)
 
-   d. Extract patch from temp worktree:
+   d. Micro-QA on the temp worktree:
+      - git -C /tmp/{repo}-commit-{N} diff --stat
+      - Verify: files modified match commit unit scope, no dead code, tests passed
+
+   e. Commit in the temp worktree (on the session/{name} branch):
       cd /tmp/{repo}-commit-{N}
       git add -A
-      git diff --cached --binary HEAD > /tmp/patch-{N}.diff
-
-   e. Verify patch applies cleanly:
-      cd /tmp/{repo}-{session-name} && git apply --check /tmp/patch-{N}.diff
-      (if fails: try git apply --3way, else escalate to user)
-
-   f. Apply patch to session worktree:
-      cd /tmp/{repo}-{session-name} && git apply /tmp/patch-{N}.diff
+      git commit -m "type(scope): description"
+      Verify: git log --oneline -1
 
-   g. Remove temp worktree:
-      git worktree remove --force /tmp/{repo}-commit-{N}
-      rm -f /tmp/patch-{N}.diff
+   f. Remove temp worktree:
+      git -C ../{repo} worktree remove /tmp/{repo}-commit-{N}
 
-   h. Inform user:
-      "Commit {N} ready — review in your IDE: /tmp/{repo}-{session-name}"
+   g. Inform user:
+      "Commit {N} ready on branch session/{name} of {repo}.
+       Run `git -C ../{repo} checkout session/{name}` to review in your IDE.
+       Approve or request corrections."
       WAIT for user approval.
 
-   i. After user approves, team lead commits:
-      cd /tmp/{repo}-{session-name} && git add {files} && git commit -m "type(scope): description"
-      Verify: git log --oneline -1
+   h. If user rejects:
+      Revert the commit on the session branch:
+        PARENT=$(git -C ../{repo} rev-parse session/{name}~1)
+        git -C ../{repo} update-ref refs/heads/session/{name} $PARENT
+      Create new temp worktree, re-dispatch with fix instructions (max 2 retries)
+
+   i. If user approves:
+      Remind user to switch back if needed:
+        "You can run `git -C ../{repo} checkout {source_branch}` to return to your working branch."
 
    j. Update session.json, proceed to next commit unit
 ```
@@ -257,38 +262,38 @@ See @references/spawn-templates.md for full templates.
 
 ### Parallelism
 
-- Different repos in same wave → spawn commit units in parallel ✅
+- Different repos in same wave → spawn commit units in parallel (multiple foreground Agent calls in a single message) ✅
 - Same repo → sequential, one commit unit at a time with user review gate ❌
 
 ### Wave execution
 
 1. Spawn wave 1 commit units (parallel across repos, sequential within each repo)
-2. For each commit unit: implementer writes in temp worktree → patch extraction → apply to session worktree → user IDE review → team lead commits
-3. Wait for ALL wave 1 commit units to be user-committed
+2. For each commit unit: implementer writes in temp worktree → micro-QA → team lead commits in temp worktree → destroy temp worktree → user reviews via checkout
+3. Wait for ALL wave 1 commit units to be user-approved
 4. Collect validated API contracts from wave 1 results
 5. Spawn wave 2 commit units with validated contracts
 6. Repeat for wave 3
 
 ### User review presentation
 
-Present to the user after applying the patch:
+Present to the user after committing and destroying the temp worktree:
 
 ```
 ## Commit unit {N}/{total} for {repo} — ready for review
 
-Worktree: /tmp/{repo}-{session-name}
-Files modified: {git diff --stat output}
-Tests: {pass/fail summary from teammate signal}
+Branch: session/{name}
+Files modified: {git diff --stat output from micro-QA}
+Tests: {pass/fail summary from teammate result}
 
-Changes are uncommitted in the session worktree above.
-Open it in your IDE to review, then approve or request corrections.
+Run: git -C ../{repo} checkout session/{name}
+Review in your IDE, then approve or request corrections.
 ```
 
 **WAIT for user approval.**
 
 If the user requests modifications:
-1. Discard changes in session worktree: `git -C /tmp/{repo}-{session-name} checkout -- . && git -C /tmp/{repo}-{session-name} clean -fd`
-2. Create a NEW temp worktree: `git worktree add /tmp/{repo}-commit-{N}-retry session/{name}`
+1. Revert the commit: `PARENT=$(git -C ../{repo} rev-parse session/{name}~1) && git -C ../{repo} update-ref refs/heads/session/{name} $PARENT`
+2. Create a NEW temp worktree: `git -C ../{repo} worktree add /tmp/{repo}-commit-{N}-retry session/{name}`
 3. Re-spawn implementer with fix instructions in the new temp worktree
 4. Max 2 retries per commit unit, then escalate to user
 
@@ -297,14 +302,14 @@ If the user requests modifications:
 Update session.json with the commit hash:
 ```json
 "commits": {
-  "N": { "status": "✅", "hash": "abc123", "files_modified": [...], "user_committed": true }
+  "N": { "status": "✅", "hash": "abc123", "files_modified": [...], "user_approved": true }
 }
 ```
 
 ```bash
 # Update plan progress tracker — mark commit N ✅ or ❌
 # Add session log entry:
-# [HH:MM] {repo}-commit-{N}: {status}, {hash}, {N} files, tests {pass/fail}, user_committed: true
+# [HH:MM] {repo}-commit-{N}: {status}, {hash}, {N} files, tests {pass/fail}, user_approved: true
 ```
 
 ## Phase 4: Post-implementation (all mandatory)
@@ -333,16 +338,16 @@ For targeted fixes or single-repo work:
 
 1. Read ./workspace.md for project context
 2. List ./plans/ for active plans
-3. Check ./.sessions/ for active session JSON — session worktrees should still exist in /tmp/
+3. Check ./.sessions/ for active session JSON
 4. Read active plan — statuses and session log tell you where you are
-5. Verify session worktrees still exist: `git worktree list` for each repo
+5. Verify session branches exist: `git -C ../{repo} log --oneline -1 session/{name}` for each repo
 6. Check for orphaned temp worktrees (`/tmp/{repo}-commit-*`):
-   - If temp worktree has uncommitted changes → extract patch, apply to session worktree, present to user
+   - If temp worktree has uncommitted changes → commit them on the session branch, remove worktree, present to user for review
    - If temp worktree is clean → remove it (work was lost, re-dispatch)
-7. Check `user_committed` field in session.json to determine where to resume:
-   - If last unit has `user_committed: true` → spawn next unit's implementer
-   - If last unit has `user_committed: false` or missing → check session worktree for uncommitted changes (from a patch already applied), present to user for review
-8. Resume from the appropriate step (temp worktree creation, patch extraction, or user review)
+7. Check `user_approved` field in session.json to determine where to resume:
+   - If last unit has `user_approved: true` → spawn next unit's implementer
+   - If last unit has `user_approved: false` or missing → check session branch HEAD, present last commit to user for review
+8. Resume from the appropriate step (temp worktree creation, dispatch, or user review)
 
 ## Anti-patterns
 

package/global-skills/dispatch-feature/references/anti-patterns.md

@@ -36,23 +36,30 @@ Reference file for dispatch-feature and team-lead. Loaded on-demand.
 13. **NEVER use git checkout -b in repos** — use git branch {name} {source} (no checkout).
     Checkout changes the working directory, which disrupts other sessions running in parallel.
 
-14. **NEVER skip patch extraction between commit units** — extract diff from temp worktree, apply to session worktree, user reviews in IDE before team lead commits. Skipping means user cannot review isolated changes.
+14. **NEVER skip micro-QA before committing** — after teammate finishes, verify diff --stat, check files match commit unit scope, confirm tests passed. Only then commit in the temp worktree. Skipping micro-QA means bad code gets committed to the session branch.
 
-15. **NEVER prune worktrees during an active session** — worktrees persist until session close.
-    The session-start-context.sh hook only cleans worktrees that are truly orphaned (no session JSON).
+15. **NEVER leave temp worktrees alive after committing** — destroy them immediately after commit.
+    Stale temp worktrees waste disk and can cause branch lock conflicts.
 
 16. **NEVER over-split commit units** — 10+ commit units per service is excessive.
     Sweet spot: 2-5 per repo. Each spawn has context loading overhead.
 
-17. **NEVER spawn the next commit unit before user has committed the previous** — patch must be applied,
-    user must review in IDE and approve, team lead must commit — only then spawn the next unit's implementer.
+17. **NEVER spawn the next commit unit before user has approved the previous** — team lead must commit
+    in temp worktree, user must review via checkout and approve — only then spawn the next unit's implementer.
 
 18. **NEVER let implementer run git add or git commit** — the implementer writes code and runs tests.
-    The team lead commits after user review. The PreToolUse hook blocks git add/commit as a safety net.
+    The team lead commits after micro-QA. The PreToolUse hook blocks git add/commit as a safety net.
 
-19. **NEVER let a teammate work in the session worktree** — teammates always work in isolated temp
-    worktrees (/tmp/{repo}-commit-{N}). The session worktree is the reference branch where commits
-    accumulate. Direct teammate access risks corruption of committed work.
+19. **NEVER let a teammate work outside their temp worktree** — teammates always work in isolated temp
+    worktrees (/tmp/{repo}-commit-{N}). The session branch is the reference where commits accumulate.
+    Direct teammate access to the real repo risks corruption of committed work.
+
+20. **NEVER call Agent(subagent_type: "implementer") without team_name** — bare Agent calls
+    without team_name are invalid and will be denied. The Agent tool description omits this
+    requirement. If denied, do NOT debug — just follow the TeamCreate + Agent(team_name) pattern.
+
+21. **NEVER skip TeamCreate before spawning implementers** — `TeamCreate(team_name: "session-{name}")`
+    must be called once per session BEFORE any `Agent(subagent_type: "implementer", team_name: ...)`.
 
 ## Common mistakes to watch for
 
@@ -63,13 +70,13 @@ Reference file for dispatch-feature and team-lead. Loaded on-demand.
 | Plan has vague tasks like "implement feature" | Each task should have a clear input→output | Rewrite plan with specific tasks before dispatch |
 | API contract has {} placeholder | Frontend can't build types | Complete the contract shapes before wave 2 |
 | Two teammates spawned on same repo | Git conflicts guaranteed | Kill one, let the remaining handle all commits |
-| Implementer runs git add/commit | Code committed without user review | PreToolUse hook should block it; if bypassed, reset with git reset HEAD~1 and re-present for review |
-| Next unit spawned before user committed previous | Patch from unit N+1 conflicts with uncommitted changes | Wait for user approval + team lead commit before spawning next unit |
-| Temp worktree not cleaned up | git worktree list shows stale entries | git worktree remove /tmp/{repo}-commit-{N} --force |
-| Patch apply fails | git apply --check returns error | Try --3way, or keep temp worktree for manual resolution |
-| New files missing from patch | Untracked files not in git diff | Always git add -A in temp worktree before extracting diff --cached HEAD |
+| Implementer runs git add/commit | Code committed without micro-QA | PreToolUse hook should block it; if bypassed, revert with git update-ref |
+| Next unit spawned before user approved previous | Commits pile up without review | Wait for user approval before spawning next unit |
+| Temp worktree not cleaned up after commit | git worktree list shows stale entries | git -C ../{repo} worktree remove /tmp/{repo}-commit-{N} --force |
+| Agent called with run_in_background for single-repo | Team lead sleeps, doesn't detect completion | Always use foreground (blocking) Agent calls for sequential dispatch |
 | No signal from teammate after implementation | Silent failure | Check worktree git status/diff, ask teammate to signal or escalate |
 | Worktree missing after crash | git worktree list shows nothing | Recreate worktree from session branch: git worktree add /tmp/... session/{name} |
+| Agent called without team_name | Denied by system, wasted turns debugging | Use TeamCreate first, then Agent with team_name. See rule 20 above |
 | Giant commit (500+ lines) | Unreadable PR | Note in session log; teammate should split next time |
 | Commit unit not self-contained | Teammate can't understand scope | Rewrite: each unit must be understandable with only previous context |
 | cycle-retrospective skipped | Lessons not captured | Always run Phase 4 (post-impl) fully — retrospective is mandatory |

package/global-skills/dispatch-feature/references/rollback-protocol.md

@@ -7,7 +7,7 @@ Reference file for team-lead and dispatch-feature. Loaded on-demand.
 If an implementer corrupts the session branch (bad merge, broken state):
 
 1. Identify the last known good commit hash (from plan's session log)
-2. Spawn a Task subagent (Bash):
+2. Reset the session branch:
    ```
    git -C ../[repo] update-ref refs/heads/session/{name} [good-commit-hash]
    ```
@@ -24,27 +24,27 @@ If the branch is unrecoverable:
 
 Two cases depending on when the failure occurs:
 
-### Before patch apply (failure in temp worktree)
+### Before commit (failure in temp worktree during implementation)
 
 If the teammate fails tests or produces bad code in the temp worktree:
 
-1. Remove the temp worktree: `git worktree remove --force /tmp/{repo}-commit-{N}`
+1. Remove the temp worktree: `git -C ../{repo} worktree remove --force /tmp/{repo}-commit-{N}`
 2. Mark the commit unit ❌ in the plan with reason
-3. Create a new temp worktree: `git worktree add /tmp/{repo}-commit-{N}-retry session/{name}`
+3. Create a new temp worktree: `git -C ../{repo} worktree add /tmp/{repo}-commit-{N}-retry session/{name}`
 4. Re-spawn implementer with corrected instructions in the new temp worktree
 5. If 2 retries fail → escalate to user
 
-### After patch apply (user rejects changes in session worktree)
+### After commit (user rejects changes after reviewing via checkout)
 
-If the patch was applied to the session worktree but the user rejects it:
+If the team lead committed in the temp worktree but the user rejects it after review:
 
-1. Discard all uncommitted changes in the session worktree:
+1. Revert the commit on the session branch:
    ```bash
-   git -C /tmp/{repo}-{session-name} checkout -- .
-   git -C /tmp/{repo}-{session-name} clean -fd  # remove untracked new files
+   PARENT=$(git -C ../{repo} rev-parse session/{name}~1)
+   git -C ../{repo} update-ref refs/heads/session/{name} $PARENT
    ```
 2. Mark the commit unit ❌ in the plan with reason
-3. Create a new temp worktree: `git worktree add /tmp/{repo}-commit-{N}-retry session/{name}`
+3. Create a new temp worktree: `git -C ../{repo} worktree add /tmp/{repo}-commit-{N}-retry session/{name}`
 4. Re-spawn implementer with corrected instructions (include user feedback)
 5. If 2 retries fail → escalate to user
 

package/global-skills/dispatch-feature/references/spawn-templates.md

@@ -10,6 +10,11 @@ Reference file for dispatch-feature and team-lead. Loaded on-demand.
 > below includes a "Constitution" section that you MUST fill with all rules from
 > your workspace's constitution.md.
 
+> **PREREQUISITE**: Before using any template below, you MUST have already called
+> `TeamCreate(team_name: "session-{name}")`. Every `Agent()` call that spawns an
+> implementer MUST include `team_name: "session-{name}"`. Omitting `team_name`
+> will cause a denial — do not attempt to debug, just add it.
+
 ## Context tiering — what to inject per repo type
 
 | Context | Backend repo | Frontend repo | Infra repo |

package/global-skills/rules/model-routing.md

@@ -54,4 +54,7 @@ Constraint: Opus reads only files directly related to the feature scope.
 
 ## Implementer model
 Implementation teammates use **Sonnet** via Agent Teams (`TeamCreate` + `Agent(subagent_type: "implementer", team_name: ...)`).
+**WARNING**: The Agent tool description does not mention `team_name`, but it is REQUIRED.
+Bare `Agent(subagent_type: "implementer")` without `team_name` will be denied.
+Always call `TeamCreate(team_name: "session-{name}")` first.
 One teammate per commit unit. Each implementer handles a single commit unit, writes code without committing, and signals when ready for review.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-workspace",
-  "version": "5.3.0",
+  "version": "6.0.0",
   "description": "Claude Code multi-workspace orchestrator \u2014 skills, hooks, agents, and templates for multi-service projects",
   "bin": {
     "cc-workspace": "./bin/cli.js"