cokit-cli 1.0.4 → 1.0.5

package/templates/repo/.github/prompts/ck-fix-parallel.prompt.md

@@ -0,0 +1,54 @@
+---
+agent: 'agent'
+description: 'Analyze & fix issues with parallel fullstack-developer agents'
+tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLastCommand']
+---
+
+**Ultrathink parallel** to fix: <issues>${input}</issues>
+
+**IMPORTANT:** Activate needed skills. Ensure token efficiency. Sacrifice grammar for concision.
+
+## Workflow
+
+### 1. Issue Analysis
+- analyze root causes
+- Use  to find related files
+- Categorize issues by scope/area (frontend, backend, auth, payments, etc.)
+- Identify dependencies between issues
+
+### 2. Parallel Fix Planning
+- Trigger :parallel <detailed-fix-instructions>` for parallel-executable fix plan
+- Wait for plan with dependency graph, execution strategy, file ownership matrix
+- Group independent fixes for parallel execution
+- Sequential fixes for dependent issues
+
+### 3. Parallel Fix Implementation
+- Read `plan.md` for dependency graph
+- Launch multiple `fullstack-developer` agents  for independent fixes
+  - Example: "Fix auth + Fix payments + Fix UI" → launch 3 agents simultaneously
+  - Pass phase file path: `{plan-dir}/phase-XX-*.md`
+  - Include environment info
+- Wait for all parallel fixes complete before dependent fixes
+- Sequential fixes: launch one agent at a time
+
+### 4. Testing
+- NO fake data/mocks/cheats
+- Verify all issues resolved
+- If fail: use `debugger`, fix, repeat
+
+### 5. Code Review
+- Use `code-reviewer` for all changes
+- Verify fixes don't introduce regressions
+- If critical issues: fix, retest
+
+### 6. Project Management & Docs
+- If approved: use `project-manager` + `docs-manager` 
+- Update plan files, docs, roadmap
+- If rejected: fix and repeat
+
+### 7. Final Report
+- Summary of all fixes from parallel phases
+- Verification status per issue
+- Ask to commit (use `git-manager` if yes)
+
+**Example:** Fix 1 (auth) + Fix 2 (payments) + Fix 3 (UI) → Launch 3 fullstack-developer agents → Wait → Fix 4 (integration) sequential

package/templates/repo/.github/prompts/ck-fix-test.prompt.md

@@ -0,0 +1,19 @@
+---
+agent: 'agent'
+description: 'Run test suite and fix issues'
+tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLastCommand']
+---
+
+## Reported Issues:
+<issues>${input}</issues>
+
+## Workflow:
+1. compile the code and fix all syntax errors if any.
+2. run the tests and .
+3. If there are issues or failed tests, find the root cause of the issues, .
+4. create an implementation plan based on the reports, .
+5. Use main agent to implement the plan step by step.
+6. test the fix and make sure it works, .
+6. quickly review the code changes and make sure it meets requirements, .
+7. If there are issues or failed tests, repeat from step 2.
+8. After finishing, respond back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.

package/templates/repo/.github/prompts/ck-fix-types.prompt.md

@@ -0,0 +1,11 @@
+---
+agent: 'agent'
+description: 'Fix type errors'
+tools: ['search/codebase', 'read/problems', 'read/terminalLastCommand']
+---
+
+Run `bun run typecheck` or `tsc` or `npx tsc` and fix all type errors.
+
+## Rules
+- Fix all of type errors and repeat the process until there are no more type errors.
+- Do not use `any` just to pass the type check.

package/templates/repo/.github/prompts/ck-fix-ui.prompt.md

@@ -0,0 +1,49 @@
+---
+agent: 'agent'
+description: 'Analyze and fix UI issues'
+tools: ['search/codebase', 'search/changes', 'read/problems', 'web/fetch']
+---
+
+## Required Skills (Priority Order)
+1. **`ui-ux-pro-max`** - Design intelligence database (ALWAYS ACTIVATE FIRST)
+2. **`aesthetic`** - Design principles
+3. **`frontend-design`** - Implementation patterns
+
+Read and analyze `./docs/design-guidelines.md` then fix the following issues:
+<issue>${input}</issue>
+
+## Workflow
+**FIRST**: Run `ui-ux-pro-max` searches to understand context and common issues:
+```bash
+python3  "<product-type>" --domain product
+python3  "<style-keywords>" --domain style
+python3  "accessibility" --domain ux
+python3  "z-index animation" --domain ux
+```
+
+If the user provides a screenshots or videos, 
+
+1. implement the fix step by step.
+2. Use screenshot capture tools along with `ai-multimodal` skill to take screenshots of the implemented fix (at the exact parent container, don't take screenshot of the whole page) and use the appropriate Gemini analysis skills (`ai-multimodal`, `video-analysis`, or `document-extraction`) to analyze those outputs so the result matches the design guideline and addresses all issues.
+  - If the issues are not addressed, repeat the process until all issues are addressed.
+3. 
+4. test the fix and compile the code to make sure it works, .
+  - If there are issues or failed tests, ask main agent to fix all of them and repeat the process until all tests pass.
+5. Project Management & Documentation:
+  **If user approves the changes:** Use `project-manager` and s  to update the project progress and documentation:
+    * update the project progress and task status in the given plan file.
+    * update the docs in `./docs` directory if needed.
+    * create a project roadmap at `./docs/project-roadmap.md` file.
+    * **IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+  **If user rejects the changes:** Ask user to explain the issues and ask main agent to fix all of them and repeat the process.
+6. Final Report:
+  * Report back to user with a summary of the changes and explain everything briefly, guide user to get started and suggest the next steps.
+  * Ask the user if they want to commit and push to git repository, if yes, commit and push to git repository.
+  * **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+  * **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+
+**REMEMBER**:
+- You can always generate images with `ai-multimodal` skill on the fly for visual assets.
+- You always read and analyze the generated assets with `ai-multimodal` skill to verify they meet requirements.
+- For image editing (removing background, adjusting, cropping), use `ImageMagick` skill or similar tools as needed.
+- **IMPORTANT:** 

package/templates/repo/.github/prompts/ck-fix.prompt.md

@@ -1,24 +1,44 @@
 ---
-mode: agent
-description: Debug and fix code issues systematically
+agent: 'agent'
+description: 'Analyze and fix issues [INTELLIGENT ROUTING]'
+tools: ['search/codebase', 'search/changes', 'read/problems', 'read/terminalLastCommand']
 ---
 
-# Fix - Systematic Debugging
+**Analyze issues and route to specialized fix command:**
+<issues>${input}</issues>
 
-You are a debugging expert. Help the user fix their issue systematically.
+## Decision Tree
 
-## Approach
+**1. Check for existing plan:**
+- If markdown plan exists →  <path-to-plan>`
 
