@codyswann/lisa 1.0.0

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

@@ -0,0 +1,49 @@
+---
+description: Automated project setup and research with gap detection
+argument-hint: <project-brief-file-or-jira-issue-number>
+---
+
+Complete all of the following steps for $ARGUMENTS:
+
+## Step 0: MANDATORY SETUP
+
+Create workflow tracking todos:
+- Step 1: Setup
+- Step 2: Research
+- Step 3: Gap Detection
+
+⚠️ **CRITICAL**: DO NOT STOP until all 3 todos are marked completed.
+
+## Step 1: Setup
+Mark "Step 1: Setup" as in_progress.
+
+Use Task tool with prompt: "run /project:setup $ARGUMENTS"
+- Creates project directory, brief.md, findings.md, git branch
+
+Mark "Step 1: Setup" as completed. Proceed to Step 2.
+
+## Step 2: Research
+Mark "Step 2: Research" as in_progress.
+
+Use Task tool with prompt: "run /project:research [project-dir]" where [project-dir] is the directory created in Step 1
+- Generates research.md with findings
+
+Mark "Step 2: Research" as completed. Proceed to Step 3.
+
+## Step 3: Gap Detection
+Mark "Step 3: Gap Detection" as in_progress.
+
+Read the generated research.md file:
+- Locate "## Open Questions" section
+- Check if it contains actual unresolved questions (not just template/empty)
+- If gaps exist:
+  ❌ STOP and report: "Research complete but has open questions. Review $PROJECT/research.md and resolve questions before running /project:execute"
+- If no gaps:
+  ✅ Report: "Bootstrap complete. Research has no gaps. Ready to run /project:execute @projects/$PROJECT"
+
+Mark "Step 3: Gap Detection" as completed.
+
+## Output to Human
+
+- "✅ Bootstrap complete with no gaps - ready for execution" OR
+- "⚠️ Bootstrap complete but needs human review - see Open Questions in research.md"

package/all/copy-overwrite/.claude/commands/project/complete-task.md

@@ -0,0 +1,7 @@
+---
+description: Complete a single task within a project using a subagent with fresh context
+argument-hint: <task-file>
+---
+
+1. Read $ARGUMENTS without offset or limit
+2. Follow the instructions literally and specifically

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

@@ -0,0 +1,65 @@
+---
+description: Evaluates findings.md and uses skill-evaluator to decide where each learning belongs (new skill, PROJECT_RULES.md, or omit)
+argument-hint: <project-directory>
+---
+
+## Step 0: MANDATORY SETUP
+
+Use TodoWrite to create workflow tracking todos:
+- Step 1: Read project findings
+- Step 2: Evaluate each finding
+- Step 3: Apply decisions
+
+⚠️ **CRITICAL**: DO NOT STOP until all 3 todos are marked completed.
+
+## Step 1: Read Project Findings
+Mark "Step 1: Read project findings" as in_progress.
+
+Read the `findings.md` file inside $ARGUMENTS FULLY (no limit/offset).
+
+Extract each distinct finding/learning as a separate item.
+
+Mark "Step 1: Read project findings" as completed. Proceed to Step 2.
+
+## Step 2: Evaluate Each Finding
+Mark "Step 2: Evaluate each finding" as in_progress.
+
+For each finding extracted from findings.md:
+
+Use the Task tool with `subagent_type: "skill-evaluator"` to evaluate where (and if) the finding should be recorded:
+
+```
+Evaluate this finding from a project debrief:
+
+"[FINDING TEXT]"
+
+Determine if this should be:
+1. CREATE SKILL - if it's a complex, reusable pattern
+2. ADD TO RULES - if it's a simple never/always rule for PROJECT_RULES.md
+3. OMIT ENTIRELY - if it's already covered or too project-specific
+```
+
+Collect all decisions from the skill-evaluator.
+
+Mark "Step 2: Evaluate each finding" as completed. Proceed to Step 3.
+
+## Step 3: Apply Decisions
+Mark "Step 3: Apply decisions" as in_progress.
+
+For each finding based on skill-evaluator's decision:
+
+| Decision | Action |
+|----------|--------|
+| CREATE SKILL | Use Task tool: "run /skill-creator with [finding details]" |
+| ADD TO RULES | Add the rule succinctly to @PROJECT_RULES.md |
+| OMIT ENTIRELY | No action needed |
+
+Mark "Step 3: Apply decisions" as completed.
+
+Report summary:
+```
+📝 Debrief complete:
+- Skills created: [X]
+- Rules added: [Y]
+- Omitted (redundant/narrow): [Z]
+```

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

