prjct-cli 0.35.3 → 0.35.4

package/templates/agentic/subagent-generation.md

@@ -1,127 +1,54 @@
 # Sub-Agent Generation
 
-Generate Claude Code sub-agents for this project based on detected stack.
-
-## Input Context
-
-You have access to:
-- `{analysis}` - repo-summary.md with detected technologies
-- `{projectPath}` - Path to project root
-- `{projectId}` - Project identifier
+Generate project-specific agents based on detected stack.
 
 ## Output Location
 
-Write sub-agents to: `{globalPath}/agents/` (global storage, NOT local project)
+`{globalPath}/agents/` (NEVER local project)
 
-## Sub-Agent Format (Claude Code)
+## Agent Format
 
 ```markdown
 ---
 name: agent-name
-description: When to use this agent. Include "Use PROACTIVELY" for auto-invocation.
+description: When to use. Include "Use PROACTIVELY" for auto-invoke.
 tools: Read, Write, Glob, Grep, Bash
 model: sonnet
 skills: [skill-name]
 ---
-
-Agent system prompt here...
+Agent prompt...
 ```
 
-**The `skills` field links the agent to Claude Code skills from claude-plugins.dev.**
-
-## Generation Rules
-
-### 1. ALWAYS Generate Workflow Agents
-
-These are REQUIRED for every prjct project:
-
-#### prjct-workflow.md
-- Commands: /p:now, /p:done, /p:next, /p:pause, /p:resume
-- Tools: Read, Write, Glob
-- Purpose: Task lifecycle management
-
-#### prjct-planner.md
-- Commands: /p:feature, /p:idea, /p:spec, /p:bug
-- Tools: Read, Write, Glob, Grep
-- Purpose: Feature planning and breakdown
-
-#### prjct-shipper.md
-- Commands: /p:ship
-- Tools: Read, Write, Bash, Glob
-- Purpose: Git operations, testing, deployment
-
-### 2. Generate Domain Agents Based on Stack
-
-Analyze `{analysis}` and create ONLY relevant domain agents:
-
-| If Detected | Generate | Tools | Skill |
-|-------------|----------|-------|-------|
-| React, Vue, Angular, Svelte, CSS, HTML | `frontend.md` | Read, Write, Glob, Grep | `frontend-design` |
-| Node.js, Express, Go, Python API, REST, GraphQL | `backend.md` | Read, Write, Bash, Glob, Grep | `javascript-typescript` or `python-development` |
-| PostgreSQL, MySQL, MongoDB, Redis, Prisma | `database.md` | Read, Write, Bash | (none) |
-| Docker, Kubernetes, CI/CD, GitHub Actions | `devops.md` | Read, Bash, Glob | `developer-kit` |
-| Bun test, Jest, Pytest, Testing Library | `testing.md` | Read, Write, Bash | `developer-kit` |
-| ANY frontend UI (web or mobile) | `uxui.md` | Read, Write, Glob, Grep | `frontend-design` |
-
-### 3. Adapt to Project Context
-
-Each generated agent should include:
-- Project-specific paths from analysis
-- Detected frameworks and versions
-- Relevant patterns found in codebase
-
-## Execution Steps
-
-1. **Read Analysis**
-   ```
-   Read("{globalPath}/analysis/repo-summary.md")
-   ```
+## Required Workflow Agents
 
-2. **Create Directory**
-   ```
-   Bash("mkdir -p {globalPath}/agents")
-   ```
+| Agent | Purpose | Skill |
+|-------|---------|-------|
+| prjct-workflow.md | Task lifecycle | - |
+| prjct-planner.md | Feature planning | feature-dev |
+| prjct-shipper.md | Git, deploy | code-review |
 
-3. **Generate Workflow Agents** (always)
-   - Read template from `templates/subagents/workflow/prjct-workflow.md`
-   - Adapt with project context
-   - Write to `{globalPath}/agents/prjct-workflow.md`
-   - Repeat for prjct-planner.md and prjct-shipper.md
+## Domain Agents (based on stack)
 
