prjct-cli 0.10.13 → 0.10.14

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.10.14] - 2025-11-29
+
+### Refactored - 100% Agentic Subagent Delegation via Task Tool
+
+Claude now delegates to specialist agents using the Task tool with efficient reference passing.
+
+- **`command-executor.js`** - Eliminated all if/else agent assignment logic
+  - Removed: `MandatoryAgentRouter`, `ContextFilter`, `ContextEstimator`
+  - Removed: `isTaskCommand()`, `shouldUseAgent()` methods
+  - JS only loads templates and context, Claude decides everything
+  - Added: `agentsPath` and `agentRoutingPath` to context for Claude
+
+- **Templates updated with Agent Delegation section**:
+  - `feature.md` - Added Task + Glob tools, agent delegation instructions
+  - `bug.md` - Added Task + Glob tools, agent delegation instructions
+  - `task.md` - Added Task + Glob tools, agent delegation instructions
+
+- **`agent-routing.md`** - Added efficient Task tool invocation
+  - Pass file PATH (~200 bytes), not content (3-5KB)
+  - Subagent reads agent file itself
+  - Reduced context bloat by 95%
+
+### Architecture
+
+```
+Usuario: "p. feature mejorar UX"
+    ↓
+Claude lee agent-routing.md → decide: "ux-ui"
+    ↓
+Claude: Task(prompt='Read: path/agents/ux-ui.md + Task: mejorar UX')
+    ↓
+Subagente: Lee archivo → aplica expertise → ejecuta
+```
+
+**Benefits:**
+- 95% reduction in prompt size for delegation
+- Lower hallucination risk
+- True 100% agentic - JS is pure orchestration
+
 ## [0.10.12] - 2025-11-29
 
 ### Refactored - Mandatory Agent Assignment (100% Agentic)

package/CLAUDE.md

@@ -55,8 +55,14 @@ p. ship       → Lint/test/commit/push
 
 When message starts with `p.`:
 1. Check `.prjct/prjct.config.json` exists
-2. If exists → Detect intent → Execute `/p:*` command
-3. If not exists → "No prjct project. Run /p:init first."
+2. Detect intent from message
+3. **USE SlashCommand tool** to execute the command
+
+⚠️ **CRITICAL** - Always use SlashCommand, never work directly:
+- ✅ `SlashCommand("/p:feature add dark mode")`
+- ❌ Directly creating files without the command
+
+If no project: "No prjct project. Run /p:init first."
 
 ### Intent Map
 
@@ -201,3 +207,42 @@ Use: `generator.generateDynamicAgent(name, config)`
 4. **Confirm before executing** - Always show plan first
 5. **Log actions** - Append to memory/context.jsonl
 6. **Suggest next actions** - Maintain user momentum
+
+## Output Philosophy
+
+**Task completion responses MUST be concise (< 4 lines):**
+
+Format:
+```
+✅ [What was done]
+
+Files: [count] | Modified: [key file]
+Next: [action]
+```
+
+**NEVER include in task summaries:**
+- Tables listing files
+- "Created Files" / "Modified Files" sections
+- "How It Works" explanations
+- Code snippets or implementation details
+- Detailed breakdowns of what was done
+
+**Example (GOOD):**
+```
+✅ Agentic checklists integrated
+
+Files: 11 created | Modified: prompt-builder.js
+Next: /p:ship or test with /p:now
+```
+
+**Example (BAD):**
+```
+Created Files:
+| File | Purpose |
+|------|---------|
+| x.md | Does X  |
+...
+
+How It Works:
+Claude reads → decides → applies...
+```

package/core/agentic/command-executor.js

@@ -1,16 +1,19 @@
 /**
  * Command Executor
- * WITH MANDATORY AGENT ASSIGNMENT
- * Every task MUST use a specialized agent
+ * 100% AGENTIC - Claude decides agent assignment via Task tool
  *
- * OPTIMIZATION (P0.2): Explicit Validation
- * - Pre-flight checks before execution
- * - Specific error messages, never generic failures
- * - Actionable suggestions in every error
+ * NO if/else logic for agent selection here.
+ * Claude reads templates/agentic/agent-routing.md and delegates via Task tool.
  *
- * P3.4: Plan Mode + Approval Flow
- * - Separates planning from execution
- * - Requires approval for destructive commands
+ * JS only:
+ * - Loads templates
+ * - Builds context
+ * - Returns prompt for Claude
+ *
+ * Claude:
+ * - Reads agent-routing.md
+ * - Decides best agent for task
+ * - Delegates via Task(subagent_type='general-purpose', prompt='Read: path/to/agent.md...')
  *
  * Source: Claude Code, Devin, Augment Code patterns
  */
