@codyswann/lisa 1.0.0 → 1.0.5

package/all/copy-overwrite/.claude/commands/project/reduce-max-lines.md

@@ -0,0 +1,75 @@
+---
+description: Reduce max file lines threshold and fix violations
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, TaskGet
+argument-hint: <max-lines-value>
+model: sonnet
+---
+
+# Reduce Max Lines
+
+Target threshold: $ARGUMENTS lines per file
+
+If no argument provided, prompt the user for a target.
+
+## Process
+
+### Step 0: Check Project Context
+
+Check if there's an active project for task syncing:
+
+```bash
+cat .claude-active-project 2>/dev/null
+```
+
+If a project is active, include `metadata: { "project": "<project-name>" }` in all TaskCreate calls.
+
+### Step 1: Locate Configuration
+
+Read the eslint thresholds config (`eslint.thresholds.json` or similar).
+
+### Step 2: Update Threshold
+
+Set the `maxLines` threshold to $ARGUMENTS (e.g., `"maxLines": $ARGUMENTS`).
+
+### Step 3: Identify Violations
+
+Run lint to find all files exceeding the new threshold. Note file path and current line count.
+
+If no violations, report success and exit.
+
+### Step 4: Create Task List
+
+Create a task for each file needing refactoring, ordered by line count (highest first).
+
+Each task should have:
+- **subject**: "Reduce lines in [file]" (imperative form)
+- **description**: File path, current line count, target threshold, refactoring strategies
+- **activeForm**: "Reducing lines in [file]" (present continuous)
+- **metadata**: `{ "project": "<active-project>" }` if project context exists
+
+Refactoring strategies:
+- **Extract modules**: Break file into smaller focused modules
+- **Remove duplication**: Consolidate repeated logic
+- **Delete dead code**: Remove unused functions/code paths
+- **Simplify logic**: Use early returns, reduce nesting
+
+### Step 5: Parallel Execution
+
+Launch **up to 5 sub-agents** using the `code-simplifier` subagent to refactor in parallel.
+
+### Step 6: Iterate
+
+Check for remaining pending tasks. Re-run lint to verify.
+
+If violations remain, repeat from Step 3.
+
+Continue until all files meet or are under $ARGUMENTS lines.
+
+### Step 7: Report
+
+```
+Max lines reduction complete:
+- Target threshold: $ARGUMENTS
+- Files refactored: [count]
+- Files reduced: [list with line counts]
+```

package/all/copy-overwrite/.claude/commands/project/research.md

@@ -1,248 +1,146 @@
 ---
 description: Conducts research of your code base and the web relevant to your project and compiles it for the planning phase
 argument-hint: <project-directory>
+allowed-tools: Read, Write, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, WebSearch, WebFetch
 ---
 
 # Research Codebase
 
-You are tasked with conducting comprehensive research across the codebase and web that will help create an implementation plan for the brief in $ARGUMENTS
+Conduct comprehensive research across the codebase and web to help create an implementation plan for the brief in $ARGUMENTS.
 
-Goals:
+## Goals
 
-1. Determine what existing documentation in the codebase will be needed to fulfill the spec
-2. Determine any gaps in the spec that would prevent a developer from fulfilling the acceptance criteria
-3. Determine any potential pitfalls that should be considered such as performance or security concerns
-4. Determine what code, functions, and modules currently exist within the codebase that could be reused during implementation
-5. Determine testing patterns and locations in the codebase (frameworks, conventions, examples to follow)
-6. Determine documentation patterns in the codebase (JSDoc conventions, DB comment conventions, GraphQL description conventions)
+1. Determine what existing documentation in the codebase will be needed
+2. Determine any gaps in the spec that would prevent fulfilling acceptance criteria
+3. Determine potential pitfalls (performance, security concerns)
+4. Determine reusable code, functions, and modules in the codebase
+5. Determine testing patterns and locations (frameworks, conventions, examples)
+6. Determine documentation patterns (JSDoc, DB comments, GraphQL descriptions)
 