@@ -0,0 +1,94 @@
+---
+description: Automated project execution from planning through debrief (requires gap-free research)
+argument-hint: <project-directory>
+---
+
+Execute complete implementation workflow for $ARGUMENTS:
+
+## Step 0: MANDATORY SETUP
+
+### Gap Check
+Read $ARGUMENTS/research.md and locate "## Open Questions" section.
+- If gaps exist: ❌ STOP immediately with "Cannot proceed - research.md has unresolved open questions."
+- If no gaps: ✅ Proceed with setup
+
+### Planning Already Complete Check
+Check if planning has already been done:
+1. Check if `$ARGUMENTS/progress.md` exists
+2. Check if `$ARGUMENTS/tasks/` directory exists with task files (task-*.md)
+
+- If BOTH exist: ✅ Planning already complete - skip to "Create Workflow Tracking (Resume Mode)"
+- If either is missing: ✅ Proceed with full workflow
+
+### Create Workflow Tracking (Full Mode)
+Use TodoWrite to create these workflow todos:
+- Step 1: Planning
+- Step 2: Implementation
+- Step 3: Verification
+- Step 4: Debrief
+- Step 5: Archive
+
+⚠️ **CRITICAL**: DO NOT STOP until all 5 todos are marked completed.
+
+Proceed to Step 1.
+
+### Create Workflow Tracking (Resume Mode)
+Use TodoWrite to create these workflow todos (marking Step 1 as already completed):
+- Step 1: Planning ✓ (mark as completed immediately)
+- Step 2: Implementation
+- Step 3: Review
+- Step 4: Verification
+- Step 5: Debrief
+- Step 6: Archive
+
+Report: "📋 Resuming execution - planning already complete with existing progress.md and tasks/"
+
+⚠️ **CRITICAL**: DO NOT STOP until all 5 todos are marked completed.
+
+Skip directly to Step 2.
+
+## Step 1: Planning
+⚠️ **CRITICAL**: DO NOT STOP use the Plan tool to do this. Use Task tool with prompt: "run /project:plan $ARGUMENTS" as directed below
+
+Mark "Step 1: Planning" as in_progress.
+
+Use Task tool with prompt: "run /project:plan $ARGUMENTS"
+
+Mark "Step 1: Planning" as completed. Proceed to Step 2.
+
+## Step 2: Implementation Loop
+Mark "Step 2: Implementation" as in_progress.
+
+Use Task tool with prompt: "run /project:implement $ARGUMENTS"
+
+Mark "Step 2: Implementation" as completed. Proceed to Step 3.
+
+## Step 3: Review
+Mark "Step 3: Review" as in_progress.
+
+run /project:review $ARGUMENTS
+
+Mark "Step 3: Review" as completed. Proceed to Step 4.
+
+## Step 4: Verification
+Mark "Step 4: Verification" as in_progress.
+
+Use Task tool with prompt: "run /project:verify $ARGUMENTS"
+
+Mark "Step 4: Verification" as completed. Proceed to Step 5.
+
+## Step 5: Debrief
+Mark "Step 5: Debrief" as in_progress.
+
+Use Task tool with prompt: "run /project:debrief $ARGUMENTS"
+
+Mark "Step 5: Debrief" as completed. Proceed to Step 6.
+
+## Step 6: Archive
+Mark "Step 6: Archive" as in_progress.
+
+Use Task tool with prompt: "run /project:archive $ARGUMENTS"
+
+Mark "Step 6: Archive" as completed.
+
+Report: "🎉 Project complete and archived"

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

@@ -0,0 +1,42 @@
+---
+description: Systematically implements all tasks in a specified project
+argument-hint: <project-directory>
+---
+
+### Get Task State
+
+Read $ARGUMENTS/progress.md
+
+If the file does not exist or is empty, report an error: "Error: $ARGUMENTS/progress.md not found or empty. Run /project:plan first to create the task list."
+
+If the file contains no task items (checkbox items), report an error: "Error: No tasks found in $ARGUMENTS/progress.md. The file should contain markdown checklist items."
+
+Count tasks: total=X, completed=Y, remaining=X-Y
+
+### Create Workflow Tracking for all tasks
+Use TodoWrite to create workflow todos for each task using the following format:
+- Step <task-number>: <task-name>
+
+### Sync with progress file
+
+If any of the tasks are marked as completed in $ARGUMENTS/progress.md, mark them as completed in the Workflow Tracking
+
+If any of the tasks are marked as in_progress in $ARGUMENTS/progress.md, mark them as in_progress in the Workflow Tracking
+
+### Complete the outstanding Workflow items
+
+Work on the non-completed tasks in sequence
+
+⚠️ **CRITICAL**: DO NOT STOP until all todos are marked completed.
+
+For each non-completed task:
+
+1. mark the task as in_progress in $ARGUMENTS/progress.md
+2. mark the task as in_progress in Workflow Tracking
+3. Use Task tool with subagent_type "general-purpose" and prompt: "run /project:complete-task <task-markdown-file>"
+4. Wait for the subagent to finish the task
+5. After subagent finishes with the task, mark the task as completed in $ARGUMENTS/progress.md
+6. After subagent finishes with the task, mark the task as completed in Workflow Tracking
+7. CRITICAL. DO NOT STOP. Move on to the next non-completed task
+
+Repeat until all tasks are marked completed

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

