prjct-cli 0.28.2 → 0.28.4

package/templates/commands/task.md

@@ -5,54 +5,14 @@ description: 'Unified task workflow with intelligent classification'
 
 # p. task - Start Any Task
 
-Start any work with automatic classification and intelligent breakdown.
+**See:** `@templates/shared/standard.md` for context variables and patterns.
 
-## @ Agent Mentions
+## @ Mentions
 
-Invoke specific agents directly in your task using @ notation:
+| `@frontend` `@backend` `@database` `@uxui` `@testing` `@devops` | Load domain agents |
+| `@explore` `@general` `@plan` | Claude Code subagents |
 
-| Mention | Agent | Use Case |
-|---------|-------|----------|
-| `@frontend` | frontend.md | UI components, React/Vue |
-| `@backend` | backend.md | APIs, server logic |
-| `@database` | database.md | Schema, queries |
-| `@uxui` | uxui.md | UX patterns, design |
-| `@testing` | testing.md | Tests, coverage |
-| `@devops` | devops.md | CI/CD, Docker |
-
-**Examples:**
-- `p. task @frontend add button` - Loads frontend specialist
-- `p. task @frontend @uxui dark mode` - Loads both agents
-- `p. task @backend optimize API` - Loads backend specialist
-
-**Note:** If no @ mention, agents are auto-assigned based on task analysis.
-
-## Claude Code Subagents
-
-Special @ mentions invoke Claude Code's native subagents:
-
-| Mention | Subagent | Use Case |
-|---------|----------|----------|
-| `@explore` | Explore | Fast codebase search, find patterns |
-| `@general` | General | Complex multi-step research |
-| `@plan` | Plan | Architecture design, implementation planning |
-
-**Examples:**
-- `p. task @explore find all API endpoints`
-- `p. task @general research caching strategies`
-- `p. task @plan design authentication system`
-
-**Combined:**
-- `p. task @frontend @explore add button like existing ones`
-  → Loads frontend agent + uses Explore subagent to find similar buttons
-
----
-
-## Context Variables
-
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{task}`: User-provided task description
+Example: `p. task @frontend @explore add button like existing ones`
 
 ---
 
@@ -70,259 +30,88 @@ Special @ mentions invoke Claude Code's native subagents:
 
 ---
 
-## Step 1: Validate Project
-
-```
-READ: .prjct/prjct.config.json
-EXTRACT: projectId
-SET: globalPath = ~/.prjct-cli/projects/{projectId}
-
-IF file not found:
-  OUTPUT: "No prjct project. Run `p. init` first."
-  STOP
-```
-
----
-
-## Step 2: Handle No Task Description
+## Step 1: Validate & Load State (PARALLEL)
 
 ```
