Worktree Job (wt-j) - Autonomous Isolated Development

Execute a development task in a completely isolated git worktree environment. This command runs autonomously until PR creation without requiring user approval.

Input

$ARGUMENTS

CRITICAL SAFETY RULES

ABSOLUTE PROHIBITIONS (NEVER VIOLATE)

1. NEVER modify files in the parent directory

   • The parent of the worktree directory is OFF-LIMITS
   • Only work within the created worktree directory

2. NEVER modify the default branch (main/master/develop)

   • All work MUST be on a feature branch
   • NEVER checkout or commit to the default branch

3. NEVER modify files outside the worktree

   • Your working directory is worktrees/<job-name>/
   • Any path not starting with your worktree path is FORBIDDEN

4. NEVER delete or force-push existing branches

   • Only create new branches
   • NEVER use git push --force on existing branches

5. NEVER delete the worktree before the PR is merged

   • Worktree cleanup is handled by /pw:wt-clean
   • Only wt-clean can delete worktrees, and only after merge verification

Verification Before Any File Operation

Before ANY file write/edit operation, verify the target path starts with your worktree directory. If you are about to modify a file outside worktrees/<job-name>/, STOP IMMEDIATELY.

---

Phase 1: Setup Isolated Worktree

Environment Setup (Single Block)

#!/bin/bash
set -e

# Plugin discovery
_PD=""; for _d in .claude-paralell-dev-plugin ../.claude-paralell-dev-plugin ../../.claude-paralell-dev-plugin "$HOME"/.claude/plugins/cache/claude-parallel-dev-plugin/pw/*; do [ -d "$_d/scripts" ] && _PD="$_d" && break; done 2>/dev/null; [ -n "${PW_PLUGIN_DIR:-}" ] && _PD="$PW_PLUGIN_DIR"

# Run shared worktree setup
"$_PD/scripts/setup-worktree.sh" "$ARGUMENTS" "Worktree Job"

---

Phase 2: Understand Requirements

Fetch Issue Details (if applicable)

# Load metadata from Phase 1
if [ -z "$WORKTREE_PATH" ]; then
  # Try to find wtj-meta in any worktree
  for meta in worktrees/*/.wtj-meta; do
    if [ -f "$meta" ]; then
      source "$meta"
      break
    fi
  done
fi

if [ -z "$WORKTREE_PATH" ] || [ ! -d "$WORKTREE_PATH" ]; then
  echo "ERROR: WORKTREE_PATH not set or directory does not exist"
  echo "This script must be run after Phase 1 setup"
  exit 1
fi

# Source metadata file for all variables
source "$WORKTREE_PATH/.wtj-meta"
cd "$WORKTREE_PATH"

if [ -n "$ISSUE_NUM" ]; then
  echo "=== Issue #${ISSUE_NUM} Details ==="
  gh issue view "$ISSUE_NUM" 2>/dev/null || echo "Could not fetch issue details"
fi

Read Project Configuration

