@codyswann/lisa 1.12.9 → 1.14.0

package/all/copy-overwrite/.claude/skills/git-commit-and-submit-pr/SKILL.md

@@ -0,0 +1,9 @@
+---
+name: git-commit-and-submit-pr
+description: This skill should be used when creating conventional commits for current changes and then submitting the current branch as a pull request for code review. It combines the git-commit and git-submit-pr skills into a single workflow.
+allowed-tools: ["Bash"]
+argument-hint: "[commit-message-hint]"
+---
+
+1. Run /git-commit $ARGUMENTS
+2. Run /git-submit-pr $ARGUMENTS

package/all/copy-overwrite/.claude/skills/git-prune/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: git-prune
+description: This skill should be used when pruning local branches that have been deleted on the remote. It fetches remote changes, identifies stale local branches, and safely deletes them.
+allowed-tools: ["Bash"]
+---
+
+# Git Prune Local Branches
+
+Remove local branches whose upstream tracking branches have been deleted on remote.
+
+## Workflow
+
+### Fetch and prune remote-tracking references
+
+!git fetch --prune
+
+### Find and delete stale local branches
+
+!git branch -vv | grep ': gone]' | awk '{print $1}'
+
+### Apply these requirements
+
+1. **Preview**: Show which branches will be deleted before deleting
+2. **Safe Delete**: Use `-d` (safe delete) which refuses to delete unmerged branches
+3. **Report**: Show summary of deleted branches
+
+### Never
+
+- Force delete (`-D`) without user confirmation
+- Delete the current branch
+- Delete protected branches (dev, staging, main)
+
+## Execute
+
+Execute the workflow now.

package/all/copy-overwrite/.claude/skills/git-submit-pr/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: git-submit-pr
+description: This skill should be used when pushing changes and creating or updating a pull request. It verifies the branch state, pushes to remote, creates or updates a PR with a comprehensive description, and enables auto-merge.
+allowed-tools: ["Bash", "mcp__github__create_pull_request", "mcp__github__get_pull_request", "mcp__github__update_pull_request"]
+argument-hint: "[pr-title-or-description-hint]"
+---
+
+# Submit Pull Request Workflow
+
+Push current branch and create or update a pull request. Optional hint: $ARGUMENTS
+
+## Workflow
+
+### Check current state
+
+!git status
+!git log --oneline -10
+
+### Apply these requirements
+
+1. **Branch Check**: Verify not on `dev`, `staging`, or `main` (cannot create PR from protected branches)
+2. **Commit Check**: Ensure all changes are committed before pushing
+3. **Push**: Push current branch to remote with `-u` flag and the following environment variable - GIT_SSH_COMMAND="ssh -o ServerAliveInterval=30 -o ServerAliveCountMax=5"
+4. **PR Management**:
+   - Check for existing PR on this branch
+   - If exists: Update description with latest changes
+   - If not: Create PR with comprehensive description (not a draft)
+5. **Auto-merge**: Enable auto-merge on the PR using `gh pr merge --auto --merge`
+
+### PR Description Format
+
+Include in the PR description:
+
+- **Summary**: Brief overview of changes (1-3 bullet points)
+- **Test plan**: How to verify the changes work correctly
+
+### Never
+
+- use `--force` push without explicit user request
+- create PR from protected branches (dev, staging, main)
+- skip pushing before PR creation
+
+## Execute
+
+Execute the workflow now.

