prjct-cli 0.28.2 → 0.28.4

package/templates/commands/sync.md

@@ -11,7 +11,20 @@ backend-sync: 'sync/pending.json'
 
 # /p:sync - Deep Project Sync
 
-**CRITICAL**: This is a DEEP analysis. Sync EVERYTHING with the real state of the repository.
+**PERFORMANCE**: Use parallel operations wherever possible. This sync should complete in <30 seconds.
+
+## Parallelization Strategy
+
+| Phase | Operations | Parallel? |
+|-------|------------|-----------|
+| Git + Stats | git commands, package.json read | ✅ Yes |
+| Storage Read | state, queue, ideas, shipped | ✅ Yes |
+| Context Write | now, next, ideas, shipped, CLAUDE.md | ✅ Yes |
+| Agent Gen | workflow agents, domain agents | ✅ Yes |
+
+**CRITICAL**: Batch all Read/Write operations. Never do sequential reads when parallel is possible.
+
+---
 
 ## Architecture: Write-Through Pattern
 
@@ -101,285 +114,112 @@ IF file not found:
 
 ---
 
-## Step 2: Deep Git Analysis
+## Step 2: Git Analysis (PARALLEL)
 
-### 2.1 Git Status (Uncommitted Work)
-```bash
-git status --porcelain
-```
-
-EXTRACT:
-- `{stagedFiles}`: Files staged for commit
-- `{modifiedFiles}`: Modified but not staged
-- `{untrackedFiles}`: New files
-- `{hasUncommittedChanges}`: true/false
+**Run ALL git commands in a single parallel batch:**
 
-### 2.2 Recent Commits (Last 20)
 ```bash
-git log --oneline -20 --pretty=format:"%h|%s|%ad" --date=short
-```
-
-ANALYZE each commit for completed tasks.
-
-EXTRACT: `{completedTasks}` - List of tasks found in commits
-
-### 2.3 Current Branch Analysis
-```bash
-git branch --show-current
-git log main..HEAD --oneline 2>/dev/null
+# Run in parallel (single Bash call with &&)
+git status --porcelain && \
+git log --oneline -10 --pretty=format:"%h|%s" && \
+git branch --show-current && \
+git rev-list --count HEAD
 ```
 
-EXTRACT:
-- `{currentBranch}`: Current branch name
-- `{branchCommits}`: Commits ahead of main
+EXTRACT from combined output:
+- `{stagedFiles}`, `{modifiedFiles}`, `{untrackedFiles}`, `{hasUncommittedChanges}`
+- `{recentCommits}`: Last 10 commits (reduced from 20)
+- `{currentBranch}`, `{commitCount}`
 - `{isFeatureBranch}`: true if not main/master
 
 ---
 
-## Step 3: Gather Project Stats
-
-### Count Files
-```bash
-find . -type f \( -name "*.js" -o -name "*.ts" -o -name "*.tsx" -o -name "*.py" \) -not -path "./node_modules/*" -not -path "./.git/*" | wc -l
-```
-EXTRACT: `{fileCount}`
-
-### Count Commits
-```bash
-git rev-list --count HEAD
-```
-EXTRACT: `{commitCount}`
-
-### Get Version
-READ: `package.json` → version field
-EXTRACT: `{version}`
-
-### Get Project Name
-READ: `package.json` → name field OR directory name
-EXTRACT: `{projectName}`
-
-### Detect Stack
-GLOB for config files and analyze:
-- `package.json` → Node.js, detect React/Vue/Express/Next.js
-- `Cargo.toml` → Rust
-- `go.mod` → Go
-- `requirements.txt` / `pyproject.toml` → Python
-
-EXTRACT: `{languages}`, `{frameworks}`, `{techStack}`
-
-### Detect Frontend/UI Stack (for UX/UI Agent)
-
-**CRITICAL**: If ANY frontend technology is detected, generate the UX/UI agent.
-
-#### Web Frontend Detection
-```bash
-# Check package.json for web frameworks
-grep -E '"(react|react-dom|next|vue|nuxt|svelte|@sveltejs/kit|@angular/core)"' package.json 2>/dev/null
-```
-
-SET: `{hasWebFrontend}` = true if any match
-
-#### Mobile Frontend Detection
-```bash
-# React Native / Expo
-grep -E '"(react-native|expo)"' package.json 2>/dev/null
-
-# Flutter
-test -f pubspec.yaml && echo "flutter"
-
-# SwiftUI (iOS)
-find . -name "*.swift" -exec grep -l "import SwiftUI" {} \; 2>/dev/null | head -1
-
-# Jetpack Compose (Android)
-find . -name "*.kt" -exec grep -l "androidx.compose" {} \; 2>/dev/null | head -1
-```
-
-SET: `{hasMobileFrontend}` = true if any match
+## Step 3: Project Stats (FAST)
 