-1. **Understand the problem** - What's the expected vs actual behavior?
-2. **Reproduce** - Can you identify where the issue occurs?
-3. **Root cause** - Find the actual cause, not just symptoms
-4. **Fix** - Make the minimal change needed
-5. **Verify** - Confirm the fix works and doesn't break anything else
+**2. Route by issue type:**
 
-## Guidelines
+**A) Type Errors** (keywords: type, typescript, tsc, type error)
+→ `/fix:types`
 
-- Ask clarifying questions if needed
-- Check logs and error messages
-- Don't guess - investigate first
-- Explain what you find
-- Keep fixes focused and minimal
+**B) UI/UX Issues** (keywords: ui, ux, design, layout, style, visual, button, component, css, responsive)
+→ `/fix:ui <detailed-description>`
+
+**C) CI/CD Issues** (keywords: github actions, pipeline, ci/cd, workflow, deployment, build failed)
+→ `/fix:ci <github-actions-url-or-description>`
+
+**D) Test Failures** (keywords: test, spec, jest, vitest, failing test, test suite)
+→ `/fix:test <detailed-description>`
+
+**E) Log Analysis** (keywords: logs, error logs, log file, stack trace)
+→ `/fix:logs <detailed-description>`
+
+**F) Multiple Independent Issues** (2+ unrelated issues in different areas)
+→ `/fix:parallel <detailed-description>`
+
+**G) Complex Issues** (keywords: complex, architecture, refactor, major, system-wide, multiple components)
+→ `/fix:hard <detailed-description>`
+
+**H) Simple/Quick Fixes** (default: small bug, single file, straightforward)
+→ `/fix:fast <detailed-description>`
+
+## Notes
+- `detailed-description` = enhanced prompt describing issue in detail
+- If unclear, ask user for clarification before routing
+- Can combine routes: e.g., multiple type errors + UI issue → `/fix:parallel`