@@ -0,0 +1,88 @@
+---
+description: Code review local changes on the current branch
+disable-model-invocation: false
+argument-hint: <project-directory>
+---
+
+Provide a code review for the local changes on the current branch compared to the main branch.
+
+To do this, follow these steps precisely:
+
+1. Use a Haiku agent to check the current git state:
+   - Run `git branch --show-current` to get the current branch name
+   - Run `git log main..HEAD --oneline` to see commits on this branch
+   - Run `git diff main...HEAD --stat` to see changed files
+   - If the current branch IS main, or there are no commits/changes compared to main, do not proceed.
+2. Use another Haiku agent to give you a list of file paths to (but not the contents of) any relevant CLAUDE.md files from the codebase: the root CLAUDE.md file (if one exists), as well as any CLAUDE.md files in the directories whose files were modified on this branch
+3. Use a Haiku agent to analyze the branch changes:
+   - Run `git log main..HEAD --format="%s%n%b"` to get commit messages
+   - Run `git diff main...HEAD` to get the full diff
+   - Return a summary of the changes
+4. Then, launch 5 parallel Sonnet agents to independently code review the change. The agents should do the following, then return a list of issues and the reason each issue was flagged (eg. CLAUDE.md adherence, bug, historical git context, etc.):
+   a. Agent #1: Audit the changes to make sure they comply with the CLAUDE.md. Note that CLAUDE.md is guidance for Claude as it writes code, so not all instructions will be applicable during code review.
+   b. Agent #2: Read the file changes (via `git diff main...HEAD`), then do a shallow scan for obvious bugs. Avoid reading extra context beyond the changes, focusing just on the changes themselves. Focus on large bugs, and avoid small issues and nitpicks. Ignore likely false positives.
+   c. Agent #3: Read the git blame and history of the code modified, to identify any bugs in light of that historical context
+   d. Agent #4: Read previous pull requests that touched these files, and check for any comments on those pull requests that may also apply to the current changes.
+   e. Agent #5: Read code comments in the modified files, and make sure the changes comply with any guidance in the comments.
+5. For each issue found in #4, launch a parallel Haiku agent that takes the diff, issue description, and list of CLAUDE.md files (from step 2), and returns a score to indicate the agent's level of confidence for whether the issue is real or false positive. To do that, the agent should score each issue on a scale from 0-100, indicating its level of confidence. For issues that were flagged due to CLAUDE.md instructions, the agent should double check that the CLAUDE.md actually calls out that issue specifically. The scale is (give this rubric to the agent verbatim):
+   a. 0: Not confident at all. This is a false positive that doesn't stand up to light scrutiny, or is a pre-existing issue.
+   b. 25: Somewhat confident. This might be a real issue, but may also be a false positive. The agent wasn't able to verify that it's a real issue. If the issue is stylistic, it is one that was not explicitly called out in the relevant CLAUDE.md.
+   c. 50: Moderately confident. The agent was able to verify this is a real issue, but it might be a nitpick or not happen very often in practice. Relative to the rest of the changes, it's not very important.
+   d. 75: Highly confident. The agent double checked the issue, and verified that it is very likely it is a real issue that will be hit in practice. The existing approach is insufficient. The issue is very important and will directly impact the code's functionality, or it is an issue that is directly mentioned in the relevant CLAUDE.md.
+   e. 100: Absolutely certain. The agent double checked the issue, and confirmed that it is definitely a real issue, that will happen frequently in practice. The evidence directly confirms this.
+6. Filter out any issues with a score less than 80.
+7. Write the review to $ARGUMENTS/claude-review.md. When writing your review, keep in mind to:
+   a. Keep your output brief
+   b. Avoid emojis
+   c. Reference relevant files and line numbers
+8. Briefly summarize $ARGUMENTS/claude-review.md as direct output to the user
+
+Examples of false positives, for steps 4 and 5:
+
+- Pre-existing issues
+- Something that looks like a bug but is not actually a bug
+- Pedantic nitpicks that a senior engineer wouldn't call out
+- Issues that a linter, typechecker, or compiler would catch (eg. missing or incorrect imports, type errors, broken tests, formatting issues, pedantic style issues like newlines). No need to run these build steps yourself -- it is safe to assume that they will be run separately as part of CI.
+- General code quality issues (eg. lack of test coverage, general security issues, poor documentation), unless explicitly required in CLAUDE.md
+- Issues that are called out in CLAUDE.md, but explicitly silenced in the code (eg. due to a lint ignore comment)
+- Changes in functionality that are likely intentional or are directly related to the broader change
+- Real issues, but on lines that were not modified in the current branch
+
+Notes:
+
+- Do not check build signal or attempt to build or typecheck the app. These will run separately, and are not relevant to your code review.
+- Use git commands to analyze local changes (not `gh` commands for remote PRs)
+- Make a todo list first
+- You must cite each bug with file path and line number (eg. if referring to a CLAUDE.md, you must reference it)
+- For your final output, follow the following format precisely (assuming for this example that you found 3 issues):
+
+---
+
+### Code review for branch `<branch-name>`
+
+Reviewed X commits with changes to Y files.
+
+Found 3 issues:
+
+1. **<brief description of bug>** (CLAUDE.md says "<...>")
+   - File: `path/to/file.ts:L10-L15`
+
+2. **<brief description of bug>** (some/other/CLAUDE.md says "<...>")
+   - File: `path/to/other-file.ts:L25-L30`
+
+3. **<brief description of bug>** (bug due to <reasoning>)
+   - File: `path/to/another-file.ts:L5-L8`
+
+---
+
+- Or, if you found no issues:
+
+---
+
+### Code review for branch `<branch-name>`
+
+Reviewed X commits with changes to Y files.
+
+No issues found. Checked for bugs and CLAUDE.md compliance.
+
+---