-#### Combined Frontend Flag
-```
-{hasFrontendUI} = {hasWebFrontend} OR {hasMobileFrontend}
-```
+**Use Glob tool instead of find - much faster:**
 
-EXTRACT: `{frontendType}` = "web" | "mobile" | "both" | null
-
----
+### 3.1 Quick Stats (Single Read)
 
-## Step 3.5: Deep Project Analysis (TRULY AGENTIC)
+READ: `package.json` → extract `name`, `version`, `dependencies`, `devDependencies`, `scripts`
 
-**CRITICAL: Do NOT follow hardcoded rules. ANALYZE the actual project and UNDERSTAND what it is.**
+From dependencies, detect:
+- `{techStack}`: react, vue, express, etc.
+- `{hasWebFrontend}`: react|vue|svelte|next in deps
+- `{hasMobileFrontend}`: react-native|expo in deps
 
-### 3.5.1 Detect Project Type (AGENTIC)
+SET: `{projectName}` = package.name OR directory name
+SET: `{version}` = package.version
 
-**Look at the project root and DETERMINE what kind of project this is:**
+### 3.2 File Count (Use Glob, NOT find)
 
-```bash
-ls -la
 ```
-
-ANALYZE what files exist and REASON about the project type:
-
-| If you see... | Project is... | Ecosystem |
-|---------------|---------------|-----------|
-| `Gemfile` | Ruby/Rails | Ruby |
-| `requirements.txt`, `pyproject.toml`, `setup.py` | Python | Python |
-| `go.mod` | Go | Go |
-| `Cargo.toml` | Rust | Rust |
-| `composer.json` | PHP | PHP |
-| `pom.xml`, `build.gradle` | Java | JVM |
-| `*.csproj`, `*.sln` | .NET/C# | .NET |
-| `mix.exs` | Elixir | Elixir |
-| `Package.swift` | Swift | Apple |
-| `package.json` | Node.js/JavaScript | JavaScript |
-| `pubspec.yaml` | Flutter/Dart | Dart |
-| `Makefile` only | C/C++ or custom | Native |
-
-SET: `{ecosystem}` = detected ecosystem
-SET: `{projectType}` = specific type (e.g., "Rails", "Django", "Next.js", "Go API")
-
-### 3.5.2 Detect Commands FOR THIS PROJECT (AGENTIC)
-
-**Based on the ecosystem, LOOK for the actual commands this project uses:**
-
-#### Ruby/Rails
-```bash
-cat Gemfile | head -20  # See dependencies
-test -f bin/rails && echo "rails"
-test -f Rakefile && echo "rake"
+GLOB: **/*.{ts,tsx,js,jsx,py,go,rs} (exclude node_modules, .git)
 ```
-→ Commands: `bundle install`, `rails s`, `rails c`, `rake db:migrate`, `rspec`
+SET: `{fileCount}` = count of matches
 
-#### Python
-```bash
-test -f pyproject.toml && cat pyproject.toml | head -20
-test -f requirements.txt && echo "pip"
-which poetry && echo "poetry"
-which uv && echo "uv"
-```
-→ Commands: `pip install -r requirements.txt` OR `poetry install` OR `uv sync`
+**NOTE**: commitCount already extracted in Step 2.
 
-#### Go
-```bash
-cat go.mod | head -5
-```
-→ Commands: `go build`, `go test ./...`, `go run .`
+### 3.3 Detect Ecosystem (Single ls)
 
-#### Rust
 ```bash
-cat Cargo.toml | head -10
+ls package.json bun.lockb pnpm-lock.yaml yarn.lock package-lock.json Cargo.toml go.mod pyproject.toml 2>/dev/null
 ```
-→ Commands: `cargo build`, `cargo test`, `cargo run`
 