-Note: Task-specific concerns (acceptance criteria, specific tests to write, specific documentation to create) are determined during the Planning phase on a per-task basis.
+## Critical Rule
 
-## Step 0: MANDATORY SETUP
+**YOUR ONLY JOB IS TO DOCUMENT AND EXPLAIN THE CODEBASE AS IT EXISTS TODAY**
 
-Create workflow tracking todos:
-- Step 1: Read mentioned files
-- Step 2: Analyze and decompose
-- Step 3: Spawn research agents
-- Step 4: Wait and synthesize
-- Step 5: Generate document
-- Step 6: Commit
+- DO NOT suggest improvements or changes
+- DO NOT perform root cause analysis
+- DO NOT propose future enhancements
+- DO NOT critique or identify problems
+- ONLY describe what exists, where it exists, how it works, and how components interact
 
-⚠️ **CRITICAL**: DO NOT STOP until all 6 todos are marked completed.
+## Workflow Tasks
 
-## CRITICAL: YOUR ONLY JOB IS TO DOCUMENT AND EXPLAIN THE CODEBASE AS IT EXISTS TODAY
+Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "research" }`:
 
-- DO NOT suggest improvements or changes unless the user explicitly asks for them
-- DO NOT perform root cause analysis unless the user explicitly asks for them
-- DO NOT propose future enhancements unless the user explicitly asks for them
-- DO NOT critique the implementation or identify problems
-- DO NOT recommend refactoring, optimization, or architectural changes
-- ONLY describe what exists, where it exists, how it works, and how components interact
-- You are creating a technical map/documentation of the existing system
+1. Read mentioned files
+2. Analyze and decompose
+3. Spawn research agents
+4. Wait and synthesize
+5. Generate document
+6. Commit
 
 ## Step 1: Read Mentioned Files
-Mark "Step 1: Read mentioned files" as in_progress.
 
-**Read any directly mentioned files first:**
-- If the user mentions specific files (tickets, docs, JSON), read them FULLY first
-- **IMPORTANT**: Use the Read tool WITHOUT limit/offset parameters to read entire files
-- **CRITICAL**: Read these files yourself in the main context before spawning any sub-tasks
-- This ensures you have full context before decomposing the research
-
-Mark "Step 1: Read mentioned files" as completed. Proceed to Step 2.
+Read any directly mentioned files FULLY first (no limit/offset). This ensures full context before spawning sub-tasks.
 
 ## Step 2: Analyze and Decompose
-Mark "Step 2: Analyze and decompose" as in_progress.
 
-**Analyze and decompose the research question:**
 - Break down the brief into composable research areas
-- Take time to ultrathink about the underlying patterns, connections, and architectural implications
 - Identify specific components, patterns, or concepts to investigate
-- Create a research plan using TodoWrite to track all subtasks
 - Consider which directories, files, or architectural patterns are relevant
 
-Mark "Step 2: Analyze and decompose" as completed. Proceed to Step 3.
-
 ## Step 3: Spawn Research Agents
-Mark "Step 3: Spawn research agents" as in_progress.
 
-**Spawn parallel sub-agent tasks for comprehensive research:**
-- Create multiple Task agents to research different aspects concurrently
-- We now have specialized agents that know how to do specific research tasks:
+Spawn parallel sub-agent tasks for comprehensive research:
 
 **For codebase research:**
-- Use the **codebase-locator** agent to find WHERE files and components live
-- Use the **codebase-analyzer** agent to understand HOW specific code works (without critiquing it)
-- Use the **codebase-pattern-finder** agent to find examples of existing patterns (without evaluating them)
-- Use the **git-history-analyzer** agent to understand what changes the file has undergone that may affect the implementation plan
+- **codebase-locator**: Find WHERE files and components live
+- **codebase-analyzer**: Understand HOW specific code works
+- **codebase-pattern-finder**: Find examples of existing patterns
+- **git-history-analyzer**: Understand file change history
 
 **For e2e test research:**
-- Use the **codebase-locator** agent to find existing e2e tests in `e2e/` or `tests/` directories that relate to the feature being modified
-- Use the **codebase-analyzer** agent to document what scenarios each relevant test covers
-- Identify tests that will need modification due to UI/flow changes
-- Identify tests that may need to be removed if features are deprecated
-- Identify gaps where new tests will be needed for new functionality
-- Document the test file paths and what each test validates
-
-**IMPORTANT**: All agents are documentarians, not critics. They will describe what exists without suggesting improvements or identifying issues.
+- Find existing e2e tests in `e2e/` or `tests/` directories
+- Document what scenarios each test covers
+- Identify tests needing modification or gaps for new functionality
 
 **For web research:**
-- Use the **web-search-researcher** agent for external documentation and resources
-- IF you use web-research agents, instruct them to return LINKS with their findings, and please INCLUDE those links in your final report
-
-The key is to use these agents intelligently:
-- Start with locator agents to find what exists
-- Then use analyzer agents on the most promising findings to document how they work
-- Run multiple agents in parallel when they're searching for different things
-- Each agent knows its job - just tell it what you're looking for
-- Don't write detailed prompts about HOW to search - the agents already know
-- Remind agents they are documenting, not evaluating or improving
+- **web-search-researcher**: External documentation and resources
+- Include LINKS with findings in the final report
 
-Mark "Step 3: Spawn research agents" as completed. Proceed to Step 4.
+Run multiple agents in parallel when searching for different things.
 
 ## Step 4: Wait and Synthesize
-Mark "Step 4: Wait and synthesize" as in_progress.
 
-**Wait for all sub-agents to complete and synthesize findings:**
-- ⚠️ **CRITICAL**: Wait for ALL sub-agent tasks to complete before proceeding
-- DO NOT proceed to Step 5 until every spawned Task has returned
-- Compile all sub-agent results (both codebase and thoughts findings)
+**CRITICAL**: Wait for ALL sub-agent tasks to complete before proceeding.
+
+- Compile all sub-agent results
 - Prioritize live codebase findings as primary source of truth
 - Connect findings across different components
-- Include specific file paths and line numbers for reference
-- Highlight patterns, connections, and architectural decisions
-- Include any frameworks used such as Ruby on Rails, NestJs, Expo, React, React Native, Vue, etc
-- If a framework is used, identify what portions of the framework are relevant to the given project (i.e. ActiveRecord, NestJs Service's, dependency injection, etc)
-
-Mark "Step 4: Wait and synthesize" as completed. Proceed to Step 5.
+- Include specific file paths and line numbers
+- Note any frameworks used (Rails, NestJS, Expo, React, etc.)
 
 ## Step 5: Generate Document
-Mark "Step 5: Generate document" as in_progress.
-
-**Generate research document:**
-- Structure the document with YAML frontmatter followed by content:
-
-  ```markdown
-  ---
-  date: [Current date and time with timezone in ISO format]
-  status: complete
-  last_updated: [Current date in YYYY-MM-DD format]
-  ---
-
-  # Research
-
-  ## Summary
-
-  [High-level documentation of what was found]
 