package/all/copy-overwrite/.claude/skills/jira-create/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: jira-create
+description: This skill should be used when creating JIRA epics, stories, and tasks from code files or descriptions. It analyzes the provided input, determines the appropriate issue hierarchy, and creates issues with comprehensive quality requirements including test-first development and documentation.
+allowed-tools: ["Read", "Glob", "LS", "mcp__atlassian__createJiraIssue", "mcp__atlassian__getVisibleJiraProjects", "mcp__atlassian__getJiraProjectIssueTypesMetadata", "mcp__atlassian__getAccessibleAtlassianResources"]
+argument-hint: "<file-or-directory-path> [project-key]"
+---
+
+# Create JIRA Issues from $ARGUMENTS
+
+Analyze the provided file(s) and create a comprehensive JIRA hierarchy with all mandatory quality gates.
+
+## Process
+
+1. **Analyze**: Read $ARGUMENTS to understand scope
+2. **Determine Structure**:
+   - Epic needed if: multiple features, major changes, >3 related files
+   - Direct tasks if: bug fix, single file, minor change
+3. **Create Issues** with hierarchy:
+   ```
+   Epic → User Story → Tasks (test, implement, document, cleanup)
+   ```
+
+## Mandatory for Every Code Issue
+
+**Test-First**: Write tests before implementation
+**Quality Gates**: All tests/checks must pass, no SonarCloud violations
+**Documentation**: Check existing, update/create new, remove obsolete
+**Feature Flags**: All features behind flags with lifecycle plan
+**Cleanup**: Remove temporary code, scripts, dev configs
+
+## Issue Requirements
+
+Each issue must clearly communicate to:
+
+- **Coding Assistants**: Implementation requirements
+- **Developers**: Technical approach
+- **Stakeholders**: Business value
+
+Default project: SE (override via arguments)
+Exclude unless requested: migration plans, performance tests
+
+Execute the analysis and create the complete JIRA structure with proper parent-child relationships.

package/all/copy-overwrite/.claude/skills/jira-verify/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: jira-verify
+description: This skill should be used when verifying that a JIRA ticket meets organizational standards for epic relationships and description quality. It checks epic parent relationships and validates description completeness for coding assistants, developers, and stakeholders.
+allowed-tools: ["mcp__atlassian__getJiraIssue", "mcp__atlassian__searchJiraIssuesUsingJql", "mcp__atlassian__getAccessibleAtlassianResources"]
+argument-hint: "<TICKET-ID>"
+---
+
+# Verify JIRA Ticket: $ARGUMENTS
+
+Fetch ticket $ARGUMENTS and verify it meets organizational standards.
+
+## Verification Checks
+
+### 1. Epic Parent Relationship
+
+**Rule**: Non-bug, non-epic tickets MUST have an epic parent
+
+- If missing: Search filter 10089 (Epic Backlog) and suggest appropriate epics
+
+### 2. Description Quality
+
+Verify description adequately addresses:
+
+**Coding Assistants**: Acceptance criteria, requirements, constraints, I/O
+**Developers**: Technical context, integration points, testing, edge cases
+**Stakeholders**: Business value, user impact, success metrics, summary
+
+## Execute Verification
+
+Retrieve ticket details, run both checks, and provide specific improvement recommendations for any failures.

package/all/copy-overwrite/.claude/skills/lisa-review-implementation/SKILL.md