-4. **Generate Domain Agents** (based on analysis)
-   - For each detected technology stack:
-     - Read corresponding template from `templates/subagents/domain/`
-     - Adapt with project-specific details
-     - Write to `{globalPath}/agents/`
+| If Detected | Generate | Skill |
+|-------------|----------|-------|
+| React, Vue, CSS | frontend.md | frontend-design |
+| Node, Express, API | backend.md | javascript-typescript |
+| PostgreSQL, MongoDB | database.md | - |
+| Docker, CI/CD | devops.md | developer-kit |
+| Jest, Pytest | testing.md | developer-kit |
+| Any UI | uxui.md | frontend-design |
 
-5. **Link Skills to Agents**
-   - Read `templates/config/skill-mappings.json`
-   - For each generated agent, add the corresponding skill to frontmatter
-   - Skill mappings:
-     - `frontend.md` → `skills: [frontend-design]`
-     - `uxui.md` → `skills: [frontend-design]`
-     - `backend.md` → `skills: [javascript-typescript]` (or `python-development` for Python)
-     - `testing.md` → `skills: [developer-kit]`
-     - `devops.md` → `skills: [developer-kit]`
-     - `prjct-planner.md` → `skills: [feature-dev]`
-     - `prjct-shipper.md` → `skills: [code-review]`
+## Execution
 
-6. **Report Generated Agents**
-   ```
-   Generated sub-agents in {globalPath}/agents/:
-   - prjct-workflow.md (workflow)
-   - prjct-planner.md (workflow) → /feature-dev
-   - prjct-shipper.md (workflow) → /code-review
-   - frontend.md (detected: React) → /frontend-design
-   - backend.md (detected: Node.js) → /javascript-typescript
-   ```
+1. Read `{globalPath}/analysis/repo-summary.md`
+2. Create `{globalPath}/agents/` directory
+3. Generate workflow agents (always)
+4. Generate domain agents (based on analysis)
+5. Add skills to frontmatter
+6. Report generated agents
 
-## Critical Rules
+## Rules
 
-- **NEVER write agents to local project directories** (`.claude/`, `.prjct/`)
-- **ALWAYS write agents to `{globalPath}/agents/`** (global storage)
-- NEVER hardcode technology detection in TypeScript
-- ALWAYS read and analyze repo-summary.md
-- ADAPT templates to project context
-- Use Claude Code frontmatter format exactly
-- Include "Use PROACTIVELY" in descriptions for auto-invocation
+- **ALWAYS** write to `{globalPath}/agents/`
+- **NEVER** write to `.claude/` or `.prjct/`
+- Adapt templates to project context

package/templates/agentic/task-fragmentation.md

@@ -1,323 +1,89 @@
 # Task Fragmentation
 
-**Purpose**: Break complex multi-domain tasks into subtasks for specialist agents.
+Break complex multi-domain tasks into subtasks.
 
 ## When to Fragment
 
-Fragment a task when:
-- It spans multiple domains (frontend + backend + database)
-- It would require loading 3+ agents for one-shot execution
-- One-shot implementation would saturate context
-- The task has natural dependency order
-- Complex enough that specialist focus improves quality
+- Spans 3+ domains (frontend + backend + database)
+- Has natural dependency order
+- Too large for single execution
 
 ## When NOT to Fragment
 
-Keep as single task when:
 - Single domain only
 - Small, focused change
 - Already atomic
-- User explicitly requests one-shot execution
 
----
+## Dependency Order
 