-IF no task provided:
-  READ: {globalPath}/storage/state.json
-
-  IF currentTask exists AND status == "active":
-    OUTPUT current task status with elapsed time
-    STOP
-  ELSE:
-    OUTPUT: "No current task. Use `p. task <description>` to start one."
-    STOP
-```
-
----
-
-## Step 3: Handle Active Task Conflict
+READ (parallel):
+- .prjct/prjct.config.json → {projectId}
+- {globalPath}/storage/state.json → {state}
 
-```
-READ: {globalPath}/storage/state.json
-
-IF currentTask exists AND status == "active" AND description != {task}:
-  USE AskUserQuestion:
-    question: "Active task: '{currentTask.description}'. How to proceed?"
-    options:
-      - "Complete current first" → complete it, then continue
-      - "Pause and switch" → pause it, then continue
-      - "Cancel" → stay with current task
+IF no config: "No prjct project. Run `p. init`" → STOP
+IF no task AND state.currentTask: Show status → STOP
+IF no task: "Use `p. task <description>`" → STOP
+IF state.currentTask.status == "active":
+  AskUserQuestion: "Active task. Complete, Pause, or Cancel?"
 ```
 
 ---
 
-## Step 4: Agentic Classification
-
-**CRITICAL: Use reasoning, NOT keyword matching.**
+## Step 2: Classify & Branch
 
-Analyze the task holistically:
+### Classification (Reasoning, NOT keywords)
 
-| Type | When to Use |
-|------|-------------|
-| `feature` | Adds new functionality that didn't exist |
-| `bug` | Something is broken or incorrect |
-| `improvement` | Enhances existing functionality |
-| `refactor` | Reorganizes code, same behavior |
-| `chore` | Maintenance, deps, docs, config |
+| Type | Signal |
+|------|--------|
+| `feature` | New functionality |
+| `bug` | Broken behavior |
+| `improvement` | Enhance existing |
+| `refactor` | Reorganize, same behavior |
+| `chore` | Maintenance, deps, docs |
 
-**Reasoning Examples:**
-- "add error handling to login" → Reasoning: Adding new functionality → `feature`
-- "fix button that doesn't submit" → Reasoning: Broken behavior → `bug`
-- "make dashboard load faster" → Reasoning: Enhancing performance → `improvement`
-- "split UserService into modules" → Reasoning: Reorganizing code → `refactor`
+### Git Branch (if on main)
 
+```bash
+git branch --show-current && git status --porcelain
 ```
-OUTPUT:
-Analyzing: {task}
-Intent: {your reasoning}
-Classification: {taskType}
-```
-
----
-
-## Step 5: Git Branch Management
 
-```
-BASH: git branch --show-current
-SET: currentBranch = result
-
-IF currentBranch == "main" OR currentBranch == "master":
-  # Handle uncommitted changes first
-  IF git status shows changes:
-    USE AskUserQuestion: "Uncommitted changes. Stash, commit, or abort?"
-
-  # Create branch
-  SET: branchName = {taskType}/{slugify(task)}
-  BASH: git checkout -b {branchName}
-  OUTPUT: "Created branch: {branchName}"
-```
+IF on main AND clean: `git checkout -b {type}/{slug}`
+IF on main AND dirty: AskUserQuestion → Stash/Commit/Abort
 
 ---
 
-## 5-Phase Workflow
+## Step 3: 5-Phase Workflow
 
 ### Phase 1: Discovery
-Summarize what you understand:
 ```
-Building: {one-sentence summary}
+Building: {one-line summary}
 Type: {taskType}
-
-Requirements:
-- {req 1}
-- {req 2}
-
-Success looks like:
-- {criteria 1}
-- {criteria 2}
+Requirements: {2-3 bullets}
 ```
 
-### Phase 2: Exploration
-Use Task(Explore) agent to find:
-- Similar existing code
-- Patterns used in this codebase
-- Key files that would be affected
+### Phase 2: Exploration (PARALLEL)
 
-**Load skills based on task type:**
 ```
-READ: {globalPath}/config/skills.json (if exists)
-
-IF task involves UI/frontend:
-  Invoke Skill("frontend-design") for design patterns
-  OUTPUT: "🎨 Using frontend-design skill"
-
-IF task involves backend/API:
-  Invoke Skill("javascript-typescript") OR Skill("python-development")
-  OUTPUT: "⚙️ Using {skill} skill"
-```
-
-```
-OUTPUT:
-Found similar:
-- {code} in {file}
-
-Patterns used:
-- {pattern}: {where}
-
-Key files:
-- {file}: {what changes}
-
-Skills activated: {skills used}
+Task(Explore): Find similar code, patterns, affected files
+READ: {globalPath}/config/skills.json → invoke matching skills
 ```
 
 ### Phase 3: Questions
-If anything is unclear, use AskUserQuestion.
-If everything is clear, say so and continue.
+AskUserQuestion if unclear. Otherwise continue.
 
 ### Phase 4: Design
-Load relevant agents from `{globalPath}/agents/` and their linked skills:
 