package/all/copy-overwrite/.claude/commands/project/lower-code-complexity.md

@@ -0,0 +1,74 @@
+---
+description: Reduces the code complexity of the codebase by 2 on each run
+allowed-tools: Read, Write, Bash(git*), Glob, Grep, Task, TodoWrite
+---
+
+## Step 0: MANDATORY SETUP
+
+Create workflow tracking todos:
+- Step 1: Lower complexity threshold
+- Step 2: Run lint
+- Step 3: Save spec file
+- Step 4: Bootstrap project
+- Step 5: Resolve questions
+- Step 6: Execute project
+
+⚠️ **CRITICAL**: DO NOT STOP until all 7 todos are marked completed.
+
+## Step 1: Lower Complexity Threshold
+Mark "Step 1: Lower complexity threshold" as in_progress.
+
+In @eslint.config.mjs, lower the active cognitive complexity rule by two.
+Save the file.
+
+Mark "Step 1: Lower complexity threshold" as completed. Proceed to Step 2.
+
+## Step 2: Run Lint
+Mark "Step 2: Run lint" as in_progress.
+
+Run the lint command from @package.json.
+
+Mark "Step 2: Run lint" as completed. Proceed to Step 3.
+
+## Step 3: Save Spec File
+Mark "Step 3: Save spec file" as in_progress.
+
+Save the output of the lint command to `specs/reduce-cognitive-complexity.md` along with the following instructions:
+
+```text
+
+Refactor the <files> to adhere to the cognitive complexity rule.
+
+Common Solutions
+
+1. Extract functions: Break complex logic into smaller, named functions
+2. Early returns: Reduce nesting with guard clauses
+3. Extract conditions: Move complex boolean logic into named variables
+4. Use lookup tables: Replace complex switch/if-else chains
+5. Break larger components into smaller components with their own View/Container pattern
+```
+
+Mark "Step 3: Save spec file" as completed. Proceed to Step 4.
+
+## Step 4: Bootstrap Project
+Mark "Step 4: Bootstrap project" as in_progress.
+
+Run /project:bootstrap @specs/reduce-cognitive-complexity.md
+
+Mark "Step 4: Bootstrap project" as completed. Proceed to Step 5.
+
+## Step 5: Resolve Questions
+Mark "Step 5: Resolve questions" as in_progress.
+
+Answer any unresolved questions in the new project's `research.md` file.
+
+Mark "Step 5: Resolve questions" as completed. Proceed to Step 6.
+
+## Step 6: Execute Project
+Mark "Step 6: Execute project" as in_progress.
+
+Run /project:execute [project-dir] where [project-dir] is the directory created from Step 4.
+
+Mark "Step 6: Execute project" as completed.
+
+Report: "🎉 Code complexity reduction complete"