-## Fragmentation Algorithm
-
-### Input
-
-```
-Task: "{task description}"
-Available Agents: [list from {agentsDir}]
-Project Tech: {from repo-analysis.json}
-```
-
-### Process
-
-#### 1. Parse Intent
-
-What is the user trying to achieve?
-What are the moving parts?
-
-#### 2. Identify Components
-
-| Component | Domain | Indicator Keywords |
-|-----------|--------|-------------------|
-| Data layer changes | database | schema, migration, table, query, model |
-| API changes | backend | endpoint, API, route, controller, auth |
-| UI changes | frontend | component, form, page, UI, layout, styling |
-| Test changes | testing | test, spec, coverage, TDD |
-| Deploy changes | devops | deploy, CI/CD, pipeline, container |
-
-#### 3. Check Agent Availability
-
-For each identified component:
-- Does a matching agent exist in `{agentsDir}`?
-- If YES → Create subtask for that agent
-- If NO → Mark for generalist execution (rare)
-
-**Remember**: Agents in `{agentsDir}` are ALREADY project-specific (generated during `p. sync`). Don't second-guess whether they "match" the technology.
-
-#### 4. Order by Dependencies
-
-Typical dependency order:
-1. **Database** (data models first)
+1. **Database** (models first)
 2. **Backend** (API using models)
 3. **Frontend** (UI using API)
 4. **Testing** (tests for all)
-5. **DevOps** (deploy everything)
+5. **DevOps** (deploy)
 
-#### 5. Create Subtask Objects
+## Subtask Format
 
 ```json
 {
-  "subtasks": [
-    {
-      "id": "subtask-1",
-      "description": "Create users table schema",
-      "domain": "database",
-      "agent": "database.md",
-      "dependsOn": [],
-      "expectedOutput": "Migration file created"
-    },
-    {
-      "id": "subtask-2",
-      "description": "Create auth API endpoints",
-      "domain": "backend",
-      "agent": "backend.md",
-      "dependsOn": ["subtask-1"],
-      "expectedOutput": "Auth routes implemented"
-    },
-    {
-      "id": "subtask-3",
-      "description": "Create login form component",
-      "domain": "frontend",
-      "agent": "frontend.md",
-      "dependsOn": ["subtask-2"],
-      "expectedOutput": "Login form component"
-    }
-  ]
+  "subtasks": [{
+    "id": "subtask-1",
+    "description": "Create users table",
+    "domain": "database",
+    "agent": "database.md",
+    "dependsOn": []
+  }]
 }
 ```
 
----
-
-## Output Format
-
-Report fragmentation plan before executing:
+## Output
 
 ```
-🎯 Task: {original task}
-
-📋 Subtasks (ordered by dependencies):
-├─ 1. [database] Create users table schema
-├─ 2. [backend] Create auth API endpoints
-└─ 3. [frontend] Create login form
+🎯 Task: {task}
 
-🤖 Agents to invoke: database, backend, frontend
+📋 Subtasks:
+├─ 1. [database] Create schema
+├─ 2. [backend] Create API
+└─ 3. [frontend] Create form
 ```
 
----
-
-## Delegation Pattern
-
-For each subtask, delegate via Task tool:
+## Delegation
 
 ```
 Task(
   subagent_type: 'general-purpose',
   prompt: '
-    ## Agent Assignment
-    Read and apply: {agentsPath}/{domain}.md
-
-    ## Subtask
-    {subtask.description}
-
-    ## Dependencies
-    {list completed subtasks and their summaries}
-
-    ## Previous Subtask Output
-    {previousSubtask.summary if available}
-
-    ## Expected Output
-    {subtask.expectedOutput}
-
-    ## MANDATORY: Summary on Completion
-
-    When you complete this subtask, provide a summary:
-
-    ### Summary
-    [1-2 sentence description of what you did]
-
-    ### Files Created/Modified
-    [Table of files with actions]
-
-    ### What Was Done
-    [Numbered list of concrete actions]
-
-    ### Output for Next Agent
-    [What the next agent can use from your work]
-
-    ### Notes for Integration
-    [Any important notes for integration]
-
-    ## IMPORTANT
+    Read: {agentsPath}/{domain}.md
+    Subtask: {description}
+    Previous: {previousSummary}
     Focus ONLY on this subtask.
-    Do NOT implement other parts.
-    Return when this subtask is complete.
   '
 )
 ```
 