-**Agent + Skill Loading:**
 ```
-FOR EACH relevant agent in {globalPath}/agents/:
-  READ agent file
-  PARSE frontmatter → get `skills` array
-
-  IF skills exist:
-    FOR EACH skill in skills:
-      Invoke Skill(skill) for domain expertise
-      OUTPUT: "📚 {agent} using /{skill}"
+READ (parallel): {globalPath}/agents/{detected domains}.md
+FOR EACH agent.skills: Invoke Skill()
+FOR EACH agent.mcp: Query context7
 ```
 
-**Example flow for UI feature:**
-1. Load `uxui.md` agent (has `skills: [frontend-design]`)
-2. Invoke `/frontend-design` skill
-3. Skill provides anti-AI-slop patterns, typography guidelines
-4. Agent applies them to design options
+Propose 2 options → AskUserQuestion for approval.
 
-Propose 2-3 approaches:
-
-```
-### Option 1: Minimal
-- Approach: {desc}
-- Files: {count}
-- Pros/Cons: ...
-
-### Option 2: Clean Architecture
-- Approach: {desc}
-- Files: {count}
-- Pros/Cons: ...
-
-### Option 3: Recommended (Skill-informed)
-- Approach: {desc}
-- Files: {count}
-- Pros/Cons: ...
-- Skills applied: {skills}
-```
-
-Use AskUserQuestion to get approval.
-
-### Phase 5: Task Breakdown
-Break into actionable subtasks:
-- Each task: 30min - 2h
-- Ordered by dependency
-- Include testing as final task
-
-```
-Tasks for {task}:
-1. {subtask 1}
-2. {subtask 2}
-...
-n. Write tests and verify
-```
+### Phase 5: Breakdown
+Subtasks: 30min-2h each, dependency order, tests last.
 
 ---
 
-## Step 6: Update Storage
-
-### Write state.json
-```json
-{
-  "currentTask": {
-    "id": "{uuid}",
-    "description": "{firstSubtask}",
-    "type": "{taskType}",
-    "status": "active",
-    "sessionId": "{uuid}",
-    "featureId": "{uuid}",
-    "startedAt": "{timestamp}",
-    "branch": {
-      "name": "{branchName}",
-      "baseBranch": "{baseBranch}"
-    },
-    "subtasks": [...],
-    "currentSubtaskIndex": 0,
-    "parentDescription": "{task}"
-  },
-  "lastUpdated": "{timestamp}"
-}
-```
-
-### Write queue.json
-Add all subtasks to queue with featureId linking them.
-
-### Generate context/now.md
-```markdown
-# NOW
-
-**{firstSubtask.description}**
+## Step 4: Update Storage (PARALLEL WRITES)
 
-Type: {taskType}
-Feature: {task}
-Branch: {branchName}
 ```
+WRITE (parallel):
+- {globalPath}/storage/state.json → currentTask with subtasks
+- {globalPath}/storage/queue.json → add subtasks with featureId
+- {globalPath}/context/now.md → current task summary
 
----
-
-## Step 7: Log to Memory
-
-```
-APPEND to {globalPath}/memory/events.jsonl:
-{"timestamp":"{now}","action":"task_started","taskId":"{id}","type":"{type}","description":"{task}"}
+APPEND: {globalPath}/memory/events.jsonl
 ```
 
 ---
@@ -330,24 +119,9 @@ APPEND to {globalPath}/memory/events.jsonl:
 ## Output
 
 ```
-{task}
-Type: {taskType}
-
-Branch: {branchName}
-Subtasks: {count}
-
+{task} | {taskType}
+Branch: {branchName} | Subtasks: {count}
 Started: {firstSubtask}
 
-Next: Work on the task, then `p. done`
+Next: p. done
 ```
-
----
-
-## Error Handling
-
-| Error | Action |
-|-------|--------|
-| No config | "No prjct project. Run `p. init` first." → STOP |
-| No task | Show current task or prompt for one |
-| Active task | Ask user what to do |
-| Branch fails | Show error, suggest fix |