codebyplan 1.13.13 → 1.13.14

package/templates/skills/cbp-standalone-task-check/SKILL.md

@@ -0,0 +1,152 @@
+---
+scope: repo-only:codebyplan
+name: cbp-standalone-task-check
+description: AI production review for the current standalone task
+argument-hint: [task]  # e.g. `45` (standalone TASK-45)
+triggers: [cbp-standalone-task-testing]
+effort: high
+---
+
+# Standalone Task Check Command
+
+AI-driven production readiness review for standalone tasks. Spawns the `cbp-task-check` agent for thorough verification including user satisfaction discussion. This command is a thin orchestrator — the agent does the heavy lifting.
+
+## Inline-Fallback for Spawn Failure
+
+If the `cbp-task-check` agent spawn fails for any reason, follow the canonical inline-fallback procedure documented in `skills/cbp-round-end/SKILL.md` "Inline-fallback for any spawn failure". Walk every agent phase inline with the same Read/Grep depth the agent would have used — do not skip phases.
+
+## When Used
+
+- After all rounds complete and all files approved (auto-triggered by `/cbp-round-update`)
+- Before `/cbp-standalone-task-testing`
+- Never skippable
+
+## Instructions
+
+### Step 1: Parse `$ARGUMENTS`
+
+| Shape | Regex | Resolves to |
+|-------|-------|-------------|
+| `{task}` (e.g. `45`) | `^[0-9]+$` | Standalone TASK-{task} |
+| _(empty)_ | — | Use MCP `get_current_standalone_task` to find the active in-progress task |
+
+Any multi-segment input is an error:
+
+```
+standalone-task-check: argument `{value}` looks like a checkpoint-task pair.
+Use /cbp-task-check {chk}-{task} for checkpoint-bound tasks.
+Standalone tasks use a bare number, e.g. /cbp-standalone-task-check 45.
+```
+
+Error cases: any multi-segment input, `abc`, `108-`, `-1`, anything with whitespace or non-numeric characters.
+
+#### Worked examples
+
+- `standalone-task-check 45` → standalone TASK-45
+- `standalone-task-check` (no arg) → active in-progress task via `get_current_standalone_task`
+- `standalone-task-check 141-3` → error: "Use /cbp-task-check {chk}-{task} for checkpoint-bound tasks."
+- `standalone-task-check abc` → error: malformed
+
+### Step 1.5: Get Current Task
+
+| Parse | Resolution path |
+|-------|-----------------|
+| `{task}` | MCP `get_standalone_tasks(repo_id)` → filter `number === {task}`. |
+| _(empty)_ | MCP `get_current_standalone_task(repo_id)` — finds the active in-progress task. |
+
+If no in-progress task, show error and stop.
+
+### Step 2: Quick Gate — Verify All Rounds Complete
+
+Use MCP `get_standalone_rounds(standalone_task_id)`. Verify all rounds are `completed`.
+
+If any rounds still in_progress:
+
+```
+## Cannot Run Standalone Task Check
+
+Standalone TASK-[N] has an active round (Round [N]). Complete it first:
+- Run `/cbp-round-update` to finish the round
+```
+
+Stop here.
+
+### Step 3: Load All Context
+
+1. Get task details: id, title, requirements, context, qa
+2. Get all rounds via `get_standalone_rounds(standalone_task_id)`: number, requirements, context, qa, files_changed
+
+No checkpoint context is needed — standalone tasks have no parent checkpoint.
+
+### Step 4: Spawn Task Check Agent
+
+Spawn `cbp-task-check` agent with full context:
+
+```yaml
+input:
+  task_number: [N]
+  round_number: [total rounds]
+  checkpoint: null
+  task: { id, title, requirements, context, files_changed, qa }
+  rounds: [{ number, requirements, context, qa, files_changed }]
+```
+
+Wait for agent to complete. Agent handles all phases including user satisfaction discussion.
+
+### Step 5: Save Agent Output
+
+Save agent output to task context via MCP `update_standalone_task`:
+
+- `task.context.check_verdict` = agent output (verdict, requirements_check, etc.)
+
+```
+update_standalone_task(task_id, context: { ...existing, check_verdict: agentOutput })
+```
+
+### Step 6: Route Based on Verdict
+
+**READY + satisfied:**
+
+**Next**: Run `/clear`, then `/cbp-standalone-task-testing {task}` to run comprehensive task-level testing.
+
+**NOT READY — fixable issues:**
+
+```
+Issues found that need addressing:
+- [issue 1]
+- [issue 2]
+```
+
+Suggest: `/cbp-round-input` with specific issues. Stop — wait for user.
+
+**NOT READY — needs new task:**
+
+```
+Scope issues identified that require a new task:
+- [scope issue]
+```
+
+Suggest: `/cbp-standalone-task-create`. Stop — wait for user.
+
+**NOT READY — approvals missing:**
+
+```
+Code review passed but [N] files need user approval.
+```
+
+Suggest: Approve files, then re-run `/cbp-standalone-task-check {task}`. Stop — wait for user.
+
+## Key Rules
+
+- **Never skippable** — mandatory before `/cbp-standalone-task-testing`
+- **This is AI review + user satisfaction** — not automated testing
+- **Read all changed files** — agent does the heavy lifting
+- **No file changes** — review only, never edit
+- **No checkpoint context** — standalone tasks are self-contained
+
+## Integration
+
+- **Reads**: MCP `get_current_standalone_task`, `get_standalone_tasks`, `get_standalone_rounds`, all changed files (via agent)
+- **Writes**: MCP `update_standalone_task` (context.check_verdict)
+- **Triggers**: emits directive `Next: /clear, then /cbp-standalone-task-testing {task}` on READY + satisfied
+- **Triggered by**: `/cbp-round-update` (auto, when all files approved)