package/templates/repo/.github/prompts/ck-git-cm.prompt.md

@@ -0,0 +1,8 @@
+---
+agent: 'agent'
+description: 'Stage all files and create a commit.'
+tools: ['search/changes', 'web/githubRepo']
+---
+
+stage all files and create a commit.
+**IMPORTANT: DO NOT push the changes to remote repository**

package/templates/repo/.github/prompts/ck-git-cp.prompt.md

@@ -0,0 +1,7 @@
+---
+agent: 'agent'
+description: 'Stage, commit and push all code in the current branch'
+tools: ['search/changes', 'web/githubRepo']
+---
+
+stage all files, create a meaningful commit based on the changes and push to remote repository.

package/templates/repo/.github/prompts/ck-git-merge.prompt.md

@@ -0,0 +1,41 @@
+---
+agent: 'agent'
+description: '⚠️ Merge code from one branch to another'
+tools: ['search/changes', 'web/githubRepo']
+---
+
+## Variables
+
+TO_BRANCH: $1 (defaults to `main`)
+FROM_BRANCH: $2 (defaults to current branch)
+
+## Workflow
+
+### Step 1: Sync with remote (CRITICAL)
+```bash
+git fetch origin
+git checkout {TO_BRANCH}
+git pull origin {TO_BRANCH}
+```
+
+### Step 2: Merge from REMOTE tracking branch
+```bash
+# Use origin/{FROM_BRANCH} to merge remote state, not local WIP
+git merge origin/{FROM_BRANCH} --no-ff -m "merge: {FROM_BRANCH} into {TO_BRANCH}"
+```
+
+**Why `origin/{FROM_BRANCH}`:** Ensures merging only committed+pushed changes, not local uncommitted work.
+
+### Step 3: Resolve conflicts if any
+- If conflicts exist, resolve them manually
+- After resolution: `git add . && git commit`
+
+### Step 4: Push merged result
+```bash
+git push origin {TO_BRANCH}
+```
+
+## Notes
+- If `gh` command is not available, instruct the user to install and authorize GitHub CLI first.
+- If you need more clarifications, use `AskUserQuestion` tool to ask the user for more details.
+- Always fetch and pull latest remote state before merging to avoid stale conflicts.

package/templates/repo/.github/prompts/ck-git-pr.prompt.md

@@ -0,0 +1,49 @@
+---
+agent: 'agent'
+description: 'Create a pull request'
+tools: ['search/changes', 'web/githubRepo']
+---
+
+## Variables
+
+TO_BRANCH: $1 (defaults to `main`)
+FROM_BRANCH: $2 (defaults to current branch)
+
+## Workflow
+
+### Step 1: Ensure remote is synced
+```bash
+git fetch origin
+git push -u origin HEAD  # Push current branch if not pushed
+```
+
+### Step 2: Analyze REMOTE diff (CRITICAL)
+**IMPORTANT:** Always compare REMOTE branches, not local:
+```bash
+# Get commits between remote branches (what PR will actually contain)
+git log origin/{TO_BRANCH}...origin/{FROM_BRANCH} --oneline
+
+# Get file diff between remote branches
+git diff origin/{TO_BRANCH}...origin/{FROM_BRANCH} --stat
+git diff origin/{TO_BRANCH}...origin/{FROM_BRANCH}
+```
+
+**DO NOT use:**
+- `git diff {TO_BRANCH}...HEAD` (includes unpushed local changes)
+- `git diff --cached` (staged local changes)
+- `git status` (local working tree state)
+
+### Step 3: Generate PR content from remote diff
+Based on the REMOTE diff analysis:
+- **Title:** Conventional commit format from the primary change (no version/release numbers)
+- **Body:** Summary of changes that exist ON REMOTE, not local WIP
+
+### Step 4: Create PR
+```bash
+gh pr create --base {TO_BRANCH} --head {FROM_BRANCH} --title "..." --body "..."
+```
+
+## Notes
+- If `gh` command is not available, instruct the user to install and authorize GitHub CLI first.
+- If local has unpushed commits, push first before analyzing diff.
+- PR content must reflect REMOTE state since PRs are based on remote branches.

package/templates/repo/.github/prompts/ck-kanban.prompt.md

