prizmkit 1.0.45 → 1.0.66

package/bundled/skills/refactor-workflow/SKILL.md

@@ -1,21 +1,28 @@
 ---
 name: "refactor-workflow"
 tier: 1
-description: "[Tier 1] End-to-end refactor workflow: analyze → plan → implement → review → commit. 5-phase behavior-preserving pipeline with mandatory test gates. (project)"
----
-
-refactor-workflow-SKILL.md
-refactor-workflow/SKILL.md
+description: "End-to-end refactor workflow: analyze → plan → implement → review → commit. 5-phase behavior-preserving pipeline with mandatory test gates. Use this skill whenever the user wants to restructure, clean up, or optimize code without changing behavior. Trigger on: 'refactor', 'clean up code', 'restructure', 'optimize code structure', 'extract module', '重构', '优化代码结构', '代码重构'. (project)"
 ---
 
 # PrizmKit Refactor Workflow
 
-End-to-end orchestration skill for code refactoring and optimization. Chains existing PrizmKit skills (tech-debt-tracker, plan, implement, code-review, committer) into a 5-phase behavior-preserving pipeline with mandatory test gates after each task.
+End-to-end orchestration skill for code refactoring and optimization. Chains existing PrizmKit skills into a 5-phase behavior-preserving pipeline with mandatory test gates after each task.
+
+### When to Use
+- User says "refactor", "clean up code", "restructure", "extract module", "重构", "优化代码结构"
+- Code has accumulated tech debt that needs structural improvement
+- Module needs to be split, merged, or reorganized
+- When behavior must remain unchanged but internal quality needs improvement
+
+**Do NOT use when:**
+- User wants to add new features (use `feature-workflow`)
+- User wants to fix bugs (use `bug-planner` + `bugfix-pipeline-launcher`)
+- Change is trivial (single rename, <5 lines) — just do it directly
 
 ## Overview
 
 ```
-prizmkit.refactor <目标模块或描述>
+refactor-workflow
   → Phase 1: Analyze   → refactor-analysis.md
   → Phase 2: Plan      → plan.md (including Tasks section)
   → Phase 3: Implement → (code)
@@ -27,45 +34,49 @@ prizmkit.refactor <目标模块或描述>
 
 | Phase | Name | Skill Used | Artifact |
 |-------|------|-----------|----------|
-| 1 | Analyze 代码分析 | `prizmkit.tech-debt-tracker` + code reading | → `refactor-analysis.md` |
-| 2 | Plan 重构方案与任务 | `prizmkit.plan` | → `plan.md` (含 Tasks section) |
-| 3 | Implement 实现 | `prizmkit.implement` | (code changes) |
-| 4 | Code Review | `prizmkit.code-review` | (review report) |
-| 5 | Commit | `prizmkit.committer` | git commit |
+| 1 | Analyze 代码分析 | Built-in code analysis + code reading | → `refactor-analysis.md` |
+| 2 | Plan 重构方案与任务 | `/prizmkit-plan` | → `plan.md` (含 Tasks section) |
+| 3 | Implement 实现 | `/prizmkit-implement` | (code changes) |
+| 4 | Code Review | `/prizmkit-code-review` | (review report) |
+| 5 | Commit | `/prizmkit-committer` | git commit |
 
 ### Key Principles
+
 | Principle | Description |
 |-----------|-------------|
-| **Behavior preservation** | Refactoring MUST NOT change observable behavior. Acceptance criteria = "behavior unchanged + structure improved". |
-| **Test gates** | Full test suite MUST run after EVERY task** — not just at checkpoints. |
-| **No REGISTRY entry** | Refactoring does not go into REGISTRY.md (no user stories, no feature registration). |
-| **Incremental safety** | Each task preserves all tests; if tests fail → STOP and revert. |
+| **Behavior preservation** | Refactoring changes structure, not behavior. If tests pass before and after, behavior is preserved. Acceptance criteria = "behavior unchanged + structure improved". |
+| **Test gates** | Full test suite runs after every task — not just at checkpoints. A refactoring that breaks tests mid-way is much harder to debug than catching it immediately. |
+| **Structural sync only** | Refactoring triggers `/prizmkit-retrospective` Job 1 (structural sync) — update `.prizm-docs/` to reflect file/interface changes. Skip knowledge injection unless a genuinely new pitfall was discovered during refactoring. |
+| **Incremental safety** | Each task preserves all tests (green → green). If tests fail → stop and revert, because later tasks build on the assumption that previous ones are clean. |
 
 ### Artifacts
 Refactor artifacts stored at `.prizmkit/refactor/<refactor-slug>/`:
 - **`refactor-analysis.md`** — Code analysis (Phase 1)
 - **`plan.md`** — Refactoring plan with Tasks section (Phase 2)
 
-## Commands
-### prizmkit.refactor \<目标模块或描述\>
-Execute the full refactor pipeline for a module or code area.
 **INPUT**: Target description. Can be:
 - Module or file path (e.g., "src/auth/")
 - Natural language description (e.g., "重构认证模块，提取公共逻辑")
 - Specific refactoring goal (e.g., "extract payment processing into separate service")
+
 ---
 
 ## Phase 1: Analyze — 代码分析
+
 **Goal**: Assess current code state, identify refactoring targets, establish baseline.
+
 **STEPS:**
+
 1. **Read target code**: Thoroughly read and understand the target module/files:
    - Code structure and architecture
    - Dependencies (incoming and outgoing)
    - Current test coverage
    - Known tech debt (from `.prizm-docs/` TRAPS)
-2. **Invoke `prizmkit.tech-debt-tracker`** on target area:
-   - Receive: debt items, complexity metrics, code smell patterns
+2. **Perform code analysis** on target area:
+   - Identify code smells: long functions, deep nesting, duplicated logic, excessive coupling
+   - Assess complexity metrics: function length, parameter count, cyclomatic complexity
    - Identify highest-impact refactoring opportunities
+   - Check for TODO/FIXME/HACK comments indicating known debt
 3. **Establish baseline**:
    - Run full test suite — record pass/fail counts
    - Note any pre-existing test failures (isolate from refactor impact)
@@ -77,15 +88,21 @@ Execute the full refactor pipeline for a module or code area.
    - **Risk Assessment**: what could break, cross-module impact, data migration needs
    - **Baseline Tests**: test suite status (total, passing, failing), coverage estimate, behavior contracts to preserve
    - **Scope Boundary**: what IS in scope, what is explicitly OUT of scope
+
 **CHECKPOINT CP-RW-1**: `refactor-analysis.md` exists with baseline test results.
+
 ---
+
 ## Phase 2: Plan — 重构方案与任务
+
 **Goal**: Generate technical refactoring plan that preserves behavior, including task breakdown.
+
 **STEPS:**
+
 1. **Read context**: refactor-analysis.md, `.prizm-docs/` (PATTERNS, RULES, TRAPS)
-2. **Invoke `prizmkit.plan`** with refactor-analysis.md as input (in place of spec.md):
-   - Plan MUST specify: what changes, what stays the same, how behavior is preserved
-   - plan.md Tasks section: each task MUST be independently testable, MUST preserve all tests (green → green)
+2. **Invoke `/prizmkit-plan`** with refactor-analysis.md as input (in place of spec.md):
+   - Plan specifies: what changes, what stays the same, how behavior is preserved
+   - plan.md Tasks section: each task is independently testable and preserves all tests (green → green) — this ensures any failure is immediately traceable to the task that caused it
    - Artifact path: `.prizmkit/refactor/<refactor-slug>/plan.md`
 3. **Verify plan constraints**:
    - All public API contracts preserved
@@ -93,77 +110,115 @@ Execute the full refactor pipeline for a module or code area.
    - Rollback strategy: how to revert if behavior breaks
    - Tasks ordered to minimize risk (safe renames first, structural changes later)
    - Every task ends with "run full test suite"
+
 **CHECKPOINT CP-RW-2**: `plan.md` exists with behavior preservation strategy and Tasks section.
+
 ---
+
 ## Phase 3: Implement — 实现
+
 **Goal**: Execute refactoring tasks with mandatory test verification after each task.
+
 **STEPS:**
+
 1. **For EACH task in plan.md Tasks section**:
    a. Implement the refactoring change
-   b. **Run FULL test suite** (not just affected tests)
+   b. **Run FULL test suite** (not just affected tests) — refactoring can have surprising cross-module effects that targeted tests miss
    c. Verify: all previously-passing tests still pass
-   d. If any test fails → STOP, revert task, investigate
+   d. If any test fails → stop, revert task, investigate
 2. **Progress tracking**:
    - Mark tasks complete in plan.md Tasks section as they finish
    - Record test results after each task
+
 **CHECKPOINT CP-RW-3**: All tasks complete, full test suite green.
-**KEY RULES:**
-- NEVER skip the test gate between tasks
-- NEVER allow temporary test failures ("we'll fix it in the next task")
+
+**Important constraints for Phase 3:**
+- Never skip the test gate between tasks — a broken intermediate state compounds into much harder debugging later
+- Never allow temporary test failures ("we'll fix it in the next task") — this assumption is almost always wrong in refactoring
 - If a task cannot be completed without breaking tests → split it into smaller tasks
 - Max 3 attempts per task before escalating to user
+
 ---
+
 ## Phase 4: Code Review — 代码审查
+
 **Goal**: Verify refactoring quality and behavior preservation.
+
 **STEPS:**
-1. **Invoke `prizmkit.code-review`** (scoped to changed files):
+
+1. **Invoke `/prizmkit-code-review`** (scoped to changed files):
    - Review dimensions for refactoring:
      - **Behavior preservation**: Does observable behavior remain identical?
      - **Structural improvement**: Is the code measurably better? (complexity, coupling, readability)
      - **Test integrity**: Are all tests still meaningful and passing?
      - **Code quality**: Does refactored code follow project conventions?
    - Verdict: PASS / PASS_WITH_WARNINGS / NEEDS_FIXES
-2. **Run full test suite one final time**: All tests MUST pass
+2. **Run full test suite one final time**: All tests must pass
 3. **Handle review results**:
-   - **PASS / PASS_WITH_WARNINGS**: Proceed to Phase 6
+   - **PASS / PASS_WITH_WARNINGS**: Proceed to Phase 5
    - **NEEDS_FIXES**: Return to Phase 3 (max 2 review rounds)
+
 **CHECKPOINT CP-RW-4**: Code review passes, all tests green.
+
 ---
+
 ## Phase 5: Commit — 提交
+
 **Goal**: Commit with refactor convention.
+
 **STEPS:**
-1. **Invoke `prizmkit.committer`**:
+
+1. **Invoke `/prizmkit-retrospective`** (Job 1: structural sync only):
+   - Update KEY_FILES/INTERFACES/DEPENDENCIES in affected `.prizm-docs/` files
+   - Skip knowledge injection unless refactoring revealed a genuinely new pitfall (e.g. a non-obvious coupling)
+   - If structural changes are significant (module split/merge), update L1 doc
+   - Stage doc changes: `git add .prizm-docs/`
+2. **Invoke `/prizmkit-committer`**:
    - Commit message: `refactor(<scope>): <description>`
    - Include all refactored code + any test updates
    - Do NOT push
-   - Do NOT invoke `prizmkit.summarize` (no REGISTRY entry for refactoring)
-2. **Update `.prizm-docs/`** if needed:
-   - Updated module structure documentation
-   - New PATTERNS discovered
-   - Resolved TRAPS (remove if debt is paid)
+
 **CHECKPOINT CP-RW-5**: Commit recorded with `refactor()` prefix.
+
 ---
+
 ## Fast Path — 快速路径
+
 For single-file refactoring (rename, extract method, <30 lines changed):
+
 ```