package/templates/skills/cbp-standalone-task-complete/SKILL.md

@@ -0,0 +1,201 @@
+---
+scope: repo-only:codebyplan
+name: cbp-standalone-task-complete
+description: Complete a standalone task — merge feat branch and mark done
+argument-hint: [task]  # e.g. `45` (standalone TASK-45)
+effort: xhigh
+---
+
+# Standalone Task Complete Command
+
+Complete a standalone task. Auto-triggered by `/cbp-standalone-task-testing` when all tests pass. Can also be run manually.
+
+## Instructions
+
+### Step 1: Parse `$ARGUMENTS`
+
+| Shape | Regex | Resolves to |
+|-------|-------|-------------|
+| `{task}` (e.g. `45`) | `^[0-9]+$` | Standalone TASK-{task} |
+| _(empty)_ | — | Use MCP `get_current_standalone_task` to find the active in-progress task |
+
+Any multi-segment input is an error:
+
+```
+standalone-task-complete: argument `{value}` looks like a checkpoint-task pair.
+Use /cbp-task-complete {chk}-{task} for checkpoint-bound tasks.
+Standalone tasks use a bare number, e.g. /cbp-standalone-task-complete 45.
+```
+
+Error cases: any multi-segment input, `abc`, `108-`, `-1`, anything with whitespace or non-numeric characters.
+
+#### Worked examples
+
+- `standalone-task-complete 45` → standalone TASK-45
+- `standalone-task-complete` (no arg) → active in-progress task via `get_current_standalone_task`
+- `standalone-task-complete 141-3` → error: "Use /cbp-task-complete {chk}-{task} for checkpoint-bound tasks."
+- `standalone-task-complete abc` → error: malformed
+
+### Step 1.5: Get Current Task
+
+| Parse | Resolution path |
+|-------|-----------------|
+| `{task}` | MCP `get_standalone_tasks(repo_id)` → filter `number === {task}`. |
+| _(empty)_ | MCP `get_current_standalone_task(repo_id)` — finds the active in-progress task. |
+
+If no in-progress task, show error and stop.
+
+### Step 2: Verify Rounds Complete and Validated
+
+Use MCP `get_standalone_rounds(standalone_task_id)`. Verify all rounds are `completed`.
+
+If any round is `in_progress`:
+
+```
+## Cannot Complete Standalone Task
+
+Standalone TASK-[N] has an active round (Round [N]). Run `/cbp-round-update` to finish it.
+```
+
+Stop here.
+
+Verify at least one round has `testing_qa_output` in its context. If not:
+
+```
+## Cannot Complete Standalone Task
+
+No testing-qa-agent validation found. Run `/cbp-round-start` to execute a validated round.
+```
+
+Stop here.
+
+### Step 2.5: Verify `/cbp-standalone-task-check` Has Run
+
+`task.context.check_verdict` must exist and have `verdict: 'READY'`. If not, surface "Run `/cbp-standalone-task-check` first" and stop.
+
+### Step 2.6: Verify `/cbp-standalone-task-testing` Has Run
+
+`task.context.task_testing_output` must exist with `all_passed: true`. If not, surface "Run `/cbp-standalone-task-testing` first" and stop.
+
+### Step 3: Verify QA and File Approval
+
+Load `task.qa` and `task.files_changed`:
+
+1. **QA**: count items by status (pass / fail / pending / skipped). If any item has status `fail` or `pending`, warn the user.
+2. **Files**: list any file with `user_approved === false` and warn.
+
+**If issues exist**, AskUserQuestion: `Complete anyway` / `Run QA first` / `Cancel`. On `Run QA first` or `Cancel`, stop. On `Complete anyway`, continue.
+
+**If no issues**, AskUserQuestion to confirm: `Ready to complete standalone TASK-[N]: [title] — [N] rounds, [N] files. Proceed?`
+
+### Step 4: Aggregate Files Changed
+
+Collect all files_changed from all standalone rounds. Deduplicate (latest action wins).
+
+### Step 5: Git Commit (no push)
+
+Commit task work FIRST, before the merge in Step 7. `/cbp-merge-main` must never run before the task commit.
+
+**Zero-file guard**: if `aggregated_files` is empty, skip the commit. Record "No git commit: zero files changed" in the Step 9 summary, then continue.
+
+**Already-committed guard**: if the aggregated files are already committed (working tree clean for them), skip the commit and continue; the prior run's task commit still stands.
+
+Otherwise: invoke `/cbp-git-commit` to stage approved files and create the commit. Claude does NOT git add directly. Do NOT push here.
+
+### Step 5.5: Merge Production Branch (mandatory)
+
+Ensure the feat branch is current with the latest production work.
+
+1. Trigger `/cbp-merge-main`.
+2. If the skill exits with failure (offline, unresolved conflicts, user-aborted): surface the failure and STOP. The task commit from Step 5 persists; the user resolves and re-invokes.
+3. If QA warnings the user chose to commit-as-is: continue to Step 5.7 with a soft warning.
+4. On clean success: continue to Step 5.7.
+
+### Step 5.7: Push
+
+Push once, carrying both the task commit and the merge commit:
+
+```bash
+git push origin $(git branch --show-current)
+```
+
+Skip only when nothing was committed AND `/cbp-merge-main` reported already-up-to-date. If push fails, investigate and fix.
+
+### Step 6: Update Task Files
+
+`update_standalone_task(task_id, context: { ...existing, files_changed: aggregated_files })`.
+
+### Step 7: Standalone Task Branch Merge
+
+Only when current branch matches `feat/standalone-TASK-*`:
+
+1. Read `.codebyplan/git.json` `branch_config.production` (default: `main`). Store as `PRODUCTION`.
+2. `git checkout {PRODUCTION}`
+3. `git merge {feat-branch} --no-ff -m "Merge {feat-branch}: {task title}"`
+4. `git push origin {PRODUCTION}`
+5. Delete feat branch local: `git branch -d {feat-branch}`
+6. Delete feat branch remote: `git push origin --delete {feat-branch}`
+
+If merge has conflicts, stop immediately and ask the user to resolve. Do not delete the feat branch until the merge succeeds and is pushed.
+
+If current branch is not `feat/standalone-TASK-*`, skip this step.
+
+### Step 7.5: Complete Standalone Task
+
+Note: `complete_standalone_task` is called only after the branch merge succeeds — the DB completion record reflects work that has landed in production.
+
+Resolve caller worktree: `CALLER_WT=$(npx codebyplan resolve-worktree 2>/dev/null)`.
+
+Call `complete_standalone_task(standalone_task_id, caller_worktree_id: CALLER_WT)`. `caller_worktree_id` is REQUIRED — the MCP server's pre-guard rejects mutations from non-matching worktrees. The server auto-clears `assigned_worktree_id` on the task on success.
+
+If `CALLER_WT` is empty, surface this warning and ask user to confirm before proceeding:
+
+```
+Warning: could not resolve caller_worktree_id (npx codebyplan resolve-worktree returned empty).
+The complete_standalone_task call may be rejected by the pre-guard. Proceed anyway? (yes / no)
+```
+
+### Step 8: Run Cleanup + Migration (inline)
+
+Apply the `cleanup` skill inline to remove orphan references to deleted/modified files. Apply `migration` to propagate renames/moves to consumers. Both run without sub-agent spawns. Skip cleanup if no deletions/modifications; skip migration if cleanup handled everything.
+
+### Step 9: Show Result and Route
+
+```
+## Standalone Task Completed
+
+**Standalone TASK-[N]**: [title]
+**Rounds**: [N] completed
+**Files**: [N] changed
+**Commit**: [hash]
+**Branch merged**: [feat-branch] → {PRODUCTION}
+```
+
+#### Route (single directive — never a menu)
+
+Standalone tasks have no checkpoint parent. Route to session end or new work:
+
+Next: /cbp-session-end
+
+If the user has mentioned more standalone work to create:
+
+Next: /cbp-standalone-task-create
+
+Do NOT use AskUserQuestion for routing. Do NOT use the Skill tool to auto-trigger. Emit one directive and stop.
+
+## Key Rules
+
+- **`caller_worktree_id` is REQUIRED** for `complete_standalone_task`
+- **Branch merge lives here** (not in checkpoint-end) — standalone tasks self-ship to production
+- **Single-directive routing** — no menus, no auto-triggers via Skill tool
+- **No checkpoint** — never check `checkpoint_id`, always treat task as standalone
+- **Never skippable prerequisites** — check_verdict READY + task_testing_output all_passed required
+
+## Integration
+
+- **Triggered by**: `/cbp-standalone-task-testing` emits directive (user runs it manually after seeing directive)
+- **Chain**: `/cbp-standalone-task-check` → `/cbp-standalone-task-testing` → `/cbp-standalone-task-complete`
+- **Reads**: MCP `get_current_standalone_task`, `get_standalone_tasks`, `get_standalone_rounds`
+- **Writes**: MCP `update_standalone_task`, `complete_standalone_task`
+- **Uses skills (inline, no sub-agent)**: `cleanup` (if deletions), `migration` (if exports renamed)
+- **Does NOT** auto-trigger next skill — emits single directive only