----
-
-## Summary Storage
-
-After each subtask completes, the summary is stored in `storage/state.json`:
-
-```json
-{
-  "currentTask": {
-    "subtasks": [{
-      "id": "subtask-1",
-      "status": "completed",
-      "summary": {
-        "title": "Create auth schema",
-        "description": "Created database schema for user authentication",
-        "filesChanged": [
-          { "path": "prisma/schema.prisma", "action": "modified" }
-        ],
-        "whatWasDone": [
-          "Added User model",
-          "Added Session model"
-        ],
-        "outputForNextAgent": "User and Session models available via Prisma",
-        "notes": "Use bcrypt for password hashing"
-      }
-    }]
-  }
-}
-```
-
----
-
-## Context Handoff
-
-Each subsequent subtask receives the previous subtask's summary:
-
-```
-## Previous Subtask Summary (CONTEXT)
-${previousSubtask.summary}
-
-## What's Available
-- User model (prisma.user)
-- Session model (prisma.session)
-- Notes: Use bcrypt for passwords
-
-## Your Task
-Create auth API endpoints using the models from subtask 1.
-```
-
----
-
-## Progress Tracking
-
-The orchestrator updates progress after each subtask:
-
-```
-📊 Progress: 2/4 subtasks (50%)
-
-✅ 1. [database] Create auth schema
-✅ 2. [backend] Create auth API
-▶️ 3. [frontend] Create login form ← CURRENT
-⏳ 4. [testing] Add auth tests
-```
-
----
-
-## Aggregating Results
-
-After all subtasks complete, report aggregated status:
+## Progress
 
 ```
-✅ Task Complete: add user authentication
-
-📋 Subtasks Completed:
-├─ ✅ 1. [database] Create auth schema
-│      Files: prisma/schema.prisma
-│
-├─ ✅ 2. [backend] Create auth API
-│      Files: src/routes/auth.ts, src/middleware/auth.ts
-│
-├─ ✅ 3. [frontend] Create login form
-│      Files: src/components/LoginForm.tsx
-│
-└─ ✅ 4. [testing] Add auth tests
-       Files: tests/auth.test.ts
-
-📁 Total files affected: 5
-⏱️ Total duration: {calculated from subtask times}
+📊 Progress: 2/4 (50%)
+✅ 1. [database] Done
+✅ 2. [backend] Done
+▶️ 3. [frontend] ← CURRENT
+⏳ 4. [testing]
 ```
 
----
-
 ## Error Handling
 
-If a subtask fails:
-
 ```
-❌ Subtask 2/4 failed: Create auth API
-
-Error: Database connection failed
+❌ Subtask 2/4 failed
 
 Options:
-1. Retry this subtask
-2. Skip and continue with remaining subtasks
-3. Abort task and rollback
-
-What would you like to do?
-```
-
-Use `AskUserQuestion` to get user decision on failure handling.
-
----
-
-## Anti-Patterns to Avoid
-
-### 1. Over-fragmentation
-```
-❌ WRONG: 10 subtasks for "add login button"
-✅ RIGHT: Single task (already atomic)
-```
-
-### 2. Under-fragmentation
+1. Retry
+2. Skip and continue
+3. Abort
 ```
-❌ WRONG: 1 subtask for "add complete auth system"
-✅ RIGHT: 4 subtasks (database, backend, frontend, testing)
-```
-
-### 3. Wrong Dependency Order
-```
-❌ WRONG: Frontend before backend (depends on API)
-✅ RIGHT: Database → Backend → Frontend
-```
-
-### 4. Missing Summaries
-```
-❌ WRONG: Subtask completes without summary
-✅ RIGHT: Every subtask generates structured summary
-```
-
----
-
-## Integration with Storage
-
-The subtasks are stored in `storage/state.json` under `currentTask.subtasks`.
 
-Key methods available:
-- `stateStorage.createSubtasks(projectId, subtasks)` - Create subtasks
-- `stateStorage.completeSubtask(projectId, output, summary)` - Complete current subtask
-- `stateStorage.getCurrentSubtask(projectId)` - Get current subtask
-- `stateStorage.getNextSubtask(projectId)` - Get next subtask
-- `stateStorage.getSubtaskProgress(projectId)` - Get progress
+## Anti-Patterns
 
-These are called by the orchestrator as subtasks are processed.
+- Over-fragmentation: 10 subtasks for "add button"
+- Under-fragmentation: 1 subtask for "add auth system"
+- Wrong order: Frontend before backend