@@ -0,0 +1,210 @@
+---
+name: lisa-review-implementation
+description: This skill should be used when comparing a project's Lisa-managed files against Lisa's source templates to identify drift. It reads the project manifest, locates source templates, generates diffs for drifted files, and offers to upstream improvements back to Lisa.
+argument-hint: "[lisa-dir]"
+---
+
+# Lisa Implementation Review
+
+This skill compares the current project's Lisa-managed files against Lisa's source templates to identify drift and offer to upstream improvements back to Lisa.
+
+## Prerequisites
+
+This skill requires access to the Lisa installation directory. Either:
+1. Start Claude Code with `--add-dir ~/lisa` (or your Lisa path)
+2. Pass the Lisa directory as an argument: `/lisa-review-implementation ~/lisa`
+
+## Instructions
+
+### Step 1: Locate Lisa Directory
+
+First, determine the Lisa installation directory:
+
+1. If an argument was provided, use that path
+2. Otherwise, check if any `--add-dir` paths contain a `src/core/lisa.ts` file (Lisa's signature file)
+3. Common locations to check: `~/lisa`, `~/workspace/lisa`, `../lisa`
+
+If Lisa directory cannot be found, inform the user:
+```
+Unable to locate Lisa installation directory.
+
+Please either:
+1. Start Claude Code with: claude --add-dir /path/to/lisa
+2. Run this command with the path: /lisa-review-implementation /path/to/lisa
+```
+
+### Step 2: Read the Manifest
+
+Read the project's `.lisa-manifest` file to get the list of managed files.
+
+Parse each line to extract:
+- `strategy`: The copy strategy used (copy-overwrite, copy-contents, merge, create-only)
+- `relativePath`: The file path relative to project root
+
+Skip:
+- Lines starting with `#` (comments)
+- Empty lines
+- Files with `create-only` strategy (these are meant to be customized)
+- Files with `merge` strategy (these are intentionally combined)
+
+### Step 3: Find Source Templates
+
+For each managed file, locate its source in Lisa by checking these directories in order:
+1. `npm-package/copy-overwrite/` and `npm-package/copy-contents/`
+2. `cdk/copy-overwrite/` and `cdk/copy-contents/`
+3. `nestjs/copy-overwrite/` and `nestjs/copy-contents/`
+4. `expo/copy-overwrite/` and `expo/copy-contents/`
+5. `typescript/copy-overwrite/` and `typescript/copy-contents/`
+6. `all/copy-overwrite/` and `all/copy-contents/`
+
+The FIRST match wins (most specific type takes precedence).
+
+Detect which project types apply by checking the project for:
+- `npm-package`: package.json without `"private": true` AND has `main`, `bin`, `exports`, or `files`
+- `cdk`: presence of `cdk.json` or `aws-cdk` in dependencies
+- `nestjs`: presence of `nest-cli.json` or `@nestjs` in dependencies
+- `expo`: presence of `app.json`, `eas.json`, or `expo` in dependencies
+- `typescript`: presence of `tsconfig.json` or `typescript` in dependencies
+
+Only check type directories that match the project.
+
+### Step 4: Compare Files
+
+For each file, compare the project version against the Lisa source:
+
+1. Read both files
+2. If identical, mark as "in sync"
+3. If different, generate a diff summary
+
+Use the Bash tool with `diff` to generate readable diffs:
+```bash
+diff -u "/path/to/lisa/source" "/path/to/project/file" || true
+```
+
+### Step 5: Generate Report
+
+Create a markdown report with these sections:
+
+```markdown
+# Lisa Implementation Review
+
+**Project:** [project name from package.json]
+**Lisa Source:** [lisa directory path]
+**Generated:** [current date/time]
+
+## Summary
+
+- **Total managed files:** X
+- **In sync:** X
+- **Drifted:** X
+- **Source not found:** X
+
+## Drifted Files
+
+### [relative/path/to/file]
+
+**Source:** [lisa-type]/copy-overwrite/[path]
+**Strategy:** copy-overwrite
+
+<details>
+<summary>View diff</summary>
+
+```diff
+[diff output]
+```
+
+</details>
+
+**Recommendation:** [Brief analysis of whether this change should be upstreamed]
+
+---
+
+[Repeat for each drifted file]
+
+## Files Not Found in Lisa
+
+These files are in the manifest but their source templates couldn't be located:
+
+- [list of files]
+
+## In Sync Files
+
+<details>
+<summary>X files are in sync with Lisa</summary>
+
+- [list of files]
+
+</details>
+```
+
+### Step 6: Offer to Upstream Changes
+
+After presenting the report, ask the user which drifted files they want to copy back to Lisa.
+
+For each file the user wants to upstream:
+
+1. Confirm the target path in Lisa (e.g., `typescript/copy-overwrite/.github/workflows/ci.yml`)
+2. Use the Write tool to copy the project's version to Lisa
+3. Report success
+
+Example prompt:
+```
+I found X files that have drifted from Lisa's templates.
+
+Which files would you like to copy back to Lisa?
+1. .github/workflows/ci.yml - [brief description of changes]
+2. .claude/settings.json - [brief description of changes]
+3. All of the above
+4. None - just show me the report
+
+Select an option (or list specific numbers):
+```
+
+### Important Notes
+
+- **Never auto-upstream without confirmation** - always ask the user first
+- **Preserve the most specific type directory** - if a file exists in both `typescript/` and `all/`, upstream to where it currently exists
+- **Handle binary files gracefully** - skip comparison for non-text files
+- **Respect .gitignore patterns** - some generated files shouldn't be compared
+- For `copy-contents` files like `.gitignore`, the comparison is trickier since the project may have additional lines - highlight only if Lisa's required lines are missing
+
+## Example Usage
+
+```
+User: /lisa-review-implementation
+
+Claude: I'll review your project's Lisa-managed files against the Lisa source templates.
+
+[Locates Lisa directory]
+[Reads manifest]
+[Compares files]
+[Generates report]
+
+# Lisa Implementation Review
+
+**Project:** my-awesome-app
+**Lisa Source:** /Users/dev/lisa
+**Generated:** 2026-01-18 10:30:00
+
+## Summary
+
+- **Total managed files:** 45
+- **In sync:** 42
+- **Drifted:** 3
+- **Source not found:** 0
+
+## Drifted Files
+
+### .github/workflows/ci.yml
+
+**Source:** typescript/copy-overwrite/.github/workflows/ci.yml
+**Strategy:** copy-overwrite
+
+[diff details]
+
+**Recommendation:** This adds a new caching step that improves CI performance. Good candidate for upstreaming.
+
+---
+
+I found 3 files that have drifted. Would you like to upstream any of these changes back to Lisa?
+```

package/all/copy-overwrite/.claude/skills/project-add-test-coverage/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: project-add-test-coverage
+description: This skill should be used when increasing test coverage to a specified threshold percentage. It runs the coverage report, identifies files with the lowest coverage, generates a brief with coverage gaps, and bootstraps a project to add the missing tests.
+allowed-tools: ["Read", "Bash", "Glob", "Grep"]
+argument-hint: "<threshold-percentage>"
+model: sonnet
+---
+
+# Increase Test Coverage
+
+Target threshold: $ARGUMENTS%
+
+If no argument provided, prompt the user for a target.
+
+## Step 1: Gather Requirements
+
+1. **Find coverage config** (jest.config.js, vitest.config.ts, .nycrc, etc.)
+2. **Run coverage report** to get current state:
+   ```bash
+   bun run test:cov 2>&1 | head -100
+   ```
+3. **Identify the 20 files with lowest coverage**, noting:
+   - File path
+   - Current coverage % (lines, branches, functions)
+   - Which lines/branches are uncovered
+
+## Step 2: Generate Brief
+
+Compile findings into a detailed brief:
+
+```
+Increase test coverage from [current]% to $ARGUMENTS%.
+
+## Files Needing Coverage (ordered by coverage gap)
+
+1. src/services/user.ts - 23% coverage (target: $ARGUMENTS%)
+   - Uncovered: lines 45-67, 89-102
+   - Missing branch coverage: lines 34, 56
+2. src/utils/helpers.ts - 34% coverage (target: $ARGUMENTS%)
+   - Uncovered: lines 12-45
+...
+
+## Configuration
+- Config file: [path to coverage config]
+- Update thresholds to $ARGUMENTS% for: lines, branches, functions, statements
+
+## Acceptance Criteria
+- All files meet $ARGUMENTS% coverage threshold
+- `bun run test:cov` passes with no threshold violations
+
+## Verification
+Command: `bun run test:cov`
+Expected: All thresholds pass at $ARGUMENTS%
+```
+
+## Step 3: Bootstrap Project
+
+Run `/project-bootstrap` with the generated brief as a text prompt.

package/all/copy-overwrite/.claude/skills/project-archive/SKILL.md

@@ -0,0 +1,10 @@
+---
+name: project-archive
+description: This skill should be used when archiving a completed project. It moves the project directory to the projects/archive folder, clears the active project marker, and commits and submits a PR with the changes.
+allowed-tools: ["Read", "Write", "Bash(git*)", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList"]
+argument-hint: "<project-directory>"
+---
+
+1. Move $ARGUMENTS to `projects/archive`
+2. Clear the active project marker: `rm -f .claude-active-project`
+3. Run /git-commit-and-submit-pr

package/all/copy-overwrite/.claude/skills/project-bootstrap/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: project-bootstrap
+description: This skill should be used when performing automated project setup and research with gap detection. It runs project setup, conducts research, checks for open questions, and if no gaps exist, proceeds directly to project execution.
+argument-hint: "<file-path|jira-issue|\"text description\">"
+---
+
+Complete all of the following steps for $ARGUMENTS:
+
+## Step 1: Setup
+
+Run `/project-setup $ARGUMENTS`
+
+Capture the project name from the output for use in subsequent steps.
+
+## Step 2: Research
+
+Run `/project-research @projects/<project-name>`
+
+## Step 3: Gap Detection
+
+Read @projects/<project-name>/research.md.
+
+Check '## Open Questions' section. If unresolved questions exist, STOP and report to human.
+
+If no gaps, immediately run `/project-execute @projects/<project-name>`
+
+## Output to Human
+
+- If gaps exist: "Bootstrap complete but needs human review - see Open Questions in research.md"

package/all/copy-overwrite/.claude/skills/project-debrief/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: project-debrief
+description: This skill should be used when aggregating learnings from completed project tasks and findings. It collects learnings from task metadata and findings.md, uses the skill-evaluator to categorize each learning (new skill, project rule, or omit), and applies the decisions accordingly.
+allowed-tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList", "Skill"]
+argument-hint: "<project-directory>"
+---
+
+## Setup
+
+Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
+
+Extract `<project-name>` from the last segment of `$ARGUMENTS`.
+
+## Create and Execute Tasks
+
+Create workflow tracking tasks with `metadata.project` set to the project name:
+
+```
+TaskCreate:
+  subject: "Aggregate project learnings"
+  description: "Collect all learnings from two sources: 1) Read $ARGUMENTS/findings.md for manual findings. 2) Read all task files in $ARGUMENTS/tasks/*.json and extract metadata.learnings arrays. Compile into a single list of distinct findings/learnings."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Evaluate each learning"
+  description: "For each learning, use Task tool with subagent_type 'skill-evaluator' to determine: CREATE SKILL (complex, reusable pattern), ADD TO RULES (simple never/always rule), or OMIT ENTIRELY (already covered or too project-specific). Collect all decisions."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Apply decisions"
+  description: "For each learning based on skill-evaluator decision: CREATE SKILL → run /skill-creator with details. ADD TO RULES → add succinctly to .claude/rules/PROJECT_RULES.md. OMIT → no action. Report summary: skills created, rules added, omitted count."
+  metadata: { project: "<project-name>" }
+```
+
+**Execute each task via a subagent** to preserve main context. Launch up to 6 in parallel where tasks don't have dependencies. Do not stop until all are completed.
+
+## Important: Rules vs Skills
+
+**WARNING about PROJECT_RULES.md**: Rules in `.claude/rules/` are **always loaded** at session start for every request. Only add learnings to PROJECT_RULES.md if they:
+- Apply to **every** request in this codebase (not just specific features)
+- Are simple "never do X" or "always do Y" statements
+- Cannot be scoped to a skill that's invoked on-demand
+
+If a learning only applies to certain types of work (e.g., "when writing GraphQL resolvers..."), it should be a **skill** instead, not a rule.

package/all/copy-overwrite/.claude/skills/project-document/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: project-document
+description: This skill should be used when updating all documentation related to changes implemented in a project. It identifies changed files, maps them to documentation targets, and updates README, API docs, CHANGELOG, and JSDoc documentation.
+allowed-tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList", "Skill"]
+argument-hint: "<project-directory>"
+---
+
+The current branch is a feature branch with implementation of the project in $ARGUMENTS.
+
+Changes on this branch need corresponding documentation updates to keep README, API docs, changelogs, and JSDoc current.
+
+**IMPORTANT**: Perform each step and move to the next without stopping.
+
+## Setup
+
+Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
+
+Extract `<project-name>` from the last segment of `$ARGUMENTS`.
+
+## Create and Execute Tasks
+
+Create workflow tracking tasks with `metadata.project` set to the project name:
+
+```
+TaskCreate:
+  subject: "Identify changed files and documentation targets"
+  description: "Use git to identify files changed on this branch (git diff main...HEAD --name-only). For each changed file, identify related documentation: README sections, API docs, inline JSDoc, CHANGELOG entries, architecture docs, configuration docs. Compile a mapping of: changed file → related documentation file(s). Save to $ARGUMENTS/doc-targets.json with structure: { \"file.ts\": [\"README.md#section\", \"docs/api.md\"], ... }"
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Update README and user-facing docs"
+  description: "For each documentation target in $ARGUMENTS/doc-targets.json that is a README section or user guide: Read the changed implementation file. Read the current documentation section. Update the documentation to accurately reflect the new/changed behavior, examples, or configuration. Preserve existing structure and tone."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Update API and technical documentation"
+  description: "For each documentation target that is API docs, architecture docs, or technical guides: Read the changed implementation. Read the current documentation. Update to reflect new endpoints, parameters, type signatures, behavior changes, or architectural decisions. Ensure consistency with code comments."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Update CHANGELOG"
+  description: "If CHANGELOG.md or CHANGELOG.{md,txt,rst} exists in project root: Add entry for all user-facing changes. Group by type (Added, Changed, Fixed, Deprecated). Reference relevant files or features. Follow existing CHANGELOG format and conventions."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Verify JSDoc on changed files"
+  description: "Read $ARGUMENTS/doc-targets.json. For each changed file (key), verify its JSDoc preamble and function/export documentation are current: Run /jsdoc-best-practices skill. Check that file-level preambles explain the module's purpose and when to use it. Check that exported functions/types have 'why' documentation (not just 'what'). Update any stale or missing documentation."
+  metadata: { project: "<project-name>" }
+```
+
+**Execute each task via a subagent** to preserve main context. Launch up to 5 in parallel where tasks don't have dependencies. Do not stop until all are completed.

package/all/copy-overwrite/.claude/skills/project-execute/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: project-execute
+description: This skill should be used when running the complete automated project execution workflow from planning through debrief. It requires gap-free research and sequentially runs planning, implementation, review, documentation, verification, debrief, and archive phases.
+allowed-tools: ["Read", "Write", "Edit", "Bash", "Glob", "Grep", "Task", "TaskCreate", "TaskUpdate", "TaskList", "TaskGet", "Skill"]
+argument-hint: "<project-directory>"
+---
+
+Execute complete implementation workflow for $ARGUMENTS.
+
+## Execution Rules
+
+1. **Continuous execution**: After each step completes, immediately invoke the next
+2. **No summaries**: Do not summarize progress between steps
+3. **No waiting**: Do not wait for user confirmation between steps
+4. **Only stop when done**: Only stop when all steps are completed
+
+## Setup
+
+1. Set active project marker: `echo "$ARGUMENTS" | sed 's|.*/||' > .claude-active-project`
+2. Read `$ARGUMENTS/research.md` and check "## Open Questions" section
+   - If gaps exist: STOP with "Cannot proceed - research.md has unresolved open questions"
+3. Check if planning is already complete: `ls $ARGUMENTS/tasks/*.md 2>/dev/null | head -3`
+   - If task files exist: Skip planning, start at implementation
+
+## Create and Execute Tasks
+
+Create workflow tracking tasks with `metadata.project` set to the project name:
+
+```
+TaskCreate:
+  subject: "Planning"
+  description: "Run /project-plan $ARGUMENTS to create implementation tasks."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Implementation"
+  description: "Run /project-implement $ARGUMENTS to execute all planned tasks."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Review"
+  description: "Run /project-review $ARGUMENTS to review code changes."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Documentation"
+  description: "Run /project-document $ARGUMENTS to update documentation related to changes."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Verification"
+  description: "Run /project-verify $ARGUMENTS to verify all requirements are met."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Debrief"
+  description: "Run /project-debrief $ARGUMENTS to capture learnings."
+  metadata: { project: "<project-name>" }
+
+TaskCreate:
+  subject: "Archive"
+  description: "Run /project-archive $ARGUMENTS to archive the completed project."
+  metadata: { project: "<project-name>" }
+```
+
+**Execute each task via a subagent** to preserve main context. Launch up to 6 in parallel where tasks don't have dependencies. Do not stop until all are completed.
+
+Report "Project complete and archived" when done.