@@ -0,0 +1,77 @@
+---
+agent: 'agent'
+description: 'Plans directory (default: .s)'
+tools: ['search/codebase', 'read/terminalLastCommand']
+---
+
+Plans dashboard with progress tracking and timeline visualization.
+
+## Usage
+
+- `/kanban` - View dashboard for .s directory
+- `/kanban plans/` - View dashboard for specific directory
+- `/kanban --stop` - Stop running server
+
+## Features
+
+- Plan cards with progress bars
+- Phase status breakdown (completed, in-progress, pending)
+- Timeline/Gantt visualization
+- Activity heatmap
+- Issue and branch links
+
+## Execution
+
+**IMPORTANT:**  This makes the server visible in `/tasks` and manageable via `KillShell`.
+
+Check if this script is located in the current workspace or in  directory:
+- If in current workspace: `$SKILL_DIR_PATH` = 
+- If in home directory: `$SKILL_DIR_PATH` = 
+
+### Stop Server
+
+If `--stop` flag is provided:
+
+```bash
+node $SKILL_DIR_PATH/scripts/server.cjs --stop
+```
+
+### Start Server
+
+Otherwise, run the kanban server as CC background task with `--foreground` flag (keeps process alive for CC task management):
+
+```bash
+# Determine plans directory
+INPUT_DIR="${dir}"
+PLANS_DIR="${INPUT_DIR:-.s}"
+
+# Start kanban dashboard
+node $SKILL_DIR_PATH/scripts/server.cjs \
+  --dir "$PLANS_DIR" \
+  --host 0.0.0.0 \
+  --open \
+  --foreground
+```
+
+**Critical:** ## Future Plans
+
+The `/kanban` command will evolve into **VibeKanban-inspired** AI agent orchestration:
+
+### Phase 1 (Current - MVP)
+- ✅ Task board with progress tracking
+- ✅ Visual representation of plans/tasks
+- ✅ Click to view plan details
+
+### Phase 2 (Worktree Integration)
+- Create tasks → spawn git worktrees
+- Assign agents to tasks
+- Track agent progress per worktree
+
+### Phase 3 (Full Orchestration)
+- Parallel agent execution monitoring
+- Code diff/review interface
+- PR creation workflow
+- Agent output streaming
+- Conflict detection
+
+Track progress: https://github.com/claudekit/claudekit-engineer/issues/189

package/templates/repo/.github/prompts/ck-plan-archive.prompt.md

@@ -0,0 +1,58 @@
+---
+agent: 'agent'
+description: 'Write journal entries and archive specific plans or all plans'
+tools: ['search/codebase', 'search/changes']
+---
+
+## Your mission
+Read and analyze the plans, then write journal entries and archive specific plans or all plans in the `plans` directory.
+
+## Plan Resolution
+1. If `${input}` provided → Use that path
+2. Else read all plans in the `plans` directory
+
+## Workflow
+
+### Step 1: Read Plan Files
+
+Read the plan directory:
+- `plan.md` - Overview and phases list
+- `phase-*.md` - 20 first lines of each phase file to understand the progress and status
+
+### Step 2: Summarize the plans and document them with `/journal` 
+Use `AskUserQuestion` tool to ask if user wants to document journal entries or not.
+Skip this step if user selects "No".
+If user selects "Yes":
+- Analyze the information in previous steps.
+- Use  with `_type="journal-writer"`  to document all plans.
+- Journal entries should be concise and focused on the most important events, key changes, impacts, and decisions.
+- Keep journal entries in the `./docs/journals/` directory.
+
+### Step 3: Ask user to confirm the action before archiving these plans
+Use `AskUserQuestion` tool to ask if user wants to proceed with archiving these plans, select specific plans to archive or all completed plans only.
+Use `AskUserQuestion` tool to ask if user wants to delete permanently or move to the `.s/archive` directory.
+
+### Step 4: Archive the plans
+Start archiving the plans based on the user's choice:
+- Move the plans to the `.s/archive` directory.
+- Delete the plans permanently: `rm -rf .s/<plan-1> .s/<plan-2> ...`
+
+### Step 5: Ask if user wants to commit the changes
+Use `AskUserQuestion` tool to ask if user wants to commit the changes with these options:
+- Stage and commit the changes (Use `/git:cm` )
+- Commit and push the changes (Use `/git:cp` )
+- Nah, I'll do it later
+
+## Output
+After archiving the plans, provide summary:
+- Number of plans archived 
+- Number of plans deleted permanently
+- Table of plans that are archived or deleted (title, status, created date, LOC)
+- Table of journal entries that are created (title, status, created date, LOC)
+
+## Important Notes
+
+**IMPORTANT:** Only ask questions about genuine decision points - don't manufacture artificial choices.
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+**IMPORTANT:** In the last summary report, list any unresolved questions at the end, if any.
+**IMPORTANT:** Ensure token efficiency while maintaining high quality.