-#### Node.js/JavaScript
-```bash
-# Check lockfile to determine package manager
-test -f bun.lockb && echo "bun"
-test -f pnpm-lock.yaml && echo "pnpm"
-test -f yarn.lock && echo "yarn"
-test -f package-lock.json && echo "npm"
-cat package.json | grep -A 20 '"scripts"'
-```
-→ Commands: Use detected package manager + scripts from package.json
+| Found | Ecosystem | Package Manager |
+|-------|-----------|-----------------|
+| `bun.lockb` | JavaScript | bun |
+| `pnpm-lock.yaml` | JavaScript | pnpm |
+| `yarn.lock` | JavaScript | yarn |
+| `package-lock.json` | JavaScript | npm |
+| `Cargo.toml` | Rust | cargo |
+| `go.mod` | Go | go |
+| `pyproject.toml` | Python | uv/poetry |
 
-**EXTRACT the actual commands:**
-- `{installCommand}` = what installs dependencies
-- `{runCommand}` = how to run scripts
-- `{testCommand}` = how to run tests
-- `{buildCommand}` = how to build
-- `{devCommand}` = how to run dev server
+SET: `{ecosystem}`, `{packageManager}`
 
-### 3.5.3 Detect Code Conventions (AGENTIC)
+---
 
-**LOOK at actual files to understand patterns:**
+## Step 3.5: Extract Commands & Conventions
 
-```bash
-# List some source files
-find . -type f \( -name "*.rb" -o -name "*.py" -o -name "*.go" -o -name "*.rs" -o -name "*.ts" -o -name "*.js" \) -not -path "*/node_modules/*" -not -path "*/.git/*" | head -10
+**Already have ecosystem from Step 3. Now extract commands from scripts.**
 
-# Check for linters/formatters
-ls .rubocop.yml .eslintrc* .prettierrc* pyproject.toml rustfmt.toml .golangci.yml 2>/dev/null
-```
+### 3.5.1 Extract Commands (from package.json scripts already read)
 
-ANALYZE and DETERMINE:
-- `{namingConvention}` = based on actual file names
-- `{linter}` = what linter is configured
-- `{formatter}` = what formatter is used
+From `package.json.scripts`:
+- `{installCommand}` = `{packageManager} install`
+- `{devCommand}` = scripts.dev || scripts.start
+- `{testCommand}` = scripts.test
+- `{buildCommand}` = scripts.build
+- `{lintCommand}` = scripts.lint
 
-### 3.5.4 Detect Project Structure (AGENTIC)
+### 3.5.2 Detect Conventions (Single ls)
 
 ```bash
-ls -d */ 2>/dev/null | head -10
+ls .eslintrc* .prettierrc* tsconfig.json biome.json .editorconfig 2>/dev/null
 ```
 
-UNDERSTAND the structure:
-- Where is source code?
-- Where are tests?
-- Is it a monorepo?
-- What's the architecture?
-
-### 3.5.5 Generate Project-Specific Rules (AGENTIC)
-
-**Based on YOUR ANALYSIS, generate rules that make sense for THIS project.**
+SET: `{linter}` = eslint|biome, `{formatter}` = prettier|biome
 
-Think: "What does a developer working on this project need to know?"
-
-Examples:
-- Rails project: "Use `bundle exec` for Ruby commands", "Migrations: `rails db:migrate`"
-- Python/Poetry: "Use `poetry run` to run commands in venv"
-- Go project: "Use `go test ./...` to run all tests"
-- Rust project: "Use `cargo fmt` before commits"
-- Node/bun: "Use `bun` not npm - this project has bun.lockb"
-
-### 3.5.6 Write analysis/repo-analysis.json
-
-```bash
-mkdir -p {globalPath}/analysis
-```
+### 3.5.3 Write Analysis
 
 WRITE: `{globalPath}/analysis/repo-analysis.json`
-
 ```json
-{
-  "analyzedAt": "{timestamp}",
-  "ecosystem": "{ecosystem}",
-  "projectType": "{projectType}",
-  "commands": {
-    "install": "{installCommand}",
-    "run": "{runCommand}",
-    "test": "{testCommand}",
-    "build": "{buildCommand}",
-    "dev": "{devCommand}",
-    "lint": "{lintCommand}",
-    "format": "{formatCommand}"
-  },
-  "conventions": {
-    "naming": "{namingConvention}",
-    "linter": "{linter}",
-    "formatter": "{formatter}"
-  },
-  "structure": {
-    "srcDir": "{srcDir}",
-    "testDir": "{testDir}",
-    "isMonorepo": {isMonorepo}
-  },
-  "rules": [
-    "{rule1 - generated based on analysis}",
-    "{rule2 - generated based on analysis}",
-    "..."
-  ]
-}
+{"ecosystem":"{ecosystem}","packageManager":"{packageManager}","commands":{...},"linter":"{linter}"}
 ```
 
 ---
 