@@ -22,9 +25,8 @@ const templateLoader = require('./template-loader')
 const contextBuilder = require('./context-builder')
 const promptBuilder = require('./prompt-builder')
 const toolRegistry = require('./tool-registry')
-const MandatoryAgentRouter = require('./agent-router')
-const ContextFilter = require('./context-filter')
-const ContextEstimator = require('../domain/context-estimator')
+// REMOVED: MandatoryAgentRouter, ContextFilter, ContextEstimator
+// Agent assignment is 100% agentic - Claude decides via templates
 const { validate, formatError } = require('./validation-rules')
 const loopDetector = require('./loop-detector')
 const chainOfThought = require('./chain-of-thought')
@@ -45,9 +47,8 @@ const RUNNING_FILE = path.join(os.homedir(), '.prjct-cli', '.running')
 
 class CommandExecutor {
   constructor() {
-    this.agentRouter = new MandatoryAgentRouter()
-    this.contextFilter = new ContextFilter()
-    this.contextEstimator = null
+    // 100% AGENTIC: No agent router here
+    // Claude decides agent assignment via templates and Task tool
   }
 
   /**
@@ -173,72 +174,18 @@ class CommandExecutor {
         }
       }
 
-      // 3. CRITICAL: Force agent assignment for ALL task-related commands
-      const requiresAgent = template.metadata?.['required-agent'] !== false &&
-                           (template.metadata?.['required-agent'] === true ||
-                            this.isTaskCommand(commandName) ||
-                            this.shouldUseAgent(commandName))
-
+      // 3. AGENTIC: Claude decides agent assignment via templates
+      // NO if/else logic here - templates instruct Claude to use Task tool
+      // See templates/agentic/agent-routing.md for routing rules
       let context = metadataContext
-      let assignedAgent = null
-
-      // MANDATORY: Assign specialized agent for task commands
-      if (requiresAgent) {
-        // 4. Create task object for analysis
-        const task = {
-          description: params.task || params.description || commandName,
-          type: commandName
-        }
-
-        // 5. LAZY CONTEXT: Analyze task FIRST, then estimate files needed
-        // This avoids reading all files before knowing what we need
-        const agentAssignment = await this.agentRouter.executeTask(
-          task,
-          metadataContext, // Only metadata, no files yet
-          projectPath
-        )
-
-        assignedAgent = agentAssignment.agent
-        const taskAnalysis = agentAssignment.taskAnalysis
-
-        // Validate agent was assigned
-        if (!assignedAgent || !assignedAgent.name) {
-          throw new Error(
-            `CRITICAL: Failed to assign agent for command "${commandName}". ` +
-            `System requires ALL task commands to use specialized agents.`
-          )
-        }
-
-        // 6. PRE-FILTER: Estimate which files are needed BEFORE reading
-        if (!this.contextEstimator) {
-          this.contextEstimator = new ContextEstimator()
-        }
-
-        const estimatedFiles = await this.contextEstimator.estimateFiles(
-          taskAnalysis,
-          projectPath
-        )
 
-        // 7. Build context ONLY with estimated files (lazy loading)
-        const filtered = await this.contextFilter.filterForAgent(
-          assignedAgent,
-          task,
-          projectPath,
-          {
-            ...metadataContext,
-            estimatedFiles, // Pre-filtered file list
-            fileCount: estimatedFiles.length
-          }
-        )
-
-        context = {
-          ...filtered,
-          agent: assignedAgent,
-          originalSize: estimatedFiles.length, // Estimated, not actual full size
-          filteredSize: filtered.files?.length || 0,
-          reduction: filtered.metrics?.reductionPercent || 0,
-          lazyLoaded: true // Flag indicating lazy loading was used
-        }
+      // Provide agent info to context so Claude can delegate
+      context = {
+        ...context,
+        agentsPath: path.join(os.homedir(), '.prjct-cli', 'projects', metadataContext.projectId || '', 'agents'),
+        agentRoutingPath: path.join(__dirname, '..', '..', 'templates', 'agentic', 'agent-routing.md'),
+        // Flag: Claude must delegate to subagent via Task tool
+        agenticDelegation: true
       }
 
       // 6. Load state with filtered context
@@ -285,7 +232,7 @@ class CommandExecutor {
         )
       }
 
-      // 9. Build prompt with agent assignment, learned patterns, think blocks, memories, AND plan mode
+      // 9. Build prompt - NO agent assignment here, Claude decides via templates
       const planInfo = {
         isPlanning: requiresPlanning || isInPlanningMode,
         requiresApproval: isDestructive && !params.approved,
@@ -295,13 +242,11 @@ class CommandExecutor {
           template.frontmatter['allowed-tools'] || []
         )
       }
-      const prompt = promptBuilder.build(template, context, state, assignedAgent, learnedPatterns, thinkBlock, relevantMemories, planInfo)
+      // Agent is null - Claude assigns via Task tool using agent-routing.md
+      const prompt = promptBuilder.build(template, context, state, null, learnedPatterns, thinkBlock, relevantMemories, planInfo)
 
-      // 8. Log agent usage
-      if (assignedAgent) {
-        console.log(`🤖 Task assigned to: ${assignedAgent.name}`)
-        console.log(`📉 Context reduced by: ${context.reduction}%`)
-      }
+      // Log agentic mode
+      console.log(`🤖 Agentic delegation enabled - Claude will assign agent via Task tool`)
 
       // Record successful attempt
       loopDetector.recordSuccess(commandName, loopContext)
@@ -315,8 +260,10 @@ class CommandExecutor {
         context,
         state,
         prompt,
-        assignedAgent,
-        contextReduction: context.reduction,
+        // AGENTIC: No pre-assigned agent - Claude delegates via Task tool
+        agenticDelegation: true,
+        agentsPath: context.agentsPath,
+        agentRoutingPath: context.agentRoutingPath,
         reasoning, // Chain of thought results
         thinkBlock, // Think blocks (P3.1)
         groundTruth: groundTruthResult, // Ground truth verification (P1.3)
@@ -406,30 +353,9 @@ class CommandExecutor {
     }
   }
 
-  /**
-   * Check if command is task-related
-   */
-  isTaskCommand(commandName) {
-    const taskCommands = [
-      'work', 'now', 'build', 'feature', 'bug', 'done',
-      'task', 'design', 'cleanup', 'fix', 'test'
-    ]
-    return taskCommands.includes(commandName)
-  }
-
-  /**
-   * Determine if command should use an agent
-   * Expanded list of commands that benefit from agent specialization
-   */
-  shouldUseAgent(commandName) {
-    // Commands that should ALWAYS use agents
-    const agentCommands = [
-      'work', 'now', 'build', 'feature', 'bug', 'done',
-      'task', 'design', 'cleanup', 'fix', 'test',
-      'sync', 'analyze' // These analyze/modify code, need specialization
-    ]
-    return agentCommands.includes(commandName)
-  }
+  // REMOVED: isTaskCommand() and shouldUseAgent()
+  // Agent assignment is now 100% agentic - Claude decides via templates
+  // See templates/agentic/agent-routing.md
 
   /**
    * Execute tool with permission check

package/core/agentic/prompt-builder.js

@@ -7,9 +7,65 @@
  * P3.1: Includes think blocks for anti-hallucination
  * P3.3: Includes relevant memories from semantic database
  * P3.4: Includes plan mode instructions
+ * P4.1: Includes quality checklists (Claude decides which to apply)
  */
 
+const fs = require('fs')
+const path = require('path')
+
 class PromptBuilder {
+  constructor() {
+    this._checklistsCache = null
+    this._checklistRoutingCache = null
+  }
+
+  /**
+   * Load quality checklists from templates/checklists/
+   * Returns checklist content - Claude decides which to apply
+   * NO if/else logic here - just load and provide
+   */
+  loadChecklists() {
+    if (this._checklistsCache) return this._checklistsCache
+
+    const checklistsDir = path.join(__dirname, '..', '..', 'templates', 'checklists')
+    const checklists = {}
+
+    try {
+      if (fs.existsSync(checklistsDir)) {
+        const files = fs.readdirSync(checklistsDir).filter(f => f.endsWith('.md'))
+        for (const file of files) {
+          const name = file.replace('.md', '')
+          const content = fs.readFileSync(path.join(checklistsDir, file), 'utf-8')
+          checklists[name] = content
+        }
+      }
+    } catch (err) {
+      // Silent fail - checklists are optional enhancement
+    }
+
+    this._checklistsCache = checklists
+    return checklists
+  }
+
+  /**
+   * Load checklist routing template
+   * Claude reads this to decide which checklists to apply
+   */
+  loadChecklistRouting() {
+    if (this._checklistRoutingCache) return this._checklistRoutingCache
+
+    const routingPath = path.join(__dirname, '..', '..', 'templates', 'agentic', 'checklist-routing.md')
+
+    try {
+      if (fs.existsSync(routingPath)) {
+        this._checklistRoutingCache = fs.readFileSync(routingPath, 'utf-8')
+      }
+    } catch (err) {
+      // Silent fail
+    }
+
+    return this._checklistRoutingCache || null
+  }
   /**
    * Build concise prompt - only essentials
    * CRITICAL: Includes full agent content if agent is provided
@@ -154,6 +210,22 @@ class PromptBuilder {
       parts.push(`\n## APPROVAL REQUIRED\nShow changes, list affected files, ask for confirmation.\n`)
     }
 
+    // P4.1: Quality Checklists (Claude decides which to apply)
+    // Only for code-modifying commands that benefit from quality gates
+    const checklistCommands = ['now', 'build', 'feature', 'design', 'fix', 'bug', 'cleanup', 'spec', 'work']
+    if (checklistCommands.includes(commandName)) {
+      const routing = this.loadChecklistRouting()
+      const checklists = this.loadChecklists()
+
+      if (routing && Object.keys(checklists).length > 0) {
+        parts.push('\n## QUALITY CHECKLISTS\n')
+        parts.push('Apply relevant checklists based on task. Read checklist-routing.md for guidance.\n')
+        parts.push(`Available: ${Object.keys(checklists).join(', ')}\n`)
+        parts.push('Path: templates/checklists/{name}.md\n')
+        parts.push('Use Read tool to load checklists you determine are relevant.\n')
+      }
+    }
+
     // Simple execution directive
     parts.push('\nEXECUTE: Follow flow. Use tools. Decide.\n')
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.10.13",
+  "version": "0.10.14",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {

package/templates/agentic/agent-routing.md

@@ -57,17 +57,49 @@ Consider these agent specializations:
 3. Consider secondary areas
 4. Choose agent with best expertise match
 
-## Output
+## How to Invoke (EFFICIENT)
 
-Return the recommended agent with reasoning:
+After deciding the best agent, **delegate via Task tool with REFERENCE, not content**:
 
-```json
-{
-  "agent": "recommended-agent-type",
-  "reasoning": "why this agent is best for the task",
-  "confidence": "high|medium|low",
-  "alternatives": ["other agents that could help"]
-}
+```
+Task(
+  subagent_type: 'general-purpose',
+  prompt: '
+    ## Agent Assignment
+    Read and apply: ~/.prjct-cli/projects/{projectId}/agents/{agent-name}.md
+
+    ## Task
+    {task description}
+
+    ## Context
+    - Project: {projectPath}
+    - Files affected: {file list if known}
+
+    ## Flow
+    1. Read agent file FIRST
+    2. Apply agent expertise and patterns
+    3. Execute task following agent guidelines
+    4. Return results
+  '
+)
+```
+
+### Why References, Not Content
+
+| Approach | Prompt Size | Issue |
+|----------|-------------|-------|
+| ❌ Inject content | 3-5KB | Bloats context, increases hallucinations |
+| ✅ Pass reference | ~200 bytes | Subagent reads what it needs |
+
+**CRITICAL:** The subagent reads the agent file itself. You do NOT need to read and inject the content.
+
+## Output (After Delegation)
+
+After Task tool returns, summarize:
+
+```
+✅ Delegated to: {agent-name}
+Result: {brief summary from subagent}
 ```
 
 ## Rules
@@ -75,4 +107,5 @@ Return the recommended agent with reasoning:
 - **Task-driven, not tech-driven** - Focus on what needs to be done
 - **Context matters** - Same tech can mean different things in different projects
 - **Be flexible** - One project's "backend" might be another's "full-stack"
+- **Pass PATH, not CONTENT** - Let subagent read the agent file
 - **Explain your reasoning** - Don't just pick, justify

package/templates/agentic/checklist-routing.md

@@ -0,0 +1,98 @@
+---
+allowed-tools: [Read, Glob]
+description: 'Determine which quality checklists to apply - Claude decides'
+---
+
+# Checklist Routing Instructions
+
+## Objective
+
+Determine which quality checklists are relevant for a task by analyzing the ACTUAL task and its scope.
+
+## Step 1: Understand the Task
+
+Read the task description and identify:
+
+- What type of work is being done? (new feature, bug fix, refactor, infra, docs)
+- What domains are affected? (code, UI, API, database, deployment)
+- What is the scope? (small fix, major feature, architectural change)
+
+## Step 2: Consider Task Domains
+
+Each task can touch multiple domains. Consider:
+
+| Domain | Signals |
+|--------|---------|
+| Code Quality | Writing/modifying any code |
+| Architecture | New components, services, or major refactors |
+| UX/UI | User-facing changes, CLI output, visual elements |
+| Infrastructure | Deployment, containers, CI/CD, cloud resources |
+| Security | Auth, user data, external inputs, secrets |
+| Testing | New functionality, bug fixes, critical paths |
+| Documentation | Public APIs, complex features, breaking changes |
+| Performance | Data processing, loops, network calls, rendering |
+| Accessibility | User interfaces (web, mobile, CLI) |
+| Data | Database operations, caching, data transformations |
+
+## Step 3: Match Task to Checklists
+
+Based on your analysis, select relevant checklists:
+
+**DO NOT assume:**
+- Every task needs all checklists
+- "Frontend" = only UX checklist
+- "Backend" = only Code Quality checklist
+
+**DO analyze:**
+- What the task actually touches
+- What quality dimensions matter for this specific work
+- What could go wrong if not checked
+
+## Available Checklists
+
+Located in `templates/checklists/`:
+
+| Checklist | When to Apply |
+|-----------|---------------|
+| `code-quality.md` | Any code changes (any language) |
+| `architecture.md` | New modules, services, significant structural changes |
+| `ux-ui.md` | User-facing interfaces (web, mobile, CLI, API DX) |
+| `infrastructure.md` | Deployment, containers, CI/CD, cloud resources |
+| `security.md` | ALWAYS for: auth, user input, external APIs, secrets |
+| `testing.md` | New features, bug fixes, refactors |
+| `documentation.md` | Public APIs, complex features, configuration changes |
+| `performance.md` | Data-intensive operations, critical paths |
+| `accessibility.md` | Any user interface work |
+| `data.md` | Database, caching, data transformations |
+
+## Decision Process
+
+1. Read task description
+2. Identify primary work domain
+3. List secondary domains affected
+4. Select 2-4 most relevant checklists
+5. Consider Security (almost always relevant)
+
+## Output
+
+Return selected checklists with reasoning:
+
+```json
+{
+  "checklists": ["code-quality", "security", "testing"],
+  "reasoning": "Task involves new API endpoint (code), handles user input (security), and adds business logic (testing)",
+  "priority_items": ["Input validation", "Error handling", "Happy path tests"],
+  "skipped": {
+    "accessibility": "No user interface changes",
+    "infrastructure": "No deployment changes"
+  }
+}
+```
+
+## Rules
+
+- **Task-driven** - Focus on what the specific task needs
+- **Less is more** - 2-4 focused checklists beat 10 unfocused
+- **Security is special** - Default to including unless clearly irrelevant
+- **Explain your reasoning** - Don't just pick, justify selections AND skips
+- **Context matters** - Small typo fix ≠ major refactor in checklist needs

package/templates/checklists/accessibility.md

@@ -0,0 +1,33 @@
+# Accessibility Checklist
+
+> Applies to: Web (WCAG), Mobile, CLI, Desktop
+
+## Perceivable
+- [ ] Text alternatives for non-text content
+- [ ] Sufficient color contrast (4.5:1 minimum)
+- [ ] Content readable without color alone
+- [ ] Resizable text supported (up to 200%)
+
+## Operable
+- [ ] Keyboard accessible (all functionality)
+- [ ] No keyboard traps
+- [ ] Sufficient time for interactions
+- [ ] Seizure-safe (no flashing > 3Hz)
+
+## Understandable
+- [ ] Clear and simple language
+- [ ] Consistent navigation
+- [ ] Input assistance provided
+- [ ] Error identification and suggestions
+
+## Robust
+- [ ] Compatible with assistive technologies
+- [ ] Valid markup/structure
+- [ ] ARIA used correctly (web)
+- [ ] Semantic HTML elements used
+
+## CLI Accessibility
+- [ ] Screen reader compatible output
+- [ ] No color-only information
+- [ ] Clear text formatting
+- [ ] Configurable output verbosity

package/templates/checklists/architecture.md

@@ -0,0 +1,28 @@
+# Architecture Checklist
+
+> Applies to ANY system architecture
+
+## Design Principles
+- [ ] Clear separation of concerns
+- [ ] Loose coupling between components
+- [ ] High cohesion within modules
+- [ ] Single source of truth for data
+- [ ] Explicit dependencies (no hidden coupling)
+
+## Scalability
+- [ ] Stateless where possible
+- [ ] Horizontal scaling considered
+- [ ] Bottlenecks identified
+- [ ] Caching strategy defined
+
+## Resilience
+- [ ] Failure modes documented
+- [ ] Graceful degradation planned
+- [ ] Recovery procedures defined
+- [ ] Circuit breakers where needed
+
+## Maintainability
+- [ ] Clear boundaries between layers
+- [ ] Easy to test in isolation
+- [ ] Configuration externalized
+- [ ] Logging and observability built-in

package/templates/checklists/code-quality.md

@@ -0,0 +1,28 @@
+# Code Quality Checklist
+
+> Universal principles for ANY programming language
+
+## Universal Principles
+- [ ] Single Responsibility: Each unit does ONE thing well
+- [ ] DRY: No duplicated logic (extract shared code)
+- [ ] KISS: Simplest solution that works
+- [ ] Clear naming: Self-documenting identifiers
+- [ ] Consistent patterns: Match existing codebase style
+
+## Error Handling
+- [ ] All error paths handled gracefully
+- [ ] Meaningful error messages
+- [ ] No silent failures
+- [ ] Proper resource cleanup (files, connections, memory)
+
+## Edge Cases
+- [ ] Null/nil/None handling
+- [ ] Empty collections handled
+- [ ] Boundary conditions tested
+- [ ] Invalid input rejected early
+
+## Code Organization
+- [ ] Functions/methods are small and focused
+- [ ] Related code grouped together
+- [ ] Clear module/package boundaries
+- [ ] No circular dependencies

package/templates/checklists/data.md

@@ -0,0 +1,33 @@
+# Data Checklist
+
+> Applies to: SQL, NoSQL, GraphQL, File storage, Caching
+
+## Data Integrity
+- [ ] Schema/structure defined
+- [ ] Constraints enforced
+- [ ] Transactions used appropriately
+- [ ] Referential integrity maintained
+
+## Query Performance
+- [ ] Indexes on frequent queries
+- [ ] N+1 queries eliminated
+- [ ] Query complexity analyzed
+- [ ] Pagination for large datasets
+
+## Data Operations
+- [ ] Migrations versioned and reversible
+- [ ] Backup and restore tested
+- [ ] Data validation at boundary
+- [ ] Soft deletes considered (if applicable)
+
+## Caching
+- [ ] Cache invalidation strategy defined
+- [ ] TTL values appropriate
+- [ ] Cache warming considered
+- [ ] Cache hit/miss monitored
+
+## Data Privacy
+- [ ] PII identified and protected
+- [ ] Data anonymization where needed
+- [ ] Audit trail for sensitive data
+- [ ] Data deletion procedures defined

package/templates/checklists/documentation.md

@@ -0,0 +1,33 @@
+# Documentation Checklist
+
+> Applies to ALL projects
+
+## Essential Docs
+- [ ] README with quick start
+- [ ] Installation instructions
+- [ ] Configuration options documented
+- [ ] Common use cases shown
+
+## Code Documentation
+- [ ] Public APIs documented
+- [ ] Complex logic explained
+- [ ] Architecture decisions recorded (ADRs)
+- [ ] Diagrams for complex flows
+
+## Operational Docs
+- [ ] Deployment process documented
+- [ ] Troubleshooting guide
+- [ ] Runbooks for common issues
+- [ ] Changelog maintained
+
+## API Documentation
+- [ ] All endpoints documented
+- [ ] Request/response examples
+- [ ] Error codes explained
+- [ ] Authentication documented
+
+## Maintenance
+- [ ] Docs updated with code changes
+- [ ] Version-specific documentation
+- [ ] Broken links checked
+- [ ] Examples tested and working

package/templates/checklists/infrastructure.md

@@ -0,0 +1,33 @@
+# Infrastructure Checklist
+
+> Applies to: Cloud, On-prem, Hybrid, Edge
+
+## Deployment
+- [ ] Infrastructure as Code (Terraform, Pulumi, CloudFormation, etc.)
+- [ ] Reproducible environments
+- [ ] Rollback strategy defined
+- [ ] Blue-green or canary deployment option
+
+## Observability
+- [ ] Logging strategy defined
+- [ ] Metrics collection configured
+- [ ] Alerting thresholds set
+- [ ] Distributed tracing (if applicable)
+
+## Security
+- [ ] Secrets management (not in code)
+- [ ] Network segmentation
+- [ ] Least privilege access
+- [ ] Encryption at rest and in transit
+
+## Reliability
+- [ ] Backup strategy defined
+- [ ] Disaster recovery plan
+- [ ] Health checks configured
+- [ ] Auto-scaling rules (if applicable)
+
+## Cost Management
+- [ ] Resource sizing appropriate
+- [ ] Unused resources identified
+- [ ] Cost monitoring in place
+- [ ] Budget alerts configured

package/templates/checklists/performance.md

@@ -0,0 +1,33 @@
+# Performance Checklist
+
+> Applies to: Backend, Frontend, Mobile, Database
+
+## Analysis
+- [ ] Bottlenecks identified with profiling
+- [ ] Baseline metrics established
+- [ ] Performance budgets defined
+- [ ] Benchmarks before/after changes
+
+## Optimization Strategies
+- [ ] Algorithmic complexity reviewed (O(n) vs O(n²))
+- [ ] Appropriate data structures used
+- [ ] Caching implemented where beneficial
+- [ ] Lazy loading for expensive operations
+
+## Resource Management
+- [ ] Memory usage optimized
+- [ ] Connection pooling used
+- [ ] Batch operations where applicable
+- [ ] Async/parallel processing considered
+
+## Frontend Specific
+- [ ] Bundle size optimized
+- [ ] Images optimized
+- [ ] Critical rendering path optimized
+- [ ] Network requests minimized
+
+## Backend Specific
+- [ ] Database queries optimized
+- [ ] Response compression enabled
+- [ ] Proper indexing in place
+- [ ] Connection limits configured

package/templates/checklists/security.md

@@ -0,0 +1,33 @@
+# Security Checklist
+
+> ALWAYS ON - Applies to ALL applications
+
+## Input/Output
+- [ ] All user input validated and sanitized
+- [ ] Output encoded appropriately (prevent injection)
+- [ ] File uploads restricted and scanned
+- [ ] No sensitive data in logs or error messages
+
+## Authentication & Authorization
+- [ ] Strong authentication mechanism
+- [ ] Proper session management
+- [ ] Authorization checked at every access point
+- [ ] Principle of least privilege applied
+
+## Data Protection
+- [ ] Sensitive data encrypted at rest
+- [ ] Secure transmission (TLS/HTTPS)
+- [ ] PII handled according to regulations
+- [ ] Data retention policies followed
+
+## Dependencies
+- [ ] Dependencies from trusted sources
+- [ ] Known vulnerabilities checked
+- [ ] Minimal dependency surface
+- [ ] Regular security updates planned
+
+## API Security
+- [ ] Rate limiting implemented
+- [ ] Authentication required for sensitive endpoints
+- [ ] CORS properly configured
+- [ ] API keys/tokens secured

package/templates/checklists/testing.md

@@ -0,0 +1,33 @@
+# Testing Checklist
+
+> Applies to: Unit, Integration, E2E, Performance testing
+
+## Coverage Strategy
+- [ ] Critical paths have high coverage
+- [ ] Happy path tested
+- [ ] Error paths tested
+- [ ] Edge cases covered
+
+## Test Quality
+- [ ] Tests are deterministic (no flaky tests)
+- [ ] Tests are independent (no order dependency)
+- [ ] Tests are fast (optimize slow tests)
+- [ ] Tests are readable (clear intent)
+
+## Test Types
+- [ ] Unit tests for business logic
+- [ ] Integration tests for boundaries
+- [ ] E2E tests for critical flows
+- [ ] Performance tests for bottlenecks
+
+## Mocking Strategy
+- [ ] External services mocked
+- [ ] Database isolated or mocked
+- [ ] Time-dependent code controlled
+- [ ] Random values seeded
+
+## Test Maintenance
+- [ ] Tests updated with code changes
+- [ ] Dead tests removed
+- [ ] Test data managed properly
+- [ ] CI/CD integration working

package/templates/checklists/ux-ui.md

@@ -0,0 +1,37 @@
+# UX/UI Checklist
+
+> Applies to: Web, Mobile, CLI, Desktop, API DX
+
+## User Experience
+- [ ] Clear user journey/flow
+- [ ] Feedback for every action
+- [ ] Loading states shown
+- [ ] Error states handled gracefully
+- [ ] Success confirmation provided
+
+## Interface Design
+- [ ] Consistent visual language
+- [ ] Intuitive navigation
+- [ ] Responsive/adaptive layout (if applicable)
+- [ ] Touch targets adequate (mobile)
+- [ ] Keyboard navigation (web/desktop)
+
+## CLI Specific
+- [ ] Help text for all commands
+- [ ] Clear error messages with suggestions
+- [ ] Progress indicators for long operations
+- [ ] Consistent flag naming conventions
+- [ ] Exit codes meaningful
+
+## API DX (Developer Experience)
+- [ ] Intuitive endpoint/function naming
+- [ ] Consistent response format
+- [ ] Helpful error messages with codes
+- [ ] Good documentation with examples
+- [ ] Predictable behavior
+
+## Information Architecture
+- [ ] Content hierarchy clear
+- [ ] Important actions prominent
+- [ ] Related items grouped
+- [ ] Search/filter for large datasets

package/templates/commands/bug.md

@@ -1,10 +1,36 @@
 ---
-allowed-tools: [Read, Write]
+allowed-tools: [Read, Write, Task, Glob]
 description: 'Report bug with auto-priority'
 ---
 
 # /p:bug
 
+## Agent Delegation (REQUIRED)
+
+Before fixing a bug, delegate to specialist agent:
+
+1. **List agents**: `Glob("~/.prjct-cli/projects/{projectId}/agents/*.md")`
+2. **Analyze bug domain**: frontend, backend, database, etc.
+3. **Delegate via Task tool**:
+
+```
+Task(
+  subagent_type: 'general-purpose',
+  prompt: '
+    ## Agent
+    Read: ~/.prjct-cli/projects/{projectId}/agents/{agent}.md
+
+    ## Bug
+    {bug description}
+
+    ## Flow
+    1. Read agent file
+    2. Apply expertise to fix bug
+    3. Return fix
+  '
+)
+```
+
 ## Severity Keywords
 - **Critical**: crash, down, broken, production
 - **High**: error, fail, issue

package/templates/commands/feature.md

@@ -1,11 +1,48 @@
 ---
-allowed-tools: [Read, Write, Bash]
+allowed-tools: [Read, Write, Bash, Task, Glob]
 description: 'Value analysis + roadmap + task breakdown + auto-start'
 timestamp-rule: 'GetTimestamp() and GetDate() for ALL timestamps'
 ---
 
 # /p:feature - Add Feature to Roadmap
 
+## Agent Delegation (REQUIRED)
+
+Before executing any code-related task, delegate to a specialist agent:
+
+### Step 0: Assign Agent
+
+1. **List agents**: `Glob("~/.prjct-cli/projects/{projectId}/agents/*.md")`
+2. **Read routing**: `Read("templates/agentic/agent-routing.md")`
+3. **Analyze task**: Determine domain (frontend, backend, testing, etc.)
+4. **Select agent**: Match task to best agent
+5. **Delegate via Task tool** (pass reference, NOT content):
+
+```
+Task(
+  subagent_type: 'general-purpose',
+  prompt: '
+    ## Agent Assignment
+    Read and apply: ~/.prjct-cli/projects/{projectId}/agents/{agent-name}.md
+
+    ## Task
+    {feature description}
+
+    ## Context
+    - Project: {projectPath}
+    - Feature: {feature}
+
+    ## Flow
+    1. Read agent file FIRST
+    2. Apply agent expertise
+    3. Execute task
+    4. Return results
+  '
+)
+```
+
+**CRITICAL:** Pass file PATH, not content. Subagent reads it (~200 bytes vs 3-5KB).
+
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`

package/templates/commands/task.md

@@ -1,10 +1,36 @@
 ---
-allowed-tools: [Read, Write, TodoWrite]
+allowed-tools: [Read, Write, TodoWrite, Task, Glob]
 description: 'Break down complex tasks'
 ---
 
 # /p:task
 
+## Agent Delegation (REQUIRED)
+
+Before executing task, delegate to specialist agent:
+
+1. **List agents**: `Glob("~/.prjct-cli/projects/{projectId}/agents/*.md")`
+2. **Analyze task domain**: Match to agent expertise
+3. **Delegate via Task tool**:
+
+```
+Task(
+  subagent_type: 'general-purpose',
+  prompt: '
+    ## Agent
+    Read: ~/.prjct-cli/projects/{projectId}/agents/{agent}.md
+
+    ## Task
+    {task description}
+
+    ## Flow
+    1. Read agent file
+    2. Apply expertise
+    3. Execute task
+  '
+)
+```
+
 ## Usage
 
 ```