-  ## Detailed Findings
+Create `$ARGUMENTS/research.md` with this structure:
 
-  ### [Component/Area 1]
-
-  - Description of what exists ([file.ext:line](link))
-  - How it connects to other components
-  - Current implementation details (without evaluation)
-
-  ### [Component/Area 2]
-
-  ...
-
-  ## Code References
-
-  - `path/to/file.py:123` - Description of what's there
-  - `another/file.ts:45-67` - Description of the code block
-
-  ## Architecture Documentation
-
-  [Current patterns, conventions, and design implementations found in the codebase]
-
-  ## Testing Patterns
-
-  ### Unit Test Patterns
-  - **Location**: `src/**/__tests__/*.test.ts` (or actual pattern found)
-  - **Framework**: Jest/Vitest/etc.
-  - **Example to follow**: `path/to/example.test.ts:line-range`
-  - **Conventions**: [Describe naming, structure, mock patterns]
-
-  ### Integration Test Patterns
-  - **Location**: `src/**/*.integration.test.ts` (or actual pattern found)
-  - **Example to follow**: `path/to/example.integration.test.ts`
-  - **Conventions**: [Describe setup, teardown, database handling]
+```markdown
+---
+date: [ISO format with timezone]
+status: complete
+last_updated: [YYYY-MM-DD]
+---
 
-  ### E2E Test Patterns
-  - **Location**: `e2e/*.spec.ts` (or actual pattern found)
-  - **Framework**: Playwright/Cypress/Maestro/etc.
-  - **Example to follow**: `path/to/example.spec.ts`
-  - **Conventions**: [Describe page objects, fixtures, assertions]
+# Research
 
-  ## Documentation Patterns
+## Summary
+[High-level documentation of findings]
 
-  ### JSDoc Conventions
-  - **Style**: [Describe the JSDoc style used in this codebase]
-  - **Example**: `path/to/well-documented-file.ts:line-range`
-  - **Required tags**: [@param, @returns, @throws, etc.]
+## Detailed Findings
+### [Component/Area]
+- Description of what exists ([file.ext:line](link))
+- How it connects to other components
 
-  ### Database Comments (Backend Only)
-  - **Convention**: [How tables/columns are documented]
-  - **Example**: `path/to/entity.ts` or migration file
-  - **Required for**: [New tables, new columns, complex relationships]
+## Code References
+- `path/to/file.py:123` - Description
 
-  ### GraphQL Descriptions (Backend Only)
-  - **Convention**: [How types/fields are documented]
-  - **Example**: `path/to/resolver.ts` or schema file
-  - **Required for**: [Public API fields, complex types]
+## Architecture Documentation
+[Patterns, conventions, design implementations]
 
-  ## Open Questions
+## Testing Patterns
+### Unit Test Patterns
+- **Location**: pattern found
+- **Framework**: Jest/Vitest/etc.
+- **Example to follow**: path:line-range
+- **Conventions**: naming, structure, mocks
 
-  <!--
-  Structure each question with context and impact.
-  The Answer field must be filled by a human before planning can proceed.
-  -->
+### Integration Test Patterns
+[Similar structure]
 
-  ### Q1: [Short Question Title]
-  **Question**: [Full question]
-  **Context**: [Why this question arose, what in the brief is unclear]
-  **Impact**: [What parts of implementation this affects]
-  **Answer**: _[Human fills this in before running /project:plan]_
+### E2E Test Patterns
+[Similar structure]
 
-  <!-- Add more questions as needed using the same format -->
-  <!-- If no questions, replace this section with: [None identified] -->
-  ```
+## Documentation Patterns
+### JSDoc Conventions
+### Database Comments (Backend)
+### GraphQL Descriptions (Backend)
 
-- Save the research document as `research.md` in the $ARGUMENTS directory
+## Open Questions
 
-Mark "Step 5: Generate document" as completed. Proceed to Step 6.
+### Q1: [Short Title]
+**Question**: [Full question]
+**Context**: [Why this arose]
+**Impact**: [What it affects]
+**Answer**: _[Human fills before /project:plan]_
+```
 
 ## Step 6: Commit
-Mark "Step 6: Commit" as in_progress.
-
-Run /git:commit
 
-Mark "Step 6: Commit" as completed.
+Run `/git:commit`
 
-## Important notes:
+## Important Notes
 
-- Always use parallel Task agents to maximize efficiency and minimize context usage
-- Always run fresh codebase research - never rely solely on existing research documents
-- Focus on finding concrete file paths and line numbers for developer reference
-- Research documents should be self-contained with all necessary context
-- Each sub-agent prompt should be specific and focused on read-only documentation operations
-- Document cross-component connections and how systems interact
-- Include temporal context (when the research was conducted)
-- Keep the main agent focused on synthesis, not deep file reading
-- Have sub-agents document examples and usage patterns as they exist
-- **CRITICAL**: You and all sub-agents are documentarians, not evaluators
+- Always use parallel Task agents to maximize efficiency
+- Always run fresh codebase research - never rely solely on existing documents
+- Focus on finding concrete file paths and line numbers
+- Each sub-agent prompt should be specific and focused on read-only documentation
 - **REMEMBER**: Document what IS, not what SHOULD BE
-- **NO RECOMMENDATIONS**: Only describe the current state of the codebase
-- **File reading**: Always read mentioned files FULLY (no limit/offset) before spawning sub-tasks
-- **Critical ordering**: Follow the numbered steps exactly
-  - ALWAYS read mentioned files first before spawning sub-tasks (step 1)
-  - ALWAYS wait for all sub-agents to complete before synthesizing (step 4)
-  - ALWAYS gather metadata before writing the document (step 5 before step 6)
-  - NEVER write the research document with placeholder values
-- **Frontmatter consistency**:
-  - Always include frontmatter at the beginning of research documents
-  - Keep frontmatter fields consistent across all research documents
-  - Update frontmatter when adding follow-up research
-  - Use snake_case for multi-word field names (e.g., `last_updated`)
-  - Tags should be relevant to the research topic and components studied

package/all/copy-overwrite/.claude/commands/project/review.md

@@ -1,63 +1,44 @@
 ---
 description: Performs extensive code review and optimization on the current project
 argument-hint: <project-directory>
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, Skill
 ---
 
-The current branch is a feature branch that contains full implementation of the project described in $ARGUMENTS
+The current branch is a feature branch with full implementation of the project in $ARGUMENTS.
 
-IMPORTANT: Perform each step and then move to the next one without stopping
+**IMPORTANT**: Perform each step and move to the next without stopping.
 
-## Step 0: MANDATORY SETUP
+## Setup
 
-Use TodoWrite to create workflow tracking todos:
-- Step 1: Perform Claude Review
-- Step 2: Implement Claude Review Fixes
-- Step 3: Perform CodeRabbit Review
-- Step 4: Implement CodeRabbit Review Fixes
-- Step 5: Perform Claude Optimizations
+Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "review" }`:
 
-## Step 1: Perform Claude Review
-
-Mark "Step 1: Perform Claude Review" as in_progress.
+1. Perform Claude Review
+2. Implement Claude Review Fixes
+3. Perform CodeRabbit Review
+4. Implement CodeRabbit Review Fixes
+5. Perform Claude Optimizations
 
-If $ARGUMENTS/claude-review.md already exists, Mark "Step 1: Perform Claude Review" as completed. Proceed to Step 2
+## Step 1: Perform Claude Review
 
-Otherwise, run /local-code-review $ARGUMENTS
+If `$ARGUMENTS/claude-review.md` already exists, skip to Step 2.
 
-Mark "Step 1: Perform Claude Review" as completed. Proceed to Step 2
+Otherwise, run `/project:local-code-review $ARGUMENTS`
 
 ## Step 2: Implement Claude Review Fixes
 
-Mark "Step 2: Implement Claude Review Fixes" as in_progress.
-
-1. Read $ARGUMENTS/claude-review.md 
-2. Fix any suggestions that score above 45 in $ARGUMENTS/claude-review.md 
-
-Mark "Step 2: Implement Claude Review Fixes" as completed. Proceed to Step 3
+1. Read `$ARGUMENTS/claude-review.md`
+2. Fix any suggestions that score above 45
 
 ## Step 3: Perform CodeRabbit Review
 
-Mark "Step 3: Perform CodeRabbit Review" as in_progress.
-
-If $ARGUMENTS/coderabbit-review.md already exists, Mark "Step 3: Perform CodeRabbit Review" as completed. Proceed to Step 4
+If `$ARGUMENTS/coderabbit-review.md` already exists, skip to Step 4.
 
-Otherwise, use Task tool with prompt: "Run !`coderabbit review --plain || true` to get comprehensive code analysis and improvement suggestions and write the results to $ARGUMENTS/coderabbit-review.md"
-
-Mark "Step 3: Perform CodeRabbit Review" as completed. Proceed to Step 4
+Otherwise, use Task tool with prompt: "Run `coderabbit review --plain || true` and write results to $ARGUMENTS/coderabbit-review.md"
 
 ## Step 4: Implement CodeRabbit Review Fixes
 
-Mark "Step 4: Implement CodeRabbit Review Fixes" as in_progress.
-
-Evaluate the suggestions in $ARGUMENTS/coderabbit-review.md and implement fixes/changes for any valid findings
-
-Mark "Step 4: Implement CodeRabbit Review Fixes" as completed. Proceed to Step 5
+Evaluate suggestions in `$ARGUMENTS/coderabbit-review.md` and implement fixes for valid findings.
 
 ## Step 5: Perform Claude Optimizations
 
-Mark "Step 5: Perform Claude Optimizations" as in_progress.
-
-Use the code simplifier agent to clean up the code that was added to the current branch.
-
-Mark "Step 5: Perform Claude Optimizations" as completed. 
-
+Use the code simplifier agent to clean up code added to the current branch.

package/all/copy-overwrite/.claude/commands/project/setup.md

@@ -1,7 +1,7 @@
 ---
 description: Initialize a comprehensive NestJS backend project with full requirements analysis, planning, and structure setup
 argument-hint: <project-brief-file-or-jira-issue-number>
-allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TodoWrite
+allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList
 ---
 
 1. Decide if $ARGUMENTS is a Jira issue number or a path to a file

package/all/copy-overwrite/.claude/commands/project/verify.md

@@ -1,38 +1,75 @@
 ---
 description: Comprehensive verification that a feature branch fully implements all project requirements with proper code quality, tests, and documentation
 argument-hint: <project-directory>
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList
 ---
 
-The current branch is a feature branch that contains full implementation of the project described in $ARGUMENTS
+The current branch is a feature branch with full implementation of the project in $ARGUMENTS.
 
-## Step 0: MANDATORY SETUP
+## Setup
 
-Use TodoWrite to create workflow tracking todos:
-- Step 1: Review Requirements for $ARGUMENTS
-- Step 2: Verify Implementation
-- Step 3: Document Drift
+Create workflow tracking tasks with `metadata: { "project": "<project-name>", "phase": "verify" }`:
 
-## Step 1: Review Requirements
-
-Mark "Step 1: Review Requirements" as in_progress.
+1. Review Requirements
+2. Verify Implementation
+3. Run Task Verification Commands
+4. Document Drift
 
-Read all the requirements for $ARGUMENTS
+## Step 1: Review Requirements
 
-Mark "Step 1: Review Requirements" as completed. Proceed to Step 2
+Read all requirements for $ARGUMENTS.
 
 ## Step 2: Verify Implementation
 
-Mark "Step 2: Verify Implementation" as in_progress.
-
-Verify that the implementation completely and fully satisfies all the requirements from Step 1
-
-Mark "Step 2: Verify Implementation" as completed. Proceed to Step 3
-
-
-## Step 3: Document Drift
-
-Mark "Step 3: Document Drift" as in_progress.
-
-IF there is any divergence from the requirements, document what this drift is to $ARGUMENTS/drift.md
-
-Mark "Step 3: Document Drift" as completed. 
+Verify the implementation completely and fully satisfies all requirements from Step 1.
+
+## Step 3: Run Task Verification Commands
+
+### 3a: Create Verification Tasks
+
+First, read all task files in `$ARGUMENTS/tasks/` and create a new task for each one that has verification metadata:
+
+For each task file:
+1. **Read the task file** (JSON or markdown)
+2. **Check for verification metadata**:
+   - JSON tasks: Look for `metadata.verification`
+   - Markdown tasks: Look for `## Verification` section with `### Proof Command`
+3. **If verification exists**, create a new task:
+   ```
+   subject: "Verify: <original-task-subject>"
+   description: "Run verification for task <id>: <verification.command>"
+   activeForm: "Verifying <original-task-subject>"
+   metadata: {
+     "project": "<project-name>",
+     "phase": "verify",
+     "originalTaskId": "<id>",
+     "verification": <copy the verification object>
+   }
+   ```
+
+### 3b: Execute Verification Tasks
+
+Work through each verification task:
+
+1. **Run verification command** using Bash tool:
+   - JSON: Execute `metadata.verification.command`
+   - Markdown: Execute the command in `### Proof Command` code block
+2. **Compare output to expected**:
+   - JSON: Compare to `metadata.verification.expected`
+   - Markdown: Compare to `### Expected Output` section
+3. **Record results and mark task**:
+   - If verification passes → Mark task completed
+   - If verification fails → Keep task in_progress, document failure in drift.md
+   - If command cannot run → Keep task in_progress, document blocker in drift.md
+
+### Verification Summary
+
+After running all verification tasks, report:
+- Total tasks with verification: X
+- Passed: Y
+- Failed: Z
+- Blocked: W
+
+## Step 4: Document Drift
+
+If there is any divergence from the requirements or verification failures, document the drift to `$ARGUMENTS/drift.md`.

package/all/copy-overwrite/.claude/commands/pull-request/review.md

@@ -1,12 +1,30 @@
 ---
 description: Checks for code review comments on a PR and implements them if required.
 argument-hint: <github-pr-link>
-allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TodoWrite. Bash(gh*)
+allowed-tools: Read, Write, Edit, Bash(git*), Glob, Grep, Task, TaskCreate, TaskUpdate, TaskList, TaskGet, Bash(gh*)
 ---
 
-1. Use the github cli to find all the code review comments on $ARGUMENTS
-2. Create a task list for each unresolved code review comment
-3. Review the code reviews one by one and determine if they are correct and should be implemented
-4. The ones that aren't valid or you're not implementing, use the github cli to comment why you're not and resolve the code review comment
-5. For the rest, implement the changes and then use the github cli to mark the comment why it's resolved.
-6. Once all the code review comments have been resolved, run /git:commit
+Use the GitHub CLI to fetch all review comments on $ARGUMENTS:
+
+```bash
+gh pr view $ARGUMENTS --json reviews,comments
+gh api repos/{owner}/{repo}/pulls/{pr_number}/comments
+```
+
+Extract each unresolved review comment as a separate item. Note the comment ID, file path, line number, and comment body.
+
+Create a task for each unresolved comment with `metadata: { "pr": "$ARGUMENTS" }`:
+- **subject**: Brief description of the requested change
+- **description**: Full comment body, file path, line number, comment ID, and these instructions:
+  1. Evaluate if the requested change is valid
+  2. If not valid, reply explaining why and mark resolved, skip remaining steps
+  3. If valid, make appropriate code updates
+  4. Ensure changes follow project coding standards
+  5. Run relevant tests to verify changes work
+  6. Run `/git:commit` to commit changes
+  7. If hooks fail, fix errors and re-run `/git:commit`
+- **activeForm**: "Implementing PR feedback for [file]"
+
+Launch up to 6 subagents to work through the task list in parallel.
+
+When all tasks are completed, run `/git:commit-and-submit-pr`.