workflows:work

Files (3)

• SKILL.md
• worktree-patterns.md · references/
• worktree-manager.sh · scripts/

SKILL.md (first lines)

# Work Plan Execution Command

**Pipeline mode:** This command operates fully autonomously. All decisions are made automatically.

Execute a research implementation plan systematically. The focus is on **shipping complete, reproducible research code** by understanding requirements quickly, following existing patterns, and maintaining estimation quality throughout.

## Input Document

<input_document> #$ARGUMENTS </input_document>

**If no input document is provided:** Look for the most recent plan in `docs/plans/` and use it. If no plans exist, state "No plan found. Run `/workflows:plan` first." and stop.

## Execution Workflow

### Phase 1: Quick Start

1. **Read Plan**

   - Read the work document completely
   - Review any references, brainstorm origins, or linked code paths
   - Identify the estimation method, identification strategy, and key deliverables
   - Note any open questions from planning — resolve by picking the conservative default and documenting the choice
   - **Proceed immediately** — do not wait for approval

2. **Setup Environment**

   First, detect the project environment:

   ```bash
   # Detect estimation language
   if [ -f "requirements.txt" ] || [ -f "setup.py" ] || [ -f "pyproject.toml" ]; then
     echo "LANG=python"
   elif [ -f "DESCRIPTION" ] || [ -f "renv.lock" ] || [ -f ".Rprofile" ]; then
     echo "LANG=R"
   elif [ -f "Project.toml" ]; then
     echo "LANG=julia"
   elif ls *.do >/dev/null 2>&1; then
     echo "LANG=stata"
   fi

   # Detect pipeline tools
   ls Makefile Snakefile dvc.yaml 2>/dev/null
   ```

   Then check the current branch:

   ```bash
   current_branch=$(git branch --show-current)
   default_branch=$(git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null | sed 's@^refs/remotes/origin/@@')
   if [ -z "$default_branch" ]; then
     default_branch=$(git rev-parse --verify origin/main >/dev/null 2>&1 && echo "main" || echo "master")
   fi
   ```

   **If already on a feature branch** (not the default branch):
   - Continue working on it. Proceed to step 3.

   **If on the default branch:**

   **Option A: Create a new branch (default)**
   ```bash
   git pull origin $default_branch
   git checkout -b <branch-name-from-plan>
   ```
   Use a meaningful name derived from the plan (e.g., `feat/callaway-santanna-did`, `fix/blp-convergence`).

   **Option B: Use a worktree (for parallel estimation runs)**
   See `references/worktree-patterns.md` if the plan involves parallel workstreams or the user has multiple active branches.

   Automatically choose Option A unless the plan explicitly mentions parallel workstreams.

3. **Activate Research Environment**

   Read `compound-science.local.md` for environment configuration. Then activate:

   **Python:**
   ```bash
   # Activate virtual environment
   if [ -d ".venv" ]; then source .venv/bin/activate
   elif [ -d "venv" ]; then source venv/bin/activate
   elif command -v conda &>/dev/null; then conda activate $(basename $PWD)
   fi
   # Verify key packages
   python -c "import numpy, scipy, pandas; print('Core packages OK')"
   ```

   **R:**
   ```bash
   # Check renv status
   Rscript -e "if (file.exists('renv.lock')) renv::status()"
   ```

   **Verify data paths:**
   ```bash
   # Check that referenced data files exist
   ls data/ 2>/dev/null | head -5
   ```

4. **Create Task List**
   - Use TodoWrite to break plan into actionable tasks
   - Include dependencies between tasks
   - Prioritize based on the plan's phase structure
   - Include estimation-specific quality check tasks:
     - Convergence verification after each estimation step
     - Standard error computation and diagnostic tests
     - Robustness checks specified in the plan
   - Keep tasks specific and completable

### Phase 2: Execute

1. **Task Execution Loop**

   For each task in priority order:

   ```
   while (tasks remain):
     - Mark task as in_progress in TodoWrite
     - Read any referenced files from the plan
     - Look for similar patterns in codebase

From James-Traina/compound-science, MIT.