package/templates/skills/cbp-standalone-task-create/SKILL.md

@@ -0,0 +1,150 @@
+---
+scope: repo-only:codebyplan
+name: cbp-standalone-task-create
+description: Creates a standalone task (not checkpoint-bound) via create_standalone_task MCP tool
+effort: xhigh
+---
+
+# Standalone Task Create Command
+
+Create a new standalone task — independent of any checkpoint. Gathers user context, analyzes existing standalone work, and creates a well-positioned task. Runs inline (no subagent) to preserve Q&A conversation flow.
+
+## When Used
+
+- User wants to create a task that is not tied to any checkpoint
+- Improvement or fix work that stands alone
+- Maintenance, research, or investigative tasks with no checkpoint parent
+
+## Identifier Notation
+
+Standalone tasks use a bare number (e.g. `45` = standalone TASK-45). There is no checkpoint segment. Canonical notation follows `.claude/rules/notation-consistency.md`.
+
+## Instructions
+
+### Step 1: Gather User Context
+
+Use AskUserQuestion to understand the new standalone task:
+
+```
+## New Standalone Task
+
+What should this standalone task accomplish?
+
+Please describe:
+1. What the task should accomplish
+2. Any specific requirements or constraints
+3. Priority or deadline (if any)
+```
+
+### Step 2: Load Existing Standalone Tasks
+
+Use MCP `get_standalone_tasks(repo_id)` to read existing standalone tasks. Review:
+- Existing task titles and requirements
+- Task statuses (completed, in_progress, pending)
+
+### Step 3: Determine Next Task Number
+
+Sort existing standalone tasks by `number` descending. Next number = highest existing number + 1. If no standalone tasks exist, start at 1.
+
+### Step 3.5: Dedup Against Pending Standalone Tasks (MANDATORY)
+
+Before creating, compare the proposed task against every pending standalone task on these match dimensions:
+
+| Match dimension | Action if matched |
+|-----------------|-------------------|
+| Same target file(s) | STOP — `update_standalone_task` to append, do not create new |
+| Same feature / module | STOP — `update_standalone_task` to append, do not create new |
+| Same root cause | STOP — `update_standalone_task` to append, do not create new |
+| Same dependency / advisory | STOP — `update_standalone_task` to append, do not create new |
+
+If a match is found, surface it before appending:
+
+```
+Found existing pending standalone task TASK-[N]: [title]
+This finding overlaps on [dimension]. Append to TASK-[N] instead of creating new? (yes / no — create separately)
+```
+
+Default to append. Only create a separate task if the user explicitly says no, OR if the existing task is in_progress / completed.
+
+### Step 4: Analyze Codebase Context
+
+Brief inline analysis:
+1. Grep/Glob for files related to the user's described work
+2. Understand what existing standalone tasks have already built
+3. Note any obvious dependencies
+
+### Step 5: Clarify Ambiguities (if needed)
+
+If the task scope is unclear after Steps 1-4, ask up to 4 clarifying questions via AskUserQuestion:
+
+```
+To create the best task definition, I need to clarify:
+
+1. [question about scope]
+2. [question about approach]
+[max 4 questions]
+```
+
+Skip if requirements are already clear from Step 1.
+
+### Step 6: Resolve Worktree Assignment
+
+Resolve worktree_id via `npx codebyplan resolve-worktree 2>/dev/null`.
+
+- If non-empty: pass as `assigned_worktree_id` in Step 7. This engages the hard-lock from creation.
+- If empty: warn the user that the task will be unassigned and offer to run `npx codebyplan setup` from the current directory first. After setup, re-resolve and proceed. If the user declines, create without `assigned_worktree_id`.
+
+### Step 7: Create Standalone Task
+
+Use MCP `create_standalone_task` with:
+- **repo_id**: from `.codebyplan/repo.json`
+- **title**: Concise task title
+- **number**: next available number from Step 3
+- **requirements**: Numbered requirements list
+- **context**: Include decisions from Q&A and source findings
+- **assigned_worktree_id**: from Step 6 (if resolved)
+
+```
+## Standalone Task Created
+
+**TASK-[N]**: [title]
+
+### Requirements:
+1. [requirement 1]
+2. [requirement 2]
+...
+
+### Context:
+- Decisions: [key decisions from Q&A]
+- Files likely touched: [relevant paths]
+```
+
+### Step 8: Route
+
+```
+Standalone TASK-[N] created successfully.
+```
+
+---
+
+**Next:**
+Run `/cbp-standalone-task-start {N}` to begin work on this task.
+
+---
+
+Waiting for user to decide next step.
+
+## Key Rules
+
+- **Runs inline** — no subagent, preserves Q&A flow
+- **No checkpoint** — standalone tasks have no checkpoint_id
+- **Gather context first** — understand before creating
+- **Dedup against existing standalone tasks** — check Step 3.5 always
+- **Does NOT auto-trigger** — user decides when to start
+
+## Integration
+
+- **Reads**: MCP `get_standalone_tasks`
+- **Writes**: MCP `create_standalone_task`
+- **Triggered by**: user manual
+- **Does NOT auto-trigger** next command — user decides