package/templates/repo/.github/prompts/ck-plan-ci.prompt.md

@@ -0,0 +1,34 @@
+---
+agent: 'agent'
+description: 'Analyze Github Actions logs and provide a plan to fix the issues'
+tools: ['search/codebase', 'search/changes', 'web/fetch', 'web/githubRepo', 'read/problems']
+---
+
+
+
+## Github Actions URL
+ ${input}
+
+read the github actions logs, analyze and find the root causes of the issues, then provide a detailed plan for implementing the fixes.
+
+**Plan File Specification:**
+- Every `plan.md` MUST start with YAML frontmatter:
+  ```yaml
+  ---
+  title: "{Brief title}"
+  description: "{One sentence for card preview}"
+  status: pending
+  priority: P1
+  effort: {estimated fix time}
+  branch: {current git branch}
+  tags: [ci, bugfix]
+  created: {YYYY-MM-DD}
+  ---
+  ```
+
+**Output:**
+Provide at least 2 implementation approaches with clear trade-offs, and explain the pros and cons of each approach, and provide a recommended approach.
+
+**IMPORTANT:** Ask the user for confirmation before implementing.
+**IMPORTANT:** 
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.

package/templates/repo/.github/prompts/ck-plan-cro.prompt.md

@@ -0,0 +1,66 @@
+---
+agent: 'agent'
+description: 'Create a CRO plan for the given content'
+tools: ['search/codebase', 'search/changes', 'web/fetch', 'read/problems']
+---
+
+You are an expert in conversion optimization. Analyze the content based on the given issues:
+<issues>${input}</issues>
+
+
+
+**IMPORTANT:** 
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing outputs.
+
+## Conversion Optimization Framework
+
+1. Headline 4-U Formula: **Useful, Unique, Urgent, Ultra-specific** (80% won't read past this)
+2. Above-Fold Value Proposition: Customer problem focus, no company story, zero scroll required
+3. CTA First-Person Psychology: "Get MY Guide" vs "Get YOUR Guide" (90% more clicks)
+4. 5-Field Form Maximum: Every field kills conversions, progressive profiling for the rest
+5. Message Match Precision: Ad copy, landing page headline, broken promises = bounce
+6. Social Proof Near CTAs: Testimonials with faces/names, results, placed at decision points
+7. Cognitive Bias Stack: Loss aversion (fear), social proof (FOMO), anchoring (pricing)
+8. PAS Copy Framework: Problem > Agitate > Solve, emotion before logic
+9. Genuine Urgency Only: Real deadlines, actual limits, fake timers destroy trust forever
+10. Price Anchoring Display: Show expensive option first, make real price feel like relief
+11. Trust Signal Clustering: Security badges, guarantees, policies all visible together
+12. Visual Hierarchy F-Pattern: Eyes scan F-shape, put conversions in the path
+13. Lead Magnet Hierarchy: Templates > Checklists > Guides (instant > delayed gratification)
+14. Objection Preemption: Address top 3 concerns before they think them, FAQ near CTA
+15. Mobile Thumb Zone: CTAs where thumbs naturally rest, not stretching required
+16. One-Variable Testing: Change one thing, measure impact, compound wins over time
+17. Post-Conversion Momentum: Thank you page sells next step while excitement peaks
+18. Cart Recovery Sequence: Email in 1 hour, retarget in 4 hours, incentive at 24 hours
+19. Reading Level Grade 6: Smart people prefer simple, 11-word sentences, short paragraphs
+20. TOFU/MOFU/BOFU Logic: Awareness content ≠ decision content, match intent precisely
+21. White Space = Focus: Empty space makes CTAs impossible to miss, crowded = confused
+22. Benefit-First Language: Features tell, benefits sell, transformations compel
+23. Micro-Commitment Ladder: Small yes leads to big yes, start with email only
+24. Performance Tracking Stack: Heatmaps show problems, recordings show why, events show what
+25. Weekly Optimization Ritual: Review metrics Monday, test Tuesday, iterate or scale
+
+## Workflow
+
+- If the user provides a screenshots or videos, 
+- If the user provides a URL, use `web_fetch` tool to fetch the content of the URL and analyze the current issues.
+- You can use screenshot capture tools along with `ai-multimodal` skill to capture screenshots of the exact parent container and analyze the current issues with the appropriate Gemini analysis skills (`ai-multimodal`, `gemini-video-understanding`, or `gemini-document-processing`).
  - Every `plan.md` MUST start with YAML frontmatter:
+    ```yaml
+    ---
+    title: "{Brief title}"
+    description: "{One sentence for card preview}"
+    status: pending
+    priority: P2
+    effort: {sum of phases, e.g., 4h}
+    branch: {current git branch}
+    tags: [cro, conversion]
+    created: {YYYY-MM-DD}
+    ---
+    ```
+  - Save the overview access point at `plan.md`, keep it generic, under 80 lines, and list each phase with status/progress and links.
+  - For each phase, add `phase-XX-phase-name.md` files containing sections (Context links, Overview with date/priority/statuses, Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps).
+  - Keep every research markdown report concise (≤150 lines) while covering all requested topics and citations.
+- Do not start implementing the CRO plan yet, wait for the user to approve the plan first.
+
+**IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+**IMPORTANT:** In reports, list any unresolved questions at the end, if any.

package/templates/repo/.github/prompts/ck-plan-fast.prompt.md

@@ -0,0 +1,67 @@
+---
+agent: 'agent'
+description: 'No research. Only analyze and create an implementation plan'
+tools: ['search/codebase', 'search/changes', 'read/problems']
+---
+
+Think.
+
+
+## Your mission
+<task>
+${input}
+</task>
+
+## Pre-Creation Check (Active vs Suggested Plan)
+
+Check the `## Plan Context` section in the injected context:
+- If "Plan:" shows a path → Active plan exists. Ask user: "Continue with this? [Y/n]"
+- If "Suggested:" shows a path → Branch-matched hint only. Ask if they want to activate or create new.
+- If "Plan: none" → Create new plan using naming from `## Naming` section.
+
+## Workflow
+Use  to:
+1. If creating new: Create directory using `Plan dir:` from `## Naming` section, then run `node  {plan-dir}`
+   If reusing: Use the active plan path from Plan Context.
+   Make sure you pass the directory path to every  during the process.
+2. Follow strictly to the "Plan Creation & Organization" rules of `planning` skill.
+3. Analyze the codebase by reading `codebase-summary.md`, ``, `system-architecture.md` and `project-overview-pdr.md` file.
+4. Gathers all information and create an implementation plan of this task.
+5. Ask user to review the plan.
+
+## Output Requirements
+
+**Plan Directory Structure** (use `Plan dir:` from `## Naming` section)
+```
+{plan-dir}/
+├── reports/
+│   ├── XX-report.md
+│   └── ...
+├── plan.md
+├── phase-XX-phase-name-here.md
+└── ...
+```
+
+**Plan File Specification**
+- Every `plan.md` MUST start with YAML frontmatter:
+  ```yaml
+  ---
+  title: "{Brief title}"
+  description: "{One sentence for card preview}"
+  status: pending
+  priority: P2
+  effort: {sum of phases, e.g., 4h}
+  branch: {current git branch}
+  tags: [relevant, tags]
+  created: {YYYY-MM-DD}
+  ---
+  ```
+- Save the overview access point at `{plan-dir}.md`. Keep it generic, under 80 lines, and list each implementation phase with status and progress plus links to phase files.
+- For each phase, create `{plan-dir}/phase-XX-phase-name-here.md` containing the following sections in order: Context links (reference parent plan, dependencies, docs), Overview (date, description, priority, implementation status, review status), Key Insights, Requirements, Architecture, Related code files, Implementation Steps, Todo list, Success Criteria, Risk Assessment, Security Considerations, Next steps.
+
+## Important Notes
+- **IMPORTANT:** Ensure token consumption efficiency while maintaining high quality.
+- **IMPORTANT:** 
+- **IMPORTANT:** Sacrifice grammar for the sake of concision when writing reports.
+- **IMPORTANT:** In reports, list any unresolved questions at the end, if any.
+- **IMPORTANT**: **Do not** start implementing.