-## Step 4: Regenerate ALL Context Files
+## Step 4: Regenerate Context Files (PARALLEL READS)
+
+### 4.1 Read ALL Storage (PARALLEL)
 
-### 4.1 Read Storage (Source of Truth)
+**Read all 4 files in parallel (single tool call batch):**
 
-READ: `{globalPath}/storage/state.json`
-READ: `{globalPath}/storage/queue.json`
-READ: `{globalPath}/storage/ideas.json`
-READ: `{globalPath}/storage/shipped.json`
+READ (parallel):
+- `{globalPath}/storage/state.json` → `{state}`
+- `{globalPath}/storage/queue.json` → `{queue}`
+- `{globalPath}/storage/ideas.json` → `{ideas}`
+- `{globalPath}/storage/shipped.json` → `{shipped}`
 
 ### 4.2 Generate context/now.md
 
@@ -639,6 +479,44 @@ WRITE: `{globalPath}/project.json` (merge with existing, but ALWAYS update these
 
 ---
 
+## Step 6b: Update Global CLAUDE.md (CRITICAL)
+
+**ALWAYS update `~/.claude/CLAUDE.md`** with the latest prjct instructions.
+
+This ensures Claude has the newest features and commands available.
+
+### 6b.1 Read Current Global Config
+
+READ: `~/.claude/CLAUDE.md`
+
+### 6b.2 Read Template
+
+The template is at the prjct-cli install location. For development:
+READ: `templates/global/CLAUDE.md` (from the prjct-cli repo/package)
+
+### 6b.3 Intelligent Merge
+
+The file has markers:
+- `<!-- prjct:start - DO NOT REMOVE THIS MARKER -->`
+- `<!-- prjct:end - DO NOT REMOVE THIS MARKER -->`
+
+**IF markers exist in ~/.claude/CLAUDE.md:**
+1. Extract content BEFORE the start marker (user's custom content)
+2. Extract content AFTER the end marker (user's custom content)
+3. Replace the section between markers with template content
+4. Write merged content
+
+**IF no markers:**
+1. Append template content to end of file
+
+### 6b.4 Write Updated Config
+
+WRITE: `~/.claude/CLAUDE.md`
+
+OUTPUT: "📝 Updated ~/.claude/CLAUDE.md to v{cliVersion}"
+
+---
+
 ## Step 7: Generate Claude Code Sub-Agents (AGENTIC)
 
 Generate sub-agents for Claude Code in the GLOBAL storage `{globalPath}/agents/` directory.
@@ -675,240 +553,73 @@ This template contains:
 
 ### 7.3 Generate Workflow Agents (ALWAYS)
 
-These 3 agents are ALWAYS created for every prjct project.
-
-**CRITICAL: Each agent MUST include `agentId` in frontmatter.**
-
-The `agentId` format is: `p.agent.{name}` where `{name}` is derived from filename without `.md`.
-
-**prjct-workflow.md** - Handles: /p:now, /p:done, /p:next, /p:pause, /p:resume
-READ template: `templates/subagents/workflow/prjct-workflow.md`
-ADAPT with: projectId, projectPath
-ADD to frontmatter: `agentId: p.agent.workflow`
-WRITE to: `{globalPath}/agents/prjct-workflow.md`
-
-**prjct-planner.md** - Handles: /p:feature, /p:idea, /p:spec, /p:bug
-READ template: `templates/subagents/workflow/prjct-planner.md`
-ADAPT with: projectId, projectPath
-ADD to frontmatter: `agentId: p.agent.planner`
-WRITE to: `{globalPath}/agents/prjct-planner.md`
-
-**prjct-shipper.md** - Handles: /p:ship
-READ template: `templates/subagents/workflow/prjct-shipper.md`
-ADAPT with: projectId, projectPath, detected test/lint commands
-ADD to frontmatter: `agentId: p.agent.shipper`
-WRITE to: `{globalPath}/agents/prjct-shipper.md`
-
-### 7.4 Generate Domain Agents (Based on Stack)
-
-Analyze `{techStack}` from Step 3 and generate ONLY relevant domain agents:
+**Generate 3 workflow agents for every project:**
 
-| If Detected | Generate | Template | agentId |
-|-------------|----------|----------|---------|
-| React, Vue, Angular, Svelte, CSS | `frontend.md` | `templates/subagents/domain/frontend.md` | `p.agent.frontend` |
-| Node.js, Express, Go, Python API | `backend.md` | `templates/subagents/domain/backend.md` | `p.agent.backend` |
-| PostgreSQL, MySQL, MongoDB, Prisma | `database.md` | `templates/subagents/domain/database.md` | `p.agent.database` |
-| Docker, Kubernetes, GitHub Actions | `devops.md` | `templates/subagents/domain/devops.md` | `p.agent.devops` |
-| Bun test, Jest, Pytest, testing | `testing.md` | `templates/subagents/domain/testing.md` | `p.agent.testing` |
-| **{hasFrontendUI} = true** | `uxui.md` | `templates/agentic/agents/uxui.md` | `p.agent.uxui` |
+| Agent | agentId | Handles |
+|-------|---------|---------|
+| `prjct-workflow.md` | `p.agent.workflow` | /p:task, /p:done, /p:pause, /p:resume |
+| `prjct-planner.md` | `p.agent.planner` | /p:idea, /p:spec, /p:bug |
+| `prjct-shipper.md` | `p.agent.shipper` | /p:ship |
 
-For EACH detected stack:
-1. READ template from `templates/subagents/domain/{name}.md`
-2. ADAPT description with detected frameworks (e.g., "React specialist" not just "frontend")
-3. ADD to frontmatter: `agentId: p.agent.{name}` (e.g., `p.agent.backend`)
-4. WRITE to `{globalPath}/agents/{name}.md`
+READ templates from: `templates/subagents/workflow/`
+ADAPT with: projectId, projectPath, detected commands
+WRITE to: `{globalPath}/agents/`
 
-### 7.5 Generate UX/UI Agent (CRITICAL for Frontend Projects)
+### 7.4 Generate Domain Agents (AGENTIC)
 
-**Priority: UX > UI** - User experience is more important than visuals.
+**See:** `templates/guides/agent-generation.md` for complete instructions.
 
-IF `{hasFrontendUI}` == true:
+**Summary:**
+1. FIND representative files for each domain
+2. READ 3-5 files and EXTRACT real patterns
+3. GENERATE agents that enforce those patterns
 
-1. READ template: `templates/agentic/agents/uxui.md`
-2. WRITE to: `{globalPath}/agents/uxui.md`
-3. ADD to `{domainAgents}`: "uxui"
+**Domains to detect:**
 
-OUTPUT: "🎨 Generated UX/UI agent for {frontendType} ({frameworks detected})"
+| If Found | Generate | Temperature |
+|----------|----------|-------------|
+| React/Vue/Svelte | `frontend.md` | 0.3 |
+| Express/Fastify/Hono | `backend.md` | 0.2 |
+| Prisma/Drizzle/SQL | `database.md` | 0.1 |
+| Docker/K8s/Actions | `devops.md` | 0.2 |
+| Jest/Vitest/tests | `testing.md` | 0.2 |
+| UI + design system | `uxui.md` | 0.4 |
 
-The UX/UI agent ensures:
-- **UX First**: Clarity, feedback, reduced friction, error handling, accessibility
-- **Modern UI**: Distinctive typography, bold colors, purposeful animation
-- **Anti-patterns avoided**: No "AI slop" (Inter font, purple gradients, generic layouts)
-- **Checklists**: UX and UI quality gates before shipping
-
-### 7.6 Report Generated Agents
-
-Track which agents were generated for output:
-- `{workflowAgents}`: Always 3 (prjct-workflow, prjct-planner, prjct-shipper)
-- `{domainAgents}`: List of domain agents generated
-
----
-
-## Step 7.5: Install Claude Code Skills (AGENTIC)
-
-**CRITICAL: This step is AGENTIC. Search claude-plugins.dev dynamically to find the best skills.**
-
-Skills in Claude Code are markdown files in `~/.claude/skills/`. We search the marketplace and download the best matching skills for each agent.
-
-### 7.5.1 Check Existing Skills
-
-```bash
-ls ~/.claude/skills/*.md 2>/dev/null || echo "none"
+**Output per agent:**
 ```
-
-SET: `{existingSkills}` = list of installed skill files
-
-### 7.5.2 Search & Install Skills (AGENTIC)
-
-**For each generated agent, search claude-plugins.dev and install the best skill.**
-
+🤖 Generated: {agent}.md
+   Stack: {technologies}
+   Patterns: {count} from {files}
 ```
-{skillsToFind} = [
-  { agent: "frontend", searchTerms: ["frontend-design", "react", "ui components"] },
-  { agent: "uxui", searchTerms: ["ux-designer", "frontend-design", "ui ux"] },
-  { agent: "backend", searchTerms: ["{ecosystem} backend", "api design", "backend patterns"] },
-  { agent: "testing", searchTerms: ["testing", "test automation", "{ecosystem} testing"] },
-  { agent: "devops", searchTerms: ["devops", "ci cd", "docker kubernetes"] },
-  { agent: "prjct-planner", searchTerms: ["feature development", "architecture", "planning"] },
-  { agent: "prjct-shipper", searchTerms: ["code review", "pr review", "shipping"] }
-]
-
-FOR EACH entry in {skillsToFind}:
-  IF {entry.agent} IN {generatedAgents}:
-
-    # Step A: Search claude-plugins.dev
-    USE WebFetch:
-      url: "https://claude-plugins.dev/skills?q={entry.searchTerms[0]}"
-      prompt: "Find the best skill for {entry.agent}. Return: skill name, author, install URL"
-
-    SET: {searchResult} = result
-
-    # Step B: Analyze results and pick best match
-    ANALYZE {searchResult}:
-      - Prefer @anthropics skills (official)
-      - Prefer skills with high download count
-      - Match the agent's domain
-
-    SET: {bestSkill} = selected skill
-
-    # Step C: Check if already installed
-    IF {bestSkill.name}.md NOT IN {existingSkills}:
-
-      # Step D: Get skill content from GitHub
-      USE WebFetch:
-        url: "{bestSkill.githubUrl}/raw/main/skills/{bestSkill.name}.md"
-        prompt: "Get the complete skill markdown content"
-
-      SET: {skillContent} = result
-
-      # Step E: Install to ~/.claude/skills/
-      ```bash
-      mkdir -p ~/.claude/skills
-      ```
-
-      WRITE: `~/.claude/skills/{bestSkill.name}.md`
-      CONTENT: {skillContent}
-
-      OUTPUT: "📦 Installed skill: {bestSkill.name} (from {bestSkill.author})"
-      ADD {bestSkill} to {installedSkills}
-
-    ELSE:
-      OUTPUT: "✓ Skill exists: {bestSkill.name}"
-      ADD {bestSkill.name} to {verifiedSkills}
-```
-
-### 7.5.3 Skill Search Fallbacks
 
-If WebFetch fails or no results found:
-
-```
-FALLBACK SKILLS (use these if search fails):
-- frontend/uxui → "frontend-design" from @anthropics/claude-code
-- backend (JS/TS) → Search "typescript backend patterns"
-- backend (Python) → Search "python backend patterns"
-- testing → Search "testing automation"
-- devops → Search "devops ci cd"
-- planner → Search "architecture planning"
-- shipper → Search "code review"
-```
-
-### 7.5.4 Create Custom Skill if Not Found
-
-If no suitable skill found on marketplace, CREATE a minimal skill:
-
-```markdown
 ---
-name: {agent}-skill
-description: Custom skill for {agent} agent
----
-
-# {Agent} Skill
 
-This is a custom skill for the {agent} domain.
+### 7.5 Integrations (Skills + MCP) - CONDITIONAL
 
-## Expertise
-{Based on agent's domain - frontend, backend, etc.}
+**Only if agents were generated, configure integrations.**
 
-## Patterns
-{Common patterns for this domain}
-```
+See: `templates/guides/integrations.md`
 
-WRITE to: `~/.claude/skills/{agent}-custom.md`
+| Agent | Default Skill | MCP |
+|-------|---------------|-----|
+| frontend/uxui | `frontend-design` | context7 |
+| backend | - | context7 |
+| testing | - | - |
 
-### 7.5.5 Save Skills Configuration
+WRITE: `{globalPath}/config/skills.json` (if skills configured)
 
-```bash
-mkdir -p {globalPath}/config
-```
+---
 
-WRITE: `{globalPath}/config/skills.json`
+### 7.6 Scan Quick Commands
 
-```json
-{
-  "projectId": "{projectId}",
-  "ecosystem": "{ecosystem}",
-  "installedAt": "{GetTimestamp()}",
-  "searchedAt": "{GetTimestamp()}",
-  "skills": [
-    {
-      "name": "{skill.name}",
-      "source": "{skill.source}",
-      "author": "{skill.author}",
-      "path": "~/.claude/skills/{skill.name}.md",
-      "linkedAgents": ["{agents that use this skill}"]
-    }
-  ],
-  "agentSkillMap": {
-    "{agent}": "{skill.name}"
-  }
-}
+```bash
+ls ~/.prjct-cli/commands/*.md 2>/dev/null | head -20
 ```
 
-### 7.5.6 Update Agent Frontmatter
-
-FOR EACH agent file in `{globalPath}/agents/`:
-  READ agent file
-  GET skill from agentSkillMap[agent.name]
-
-  IF skill exists AND frontmatter.skills is missing:
-    UPDATE frontmatter to include: `skills: [{skill}]`
-    WRITE updated agent file
-
-### 7.5.7 Output Summary
-
-```
-SET: {skillsInstalled} = list of newly installed
-SET: {skillsVerified} = list of already existing
-SET: {skillsCreated} = list of custom-created
-SET: {totalSkills} = count of all
-
-OUTPUT:
-📦 Skills Synchronized
-├── Installed: {skillsInstalled.length} new from marketplace
-├── Verified: {skillsVerified.length} already exist
-├── Created: {skillsCreated.length} custom skills
-└── Location: ~/.claude/skills/
-```
+IF files found:
+  SET: `{quickCommandCount}` = count
+  FOR EACH file: extract `description` from frontmatter
+  SET: `{quickCommandList}` = [{name, description}, ...]
 
 ---
 
@@ -917,7 +628,7 @@ OUTPUT:
 APPEND to: `{globalPath}/memory/events.jsonl`
 
 ```json
-{"ts":"{GetTimestamp()}","action":"sync","branch":"{currentBranch}","uncommitted":{hasUncommittedChanges},"fileCount":{fileCount},"commitCount":{commitCount}}
+{"ts":"{GetTimestamp()}","action":"sync","branch":"{currentBranch}","uncommitted":{hasUncommittedChanges},"fileCount":{fileCount},"commitCount":{commitCount},"tokensUsed":{totalContextTokens}}
 ```
 
 ---
@@ -968,86 +679,22 @@ IF cloudSync AND no syncError:
 
 ---
 
-## Output
+## Output (Compact)
 
 ```
-🔄 Project synced to prjct v{cliVersion}
-
-📊 Project Stats
-├── Files: {fileCount}
-├── Commits: {commitCount}
-├── Version: {version}
-└── Stack: {stack}
-
-🌿 Git Status
-├── Branch: {currentBranch}
-├── Uncommitted: {hasUncommittedChanges ? "Yes - " + modifiedCount + " files" : "Clean"}
-└── Recent: {recentCommitCount} commits this week
-
-📁 Context Updated
-├── context/now.md
-├── context/next.md
-├── context/ideas.md
-├── context/shipped.md
-└── context/CLAUDE.md
-
-🤖 Agents Regenerated ({workflowAgents.length + domainAgents.length})
-├── Workflow: prjct-workflow, prjct-planner, prjct-shipper
-├── Domain: {domainAgents.join(', ') || 'none'}
-{IF hasFrontendUI}
-└── 🎨 UX/UI: uxui.md (Priority: UX > UI)
-{ENDIF}
-
-🏷️ Agent Mentions (use in prompts)
-├── p.agent.workflow, p.agent.planner, p.agent.shipper
-{IF domainAgents.length > 0}
-├── {domainAgents.map(a => 'p.agent.' + a).join(', ')}
-{ENDIF}
-└── Example: "p.agent.backend help me create an API endpoint"
-
-📦 Skills ({totalSkills})
-├── Installed: {skillsInstalled.length ? skillsInstalled.join(', ') : 'none'}
-├── Verified: {skillsVerified.length ? skillsVerified.join(', ') : 'none'}
-└── Config: {globalPath}/config/skills.json
-
-🔗 Agent → Skill Mapping
-{FOR EACH entry in agentSkillMap WHERE entry.skill != null}
-├── {entry.agent}.md → /{entry.skill}
-{END FOR}
-
-{IF isVersionUpgrade}
-✨ New Features Available in v{cliVersion}:
+🔄 {projectName} v{version} | {ecosystem} | prjct v{cliVersion}
 
-• /p:task - Unified task command with agentic classification
-• Automatic type detection (feature, bug, improvement, refactor, chore)
-• 7-phase development workflow for all task types
-• Git branch management with type-based prefixes
-• UX/UI design workflow for frontend tasks
-• Design expert integration
+{currentBranch} {hasUncommittedChanges ? "⚠️" : "✓"} | {fileCount} files | {commitCount} commits
 
-Note: /p:now and /p:feature are deprecated. Use /p:task instead.
-{ENDIF}
-
-{IF cloudSync}
-☁️ Cloud Sync
-├── Pushed: {pushedCount} events
-├── Pulled: {pulledCount} updates
-└── Status: {syncError ? "⚠️ " + syncError : "✓ Synced"}
-{ELSE}
-💡 Cloud sync disabled. Run `prjct auth` to enable.
-{ENDIF}
+🤖 Agents: {domainAgents.join(', ') || 'workflow only'}
+{IF quickCommandCount > 0}⚡ Commands: {quickCommandList.map(c => c.name).join(', ')}{ENDIF}
+{IF cloudSync}☁️ {pushedCount}↑ {pulledCount}↓{ENDIF}
 
-{IF hasUncommittedChanges}
-⚠️  You have uncommitted changes
-
-Next: Commit your work or continue coding
-{ELSE}
-✨ Repository is clean!
-
-Next: /p:task "your next task"
-{ENDIF}
+Next: p. task "description"
 ```
 
+**Keep output under 6 lines unless errors occur.**
+
 ---
 
 ## Error Handling
@@ -1064,35 +711,25 @@ Next: /p:task "your next task"
 ## File Structure Reference
 
 ```
-~/.prjct-cli/projects/{projectId}/
-├── storage/                  # Source of Truth (JSON)
-│   ├── state.json           # Current + paused task
-│   ├── queue.json           # Task queue
-│   ├── ideas.json           # Ideas list
-│   └── shipped.json         # Shipped features
-├── context/                  # For Claude (MD)
-│   ├── CLAUDE.md            # Full context
-│   ├── now.md               # Current task
-│   ├── next.md              # Queue
-│   ├── ideas.md             # Ideas
-│   └── shipped.md           # Shipped
-├── config/                   # Configuration (NEW)
-│   └── skills.json          # Agent-to-skill mappings
-├── sync/                     # Backend Sync
-│   └── pending.json         # Events queue
-├── agents/                   # Specialists
-├── memory/                   # Audit Trail
-│   └── events.jsonl
-└── project.json             # Metadata
-
-# Sub-Agents are in {globalPath}/agents/ (NOT in project .claude/)
-├── prjct-workflow.md        # /p:now, /p:done, /p:next
-├── prjct-planner.md         # /p:feature, /p:idea, /p:spec
-├── prjct-shipper.md         # /p:ship
-├── frontend.md              # (if React/Vue/Angular detected)
-├── backend.md               # (if Node/Go/Python API detected)
-├── database.md              # (if DB detected)
-├── devops.md                # (if Docker/K8s detected)
-├── testing.md               # (if test framework detected)
-└── uxui.md                  # (if ANY frontend UI detected - web or mobile)
+~/.prjct-cli/
+├── commands/         # User Quick Commands (global, priority over built-in)
+│   └── {command}.md  # Custom command templates
+└── projects/{projectId}/
+    ├── storage/      # Source of Truth: state.json, queue.json, ideas.json, shipped.json
+    ├── context/      # Claude Context: CLAUDE.md, now.md, next.md, ideas.md, shipped.md
+    ├── config/       # Config: skills.json, mcp-servers.json, slash-commands.json
+    ├── agents/       # Domain agents: prjct-*.md, frontend.md, backend.md, etc.
+    ├── analysis/     # repo-analysis.json
+    ├── memory/       # events.jsonl
+    ├── sync/         # pending.json
+    └── project.json  # Metadata + cliVersion
+```
+
+**Agent Frontmatter (v0.28+):**
+```yaml
+name: backend
+agentId: p.agent.backend
+skills: [skill-name]      # Auto-invoked
+mcp: [context7]           # Auto-used
+generatedAt: {timestamp}  # For refresh detection
 ```