# Load metadata from Phase 1
if [ -z "$WORKTREE_PATH" ]; then
  for meta in worktrees/*/.wtj-meta; do
    [ -f "$meta" ] && source "$meta" && break
  done
fi
[ -z "$WORKTREE_PATH" ] || [ ! -d "$WORKTREE_PATH" ] && echo "ERROR: Run Phase 1 first" && exit 1
source "$WORKTREE_PATH/.wtj-meta"
cd "$WORKTREE_PATH"

echo "=== Project Configuration ==="
if [ -f "CLAUDE.md" ]; then
  echo "--- CLAUDE.md ---"
  head -100 CLAUDE.md
fi

if [ -f "README.md" ]; then
  echo ""
  echo "--- README.md (excerpt) ---"
  head -50 README.md
fi

Explore Codebase

MANDATORY: Use explorer subagent to understand the codebase before implementation.

Use explorer subagent to:
1. Understand the project structure
2. Find files related to the task
3. Identify existing patterns and conventions

For complex tasks, also use analyzer:

Use analyzer subagent to understand architecture and dependencies if needed

---

Phase 3: Autonomous Implementation

NOTE: This phase runs WITHOUT user approval. Make careful, incremental changes.

Planning

Before writing code:

1. List ALL files to create or modify with expected changes per file
2. Estimate lines changed per file
3. Identify patterns to follow from existing code (reference specific files)
4. Identify file dependencies (which files call functions from other files)
5. Consider edge cases and error handling
6. Assess parallelizability: If 3+ independent files need modification, plan for parallel execution

Parallel Implementation (3+ files)

If the implementation plan involves modifying or creating 3 or more files, use simple-implementer subagents for parallel execution:

1. Group files

Group by directory or functional area. Each group should have:

• Max 5 files
• Estimated total changes under ~200 lines
• Minimal cross-group dependencies

2. Write detailed per-file instructions

For each file in each group, describe exactly what to create or modify:

• Function/class signatures and logic
• Expected behavior and edge cases
• Code patterns to follow (reference specific existing files)
• How this file relates to files in other groups (shared interfaces, imports)

3. Pre-Dispatch Review

Before launching subagents, verify your instructions:

• Sufficiency: Each group's instructions are self-contained enough for standalone implementation
• Cross-group consistency: Function signatures, types, and interfaces match across groups
• Scope: Each group's estimated changes are within simple-implementer limits (~200 lines)
• Dependencies: Shared contracts between groups are explicitly documented in each group's instructions

Fix any issues in the instructions before dispatching.

4. Launch simple-implementer subagents in parallel

Launch multiple simple-implementer subagents in parallel using the Task tool. For each group:

Use simple-implementer subagent to implement changes in the following files:

Working directory: [WORKTREE_PATH]

Files and changes:
- `[file1]`: [Detailed description — function signatures, logic, patterns to follow from existing_file:line]
- `[file2]`: [Detailed description — must match interface defined in file1]

Context:
- This is part of a larger task: [task description]
- Related files (read-only reference): [list of files that provide context]
- Code patterns to follow: See [existing file:line] for style reference

After implementation:
1. Verify each file is syntactically correct
2. Stage changed files: `git add [file]`

IMPORTANT:
- Only modify the files listed above
- Follow existing code style exactly
- Do NOT run git commit or git push

5. Integration Review

After all subagents complete:

• Read git diff for all changed files to verify correctness
• Verify cross-file consistency (imports, function calls, type definitions)
• Handle any REJECTED tasks directly
• Fix any integration issues found

Sequential Implementation (1-2 files)

If only 1-2 files need modification, implement directly without subagent overhead.

Implementation Guidelines

• Follow existing code style - match naming, formatting, idioms
• Minimal changes - only modify what's necessary
• Type safety - add type annotations where the project uses them
• Error handling - handle errors appropriately
• No dead code - don't leave commented-out code

Apply Quality Skills:

• Follow /pw:code-quality standards
• Follow /pw:security-review standards for sensitive code

Safety Check Before Each File Operation

Before EVERY file write or edit, verify:

1. You are still in the worktree directory
2. The target file path is within the worktree
3. You are NOT modifying any file in the parent repository

---

Phase 4: Verification (via /pw:precheck)

4.1 Create Interim Commit

/pw:precheck uses git diff BASE...HEAD to review committed changes. Create an interim commit so precheck can analyze the diff.

# Load metadata from Phase 1
if [ -z "$WORKTREE_PATH" ]; then
  for meta in worktrees/*/.wtj-meta; do
    [ -f "$meta" ] && source "$meta" && break
  done
fi
[ -z "$WORKTREE_PATH" ] || [ ! -d "$WORKTREE_PATH" ] && echo "ERROR: Run Phase 1 first" && exit 1
source "$WORKTREE_PATH/.wtj-meta"
cd "$WORKTREE_PATH"

echo "=== Creating Interim Commit for Precheck ==="

git add .
if ! git diff --cached --quiet; then
  git commit -m "wip: ${TASK_DESCRIPTION}"
  echo "Interim commit created"
else
  echo "No changes to commit"
fi

4.2 Run /pw:precheck

Use the Skill tool to invoke /pw:precheck HEAD. This runs comprehensive checks including:

• Local checks (lint, format, type check, build)
• Test verification
• Code quality & codebase consistency review
• Specification alignment check

4.3 Fix Issues and Re-verify

If /pw:precheck reports any issues:

1. Fix the reported problems
2. Stage and amend the interim commit: git add . && git commit --amend --no-edit
3. Re-run /pw:precheck HEAD via the Skill tool
4. Repeat until all precheck phases pass

---

Phase 5: Commit and Push

Final Safety Verification and Commit