package/templates/skills/cbp-standalone-task-start/SKILL.md

@@ -0,0 +1,177 @@
+---
+scope: repo-only:codebyplan
+name: cbp-standalone-task-start
+description: Start a standalone task, load context from DB
+argument-hint: [task]  # e.g. `45` (standalone TASK-45)
+effort: xhigh
+---
+
+# Standalone Task Start Command
+
+Start a standalone task by loading context from the database and preparing for work. Standalone tasks are not checkpoint-bound — they have no CHK-NNN parent.
+
+## Instructions
+
+### Step 1: Parse `$ARGUMENTS`
+
+| Shape | Regex | Resolves to |
+|-------|-------|-------------|
+| `{task}` (e.g. `45`) | `^[0-9]+$` | Standalone TASK-{task} |
+| _(empty)_ | — | Use MCP `get_current_standalone_task` |
+
+Any multi-segment input is an error — stop immediately:
+
+```
+standalone-task-start: argument `{value}` looks like a checkpoint-task pair.
+Use /cbp-task-start {chk}-{task} for checkpoint-bound tasks.
+Standalone tasks use a bare number, e.g. /cbp-standalone-task-start 45.
+```
+
+Error cases: `141-3` (that is a checkpoint-task pair), `abc`, `108-`, `-1`, anything with whitespace or non-numeric characters, or multiple dash-separated segments.
+
+#### Worked examples
+
+- `standalone-task-start 45` → standalone TASK-45
+- `standalone-task-start` (no arg) → current standalone task via `get_current_standalone_task`
+- `standalone-task-start 141-3` → error: "Use /cbp-task-start {chk}-{task} for checkpoint-bound tasks."
+- `standalone-task-start abc` → error: malformed
+
+### Step 2: Resolve Task
+
+| Parse | Resolution path |
+|-------|-----------------|
+| `{task}` | MCP `get_standalone_tasks(repo_id)` → filter `number === {task}` (must exist). |
+| _(empty)_ | MCP `get_current_standalone_task(repo_id)` — finds the active in-progress standalone task. |
+
+If no row is found, surface this and stop:
+
+```
+standalone-task-start: no standalone task found for `{ARG}`.
+  - Check with /cbp-standalone-task-create if the task has not been created yet.
+  - For checkpoint-bound tasks, use /cbp-task-start {chk}-{task}.
+```
+
+### Step 3: Branch Auto-Handling
+
+The task MUST run on its target feat branch. Claude switches/creates that branch automatically — never asks the user to do it.
+
+#### 3.1 — Determine the target branch
+
+Read `.codebyplan/git.json`:
+- `branch_config.protected` (fall back to `["main"]`)
+- `branch_config.production` (fall back to `"main"`) → store as `PRODUCTION`
+
+Compute `TARGET`:
+
+| Task type | TARGET |
+|-----------|--------|
+| Standalone, `task.branch_name` set | `task.branch_name` |
+| Standalone, `branch_name` null | `feat/standalone-TASK-{N}-{kebab-slug-from-task-title}` |
+
+Slug rules: lowercase, words joined by `-`, drop punctuation, truncate to 40 chars.
+
+#### 3.2 — Compare current branch
+
+Run `git branch --show-current`. If `current == TARGET` → continue to Step 3b. Done.
+
+#### 3.3 — Switch automatically (no AskUserQuestion, no blocking)
+
+```bash
+# (a) target exists locally
+if git rev-parse --verify "$TARGET" >/dev/null 2>&1; then
+  git checkout "$TARGET"
+
+# (b) target exists on origin (track it)
+elif git rev-parse --verify "origin/$TARGET" >/dev/null 2>&1; then
+  git checkout -t "origin/$TARGET"
+
+# (c) target doesn't exist — create from production branch
+else
+  git fetch origin "$PRODUCTION" 2>/dev/null || true
+  git checkout -b "$TARGET" "origin/$PRODUCTION" 2>/dev/null \
+    || git checkout -b "$TARGET" "$PRODUCTION"
+fi
+```
+
+No `git stash`, ever (per `git-safety.md`). No `git add`, ever (per `git-workflow.md`).
+
+If `git checkout` exits non-zero (would clobber), surface the raw git error verbatim and stop.
+
+#### 3.4 — Persist + verify
+
+After successful switch:
+
+1. Re-run `git branch --show-current` to confirm `current == TARGET`.
+2. If `task.branch_name` was null, persist: `update_standalone_task(task_id, context: { ...task.context, branch_name: TARGET })`
+3. One-line confirmation: `Branch: [TARGET] (switched from [previous])`.
+
+#### 3.5 — Protected-branch sanity (defensive)
+
+If `current` is still in `branch_config.protected`, block with a hard error citing the bad config.
+
+### Step 3b: Clean Slate
+
+1. Run `git status --short` to check for uncommitted files.
+2. If uncommitted files exist → commit them with `chore: clean slate for task start`. Prefer `git add -A && git commit -m "..."`.
+
+### Step 3.5: Worktree-Match Verification
+
+Before activating, verify the caller's worktree matches the assigned worktree.
+
+1. `CALLER_WT=$(npx codebyplan resolve-worktree 2>/dev/null)`. If empty, omit `caller_worktree_id` from MCP calls.
+2. `TARGET_WT = task.assigned_worktree_id`.
+3. If `TARGET_WT IS NOT NULL AND TARGET_WT != CALLER_WT`, surface error and abort:
+
+   ```
+   Standalone TASK-N is assigned to worktree {TARGET_WT_NAME} ({TARGET_WT}); current worktree is {CALLER_WT_NAME} ({CALLER_WT}).
+   Use the release_assignment MCP tool (requires maintainer role) if {TARGET_WT_NAME} is dead, then re-run /cbp-standalone-task-start.
+   ```
+
+4. If `TARGET_WT IS NULL` or matches, proceed.
+
+### Step 3.6: Main-Drift Check (optional)
+
+Soft-skip on fetch failure.
+
+1. Run `git fetch origin {PRODUCTION}`. Skip entire step if fetch fails.
+2. `BEHIND=$(git rev-list --count HEAD..origin/{PRODUCTION})`.
+3. Compute `LAST_FETCH_AGE_HOURS` from mtime of `.git/FETCH_HEAD`.
+4. If `BEHIND >= 10` OR `LAST_FETCH_AGE_HOURS > 24`: AskUserQuestion — merge main now (A: Yes → trigger `/cbp-merge-main`, B: No → proceed).
+
+### Step 4: Load Context
+
+Load context from DB:
+
+1. **Task context**: decisions, discoveries, requirements
+2. **Previous rounds**: check for completed rounds via `get_standalone_rounds(task_id)`
+
+```
+## Starting Standalone Task: TASK-[N]
+
+**Task**: [title]
+**Requirements**: [requirements]
+
+### Context
+- **Decisions**: [list locked decisions relevant to this task]
+- **Previous rounds**: [count] completed
+```
+
+### Step 5: Set Task Status
+
+Use MCP `update_standalone_task(task_id, status: "in_progress")`.
+
+If `CALLER_WT` is present, include `caller_worktree_id: CALLER_WT`.
+
+### Step 6: Auto-trigger Round Start
+
+Trigger `/cbp-round-start` with no argument. Do NOT pass the task number — round-start's 2-segment form means standalone TASK-{a} round {b}, not a checkpoint task. Passing no argument causes round-start to derive the active task/round from state, which is correct.
+
+```
+Starting first round...
+```
+
+## Integration
+
+- **Reads**: MCP `get_standalone_tasks`, `get_current_standalone_task`, `get_standalone_rounds`
+- **Writes**: MCP `update_standalone_task`
+- **Triggers**: `/cbp-round-start` (no argument — auto, round 1)