-Phase 1 (Analyze) → Phase 3 (Implement) → Phase 4 (Review) → Phase 5 (Commit)
+Phase 1 (Analyze) → Phase 2 (Simplified Plan) → Phase 3 (Implement) → Phase 4 (Review) → Phase 5 (Commit)
 ```
-Skip Phase 2 (Plan).
+
+Skip Phase 2's detailed planning process, but still generate a lightweight `plan.md` with a simplified Tasks section (typically 1-2 tasks).
+
 **CRITERIA** (ALL must be true):
 - Single file change
 - Estimated change < 30 lines
 - Well-known refactoring pattern (rename, extract method/class, inline, move)
 - No cross-module impact
 - No dependency changes
+
+**Fast Path implementation differs from full path:**
+- Phase 2 is simplified: generate a lightweight plan.md with 1-2 tasks directly from refactor-analysis.md, without deep architecture research
+- Phase 3 still reads plan.md Tasks as normal, marks tasks `[x]` on completion
+- Single-task refactors typically have just one task in plan.md
+
 **Fast Path still requires:**
 - refactor-analysis.md (lightweight version with baseline)
+- plan.md (simplified, 1-2 tasks)
 - Full test suite run after implementation
 - Code review
 - `refactor(<scope>):` commit convention
+
 ---
+
 ## Resume — 中断恢复
+
 The pipeline supports resuming from the last completed phase by detecting existing artifacts.
+
 **Detection logic**: Check `.prizmkit/refactor/<slug>/` for:
+
 | Artifact Found | Resume From |
 |---------------|------------|
 | (nothing) | Phase 1: Analyze |
@@ -171,9 +226,13 @@ The pipeline supports resuming from the last completed phase by detecting existi
 | `refactor-analysis.md` + `plan.md` | Phase 3: Implement |
 | All docs + code changes exist | Phase 4: Review |
 | All docs + review passed | Phase 5: Commit |
-**Resume command**: `prizmkit.refactor <slug>` — if `<slug>` matches an existing `.prizmkit/refactor/<slug>/` directory, resume instead of starting fresh.
+
+**Resume**: If `<slug>` matches an existing `.prizmkit/refactor/<slug>/` directory, resume instead of starting fresh.
+
 ---
+
 ## Error Handling
+
 | Scenario | Action |
 |----------|--------|
 | Cannot identify target module | Ask user for clarification |
@@ -184,22 +243,27 @@ The pipeline supports resuming from the last completed phase by detecting existi
 | Review fails after 2 rounds | Escalate with review findings |
 | Refactoring creates circular dependency | STOP, revise plan |
 | Performance regression detected | STOP, investigate, revise approach |
+
 ---
+
 ## Relationship to Other Skills
+
 | Skill | Role in Refactor Workflow |
 |-------|--------------------------|
-| `prizmkit-tool-tech-debt-tracker` | Phase 1: identify debt and complexity |
-| `prizmkit-plan` | Phase 2: refactoring plan + task generation |
-| `prizmkit-implement` | Phase 3: execute refactoring tasks |
-| `prizmkit-code-review` | Phase 4: review quality and behavior preservation |
-| `prizmkit-committer` | Phase 5: commit with `refactor()` convention |
+| (built-in code analysis) | Phase 1: identify debt and complexity |
+| `/prizmkit-plan` | Phase 2: refactoring plan + task generation |
+| `/prizmkit-implement` | Phase 3: execute refactoring tasks |
+| `/prizmkit-code-review` | Phase 4: review quality and behavior preservation |
+| `/prizmkit-committer` | Phase 5: commit with `refactor()` convention |
+| `/prizmkit-retrospective` | Phase 5: structural sync before commit (Job 1 only, skip knowledge injection unless new pitfall) |
 | `feature-workflow` | Handoff target when new behavior is needed |
-| `prizmkit-specify` | NOT used (no user stories for refactoring) |
-| `prizmkit-analyze` | NOT used (no spec ↔ plan consistency needed) |
-| `prizmkit-summarize` | NOT used (no REGISTRY entry for refactoring) |
-| `prizmkit-retrospective` | Optional: post-refactor lessons learned |
+| `/prizmkit-specify` | NOT used (no user stories for refactoring) |
+| `/prizmkit-analyze` | NOT used (no spec ↔ plan consistency needed) |
+
 ---
+
 ## Comparison with Feature and Bug Fix Pipelines
+
 | Dimension | Feature Workflow | Refactor Workflow | Bug Fix Pipeline |
 |-----------|-----------------|-------------------|------------------|
 | Input | Natural language requirement | Module/code target | Bug description |
@@ -211,9 +275,9 @@ The pipeline supports resuming from the last completed phase by detecting existi
 | Test Strategy | TDD per task | Full suite after EVERY task | Reproduction test |
 | Scope Guard | N/A | ✅ (enforced) | N/A |
 | Behavior Change | ✅ Expected | ❌ Forbidden | ✅ Fix behavior |
-## Path References
-All internal asset paths MUST use `${SKILL_DIR}` placeholder for cross-IDE compatibility.
+
 ## Output
+
 - `refactor-analysis.md` (Phase 1 artifact)
 - `plan.md` with Tasks section (Phase 2 artifact)
 - Refactored implementation code (Phase 3)

package/bundled/team/prizm-dev-team.json

@@ -19,14 +19,14 @@
       "name": "dev",
       "role": "developer",
       "agentDefinition": "prizm-dev-team-dev",
-      "prompt": "You are a Dev Agent of the prizm-dev-team. Follow prizmkit.implement workflow with TDD. Read tasks.md/plan.md/spec.md, implement task-by-task, mark completed tasks [x]. Check .prizm-docs/ TRAPS before implementing.",
+      "prompt": "You are a Dev Agent of the prizm-dev-team. Follow /prizmkit-implement workflow with TDD. Read plan.md/spec.md, implement task-by-task, mark completed tasks [x]. Check .prizm-docs/ TRAPS before implementing.",
       "subscriptions": ["*"]
     },
     {
       "name": "reviewer",
       "role": "reviewer",
       "agentDefinition": "prizm-dev-team-reviewer",
-      "prompt": "You are the Reviewer Agent of the prizm-dev-team. In Phase 4: run prizmkit.analyze for cross-document consistency. In Phase 6: run prizmkit.code-review for spec compliance and code quality, write and execute integration tests.",
+      "prompt": "You are the Reviewer Agent of the prizm-dev-team. In Phase 4: run /prizmkit-analyze for cross-document consistency. In Phase 6: run /prizmkit-code-review for spec compliance and code quality, write and execute integration tests.",
       "subscriptions": ["*"]
     }
   ]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prizmkit",
-  "version": "1.0.45",
+  "version": "1.0.66",
   "description": "Create a new PrizmKit-powered project with clean initialization — no framework dev files, just what you need.",
   "type": "module",
   "bin": {

package/src/scaffold.js

@@ -367,7 +367,7 @@ export async function installSettings(platform, projectRoot, options, dryRun) {
 
     // Read hook definition from unified template
     const templatesDir = getTemplatesDir();
-    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent-codebuddy.json'));
+    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent.json'));
 
     await fs.writeFile(settingsPath, JSON.stringify(hookTemplate, null, 2));
     console.log(chalk.green(`      ✓ .codebuddy/settings.json`));
@@ -392,7 +392,7 @@ export async function installSettings(platform, projectRoot, options, dryRun) {
 
     // Read hook definition from unified template
     const templatesDir = getTemplatesDir();
-    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent-claude.json'));
+    const hookTemplate = await fs.readJSON(path.join(templatesDir, 'hooks', 'commit-intent.json'));
 
     // Settings
     const permissions = [
@@ -508,7 +508,7 @@ export async function installPrizmkitScripts(projectRoot, dryRun) {
 async function installProjectMemory(platform, projectRoot, dryRun) {
   const templatesDir = getTemplatesDir();
   const skillsDir = getSkillsDir();
-  const templateName = platform === 'claude' ? 'claude-md-template.md' : 'codebuddy-md-template.md';
+  const templateName = 'project-memory-template.md';
   const targetName = platform === 'claude' ? 'CLAUDE.md' : 'CODEBUDDY.md';
   const targetPath = path.join(projectRoot, targetName);
 
@@ -850,7 +850,7 @@ export async function scaffold(config) {
     console.log('  下一步:');
     console.log(`    1. ${chalk.cyan('cd ' + projectRoot)}`);
     console.log(`    2. ${chalk.cyan(cli)}                          ${chalk.gray('# 启动 AI 对话')}`);
-    console.log(`    3. ${chalk.cyan('说 "prizmkit.init"')}           ${chalk.gray('# 初始化项目上下文')}`);
+    console.log(`    3. ${chalk.cyan('说 "/prizmkit-init"')}           ${chalk.gray('# 初始化项目上下文')}`);
 
     if (pipeline) {
       console.log(`    4. ${chalk.cyan('说 "规划一个应用"')}             ${chalk.gray('# 生成 feature-list.json')}`);

package/bundled/dev-pipeline/lib/worktree.sh

@@ -1,164 +0,0 @@
-#!/usr/bin/env bash
-# ============================================================
-# dev-pipeline/lib/worktree.sh - Git Worktree Lifecycle Library
-#
-# Shared by run.sh and run-bugfix.sh to isolate AI CLI sessions
-# in separate git worktrees. Each session runs on its own branch
-# inside a worktree directory, enabling parallel-safe execution
-# and clean main branch history.
-#
-# Functions:
-#   worktree_create      — Create worktree + branch before session
-#   worktree_merge       — Merge worktree branch into target after success
-#   worktree_cleanup     — Remove worktree directory and branch
-#   worktree_prune_stale — Prune stale worktree references
-#
-# Environment:
-#   USE_WORKTREE  — Set to 1 to enable (default), 0 to disable
-#   AUTO_PUSH     — Set to 1 to auto-push after successful merge
-# ============================================================
-
-# worktree_create <project_root> <worktree_base_dir> <session_id> <source_branch>
-#
-# Creates a git worktree and sets global vars:
-#   _WORKTREE_PATH   — absolute path to the worktree directory
-#   _WORKTREE_BRANCH — branch name (worktree/<session_id>)
-#
-# Returns 0 on success, 1 on failure.
-worktree_create() {
-    local project_root="$1"
-    local worktree_base_dir="$2"
-    local session_id="$3"
-    local source_branch="$4"
-
-    _WORKTREE_PATH=""
-    _WORKTREE_BRANCH=""
-
-    local branch_name="worktree/${session_id}"
-    local worktree_path="${worktree_base_dir}/${session_id}"
-
-    # Ensure base directory exists
-    mkdir -p "$worktree_base_dir"
-
-    # Check if worktree path already exists
-    if [[ -d "$worktree_path" ]]; then
-        log_warn "Worktree path already exists: $worktree_path"
-        return 1
-    fi
-
-    # Check if branch already exists
-    if git -C "$project_root" rev-parse --verify "$branch_name" >/dev/null 2>&1; then
-        log_warn "Branch already exists: $branch_name"
-        return 1
-    fi
-
-    # Create worktree with new branch
-    if ! git -C "$project_root" worktree add -b "$branch_name" "$worktree_path" "$source_branch" 2>/dev/null; then
-        log_error "Failed to create worktree at $worktree_path"
-        return 1
-    fi
-
-    _WORKTREE_PATH="$worktree_path"
-    _WORKTREE_BRANCH="$branch_name"
-
-    log_info "Created worktree: $worktree_path (branch: $branch_name)"
-    return 0
-}
-
-# worktree_merge <project_root> <worktree_branch> <target_branch> <item_id> <session_id>
-#
-# Merges worktree branch into target branch (no fast-forward).
-# Sets global var:
-#   _MERGE_RESULT — "success", "conflict", or "error"
-#
-# Returns 0 on success, 1 on conflict, 2 on other error.
-worktree_merge() {
-    local project_root="$1"
-    local worktree_branch="$2"
-    local target_branch="$3"
-    local item_id="$4"
-    local session_id="$5"
-
-    _MERGE_RESULT=""
-
-    # Switch to target branch in the main working tree
-    local current_branch
-    current_branch=$(git -C "$project_root" rev-parse --abbrev-ref HEAD 2>/dev/null) || {
-        log_error "Failed to determine current branch"
-        _MERGE_RESULT="error"
-        return 2
-    }
-
-    if [[ "$current_branch" != "$target_branch" ]]; then
-        if ! git -C "$project_root" checkout "$target_branch" 2>/dev/null; then
-            log_error "Failed to checkout target branch: $target_branch"
-            _MERGE_RESULT="error"
-            return 2
-        fi
-    fi
-
-    # Attempt merge (no fast-forward to preserve history)
-    local merge_msg="Merge ${worktree_branch} for ${item_id} (session: ${session_id})"
-    if git -C "$project_root" merge --no-ff -m "$merge_msg" "$worktree_branch" 2>/dev/null; then
-        _MERGE_RESULT="success"
-        log_success "Merged $worktree_branch into $target_branch"
-        return 0
-    else
-        # Check if it's a merge conflict
-        if git -C "$project_root" diff --name-only --diff-filter=U 2>/dev/null | head -1 | read -r _; then
-            # Abort the merge to leave working tree clean
-            git -C "$project_root" merge --abort 2>/dev/null || true
-            _MERGE_RESULT="conflict"
-            log_warn "Merge conflict detected for $worktree_branch"
-            return 1
-        else
-            git -C "$project_root" merge --abort 2>/dev/null || true
-            _MERGE_RESULT="error"
-            log_error "Merge failed for $worktree_branch"
-            return 2
-        fi
-    fi
-}
-
-# worktree_cleanup <project_root> <worktree_path> <worktree_branch>
-#
-# Removes worktree directory and deletes the branch.
-# Idempotent — safe to call even if worktree/branch don't exist.
-#
-# Returns 0 always.
-worktree_cleanup() {
-    local project_root="$1"
-    local worktree_path="$2"
-    local worktree_branch="$3"
-
-    # Remove the worktree (if it exists)
-    if [[ -n "$worktree_path" && -d "$worktree_path" ]]; then
-        git -C "$project_root" worktree remove --force "$worktree_path" 2>/dev/null || {
-            # Fallback: manual removal
-            rm -rf "$worktree_path" 2>/dev/null || true
-        }
-        log_info "Removed worktree: $worktree_path"
-    fi
-
-    # Delete the branch (if it exists)
-    if [[ -n "$worktree_branch" ]]; then
-        git -C "$project_root" branch -D "$worktree_branch" 2>/dev/null || true
-    fi
-
-    # Prune stale worktree entries
-    git -C "$project_root" worktree prune 2>/dev/null || true
-
-    return 0
-}
-
-# worktree_prune_stale <project_root>
-#
-# Runs `git worktree prune` to clean up stale worktree references.
-#
-# Returns 0 always.
-worktree_prune_stale() {
-    local project_root="$1"
-
-    git -C "$project_root" worktree prune 2>/dev/null || true
-    return 0
-}