# Load metadata from Phase 1
if [ -z "$WORKTREE_PATH" ]; then
  for meta in worktrees/*/.wtj-meta; do
    [ -f "$meta" ] && source "$meta" && break
  done
fi
[ -z "$WORKTREE_PATH" ] || [ ! -d "$WORKTREE_PATH" ] && echo "ERROR: Run Phase 1 first" && exit 1
source "$WORKTREE_PATH/.wtj-meta"
cd "$WORKTREE_PATH"

echo "=== Final Safety Check ==="

CURRENT_DIR=$(pwd)
CURRENT_BRANCH=$(git branch --show-current)

echo "Current directory: $CURRENT_DIR"
echo "Current branch: $CURRENT_BRANCH"

# Verify in worktree
if [[ ! "$CURRENT_DIR" == *"/worktrees/"* ]]; then
  echo "FATAL ERROR: Not in worktree directory!"
  exit 1
fi

# Verify NOT on protected branch
if [ "$CURRENT_BRANCH" = "main" ] || [ "$CURRENT_BRANCH" = "master" ] || [ "$CURRENT_BRANCH" = "develop" ]; then
  echo "FATAL ERROR: On protected branch '$CURRENT_BRANCH'! Aborting."
  exit 1
fi

echo ""
echo "=== Finalizing commit ==="

# Stage any remaining changes (from precheck fix iterations)
git add .
if ! git diff --cached --quiet; then
  git commit --amend --no-edit
fi

# Amend interim commit with proper message
COMMIT_TITLE="${BRANCH_PREFIX}: ${TASK_DESCRIPTION}"

git commit --amend -m "${COMMIT_TITLE}

Automated implementation by wt-j

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>"

echo "Commit finalized: ${COMMIT_TITLE}"

echo ""
echo "=== Pushing branch ==="
git push -u origin "$CURRENT_BRANCH"

echo ""
echo "Branch pushed successfully"

---

Phase 6: Create Pull Request

# Load metadata from Phase 1
if [ -z "$WORKTREE_PATH" ]; then
  for meta in worktrees/*/.wtj-meta; do
    [ -f "$meta" ] && source "$meta" && break
  done
fi
[ -z "$WORKTREE_PATH" ] || [ ! -d "$WORKTREE_PATH" ] && echo "ERROR: Run Phase 1 first" && exit 1
source "$WORKTREE_PATH/.wtj-meta"
cd "$WORKTREE_PATH"

# Variables are now loaded from metadata file:
# - BRANCH_PREFIX, TASK_DESCRIPTION, ISSUE_NUM, etc.

CLOSES_LINE=""
if [ -n "$ISSUE_NUM" ]; then
  CLOSES_LINE="Closes #${ISSUE_NUM}"
fi

# Generate PR title from task description (variables from metadata)
PR_TITLE="${BRANCH_PREFIX}: ${TASK_DESCRIPTION}"

echo "=== Creating Pull Request ==="
echo "Title: ${PR_TITLE}"

gh pr create --title "${PR_TITLE}" --body "## Summary

${TASK_DESCRIPTION}

Automated implementation by wt-j.

## Changes

See commit history for details.

## Testing

- [ ] All existing tests pass
- [ ] New functionality tested

## Related Issues

${CLOSES_LINE:-N/A}

---

🤖 Generated autonomously with [Claude Code](https://claude.com/claude-code)

**Worktree Job**: This PR was created in an isolated worktree environment.

To clean up after merge: \`/pw:wt-clean $(basename $(pwd))\`
"

echo ""
echo "PR created successfully"

---

Output Report

# Worktree Job Report

## Job Information
- **Job Name**: [job-name]
- **Branch**: [branch-name]
- **Worktree Path**: worktrees/[job-name]/
- **Base Branch**: [base-branch]

## Task
[Original task description or issue reference]

## Implementation Summary
[What was implemented]

## Files Changed
- `path/to/file1` - [Description]
- `path/to/file2` - [Description]

## Verification Results
- [ ] Lint: PASS/FAIL
- [ ] Type Check: PASS/FAIL
- [ ] Tests: PASS/FAIL
- [ ] Build: PASS/FAIL

## Pull Request
- **PR URL**: [URL]
- **PR Number**: #[number]
- **Status**: Ready for Review

## Cleanup Instructions

After PR is merged, run:
```bash
/pw:wt-clean [job-name]

WARNING: Do NOT manually delete the worktree before merging!

Notes

[Any additional notes, decisions made, or issues encountered]

---

## Error Handling

If ANY error occurs:

1. **DO NOT** attempt to fix by modifying files outside worktree
2. **DO NOT** switch to base branch
3. **DO NOT** delete the worktree
4. Document the error clearly in the output
5. Leave the worktree in its current state for manual inspection
6. Report what was attempted and what failed

```bash
# On error, show diagnostic info
echo "=== Error Diagnostic ==="
echo "Working directory: $(pwd)"
echo "Branch: $(git branch --show-current 2>/dev/null || echo 'unknown')"
echo "Git status:"
git status --short 2>/dev/null || echo "Not in git repo"
echo ""
echo "Recent commits:"
git log --oneline -5 2>/dev/null || echo "No commits"