prjct-cli 0.35.2 → 0.35.4

package/templates/commands/p.md

@@ -7,79 +7,214 @@ allowed-tools: [Read, Write, Edit, Bash, Glob, Grep, Task, AskUserQuestion, Todo
 
 **ARGUMENTS**: $ARGUMENTS
 
-## Instructions
-
-1. Parse ARGUMENTS: first word = `command`, rest = `commandArgs`
-2. Get npm global root:
-   ```bash
-   npm root -g
-   ```
-3. **Run Orchestrator** (for task-related commands):
-   - Read: `{npmRoot}/prjct-cli/templates/agentic/orchestrator.md`
-   - Execute orchestrator Steps 1-5 to load agents and skills
-4. Read command template:
-   ```
-   {npmRoot}/prjct-cli/templates/commands/{command}.md
-   ```
-5. Execute template with `commandArgs` + orchestrator context
-
-## Orchestrator Integration
-
-For these commands, run orchestrator FIRST:
-- `task`, `done`, `ship` - Core workflow
-- `bug`, `plan`, `prd`, `spec`, `design` - Planning
-- `review`, `merge` - Git operations
-
-Skip orchestrator for:
-- `init`, `sync`, `setup` - Project config (no task context)
-- `dash`, `next`, `history` - Read-only views
-- `linear`, `jira`, `github`, `monday` - Integrations (own logic)
-
-## Example
-
-ARGUMENTS = "task fix the login bug"
-
-1. command = "task"
-2. commandArgs = "fix the login bug"
-3. npm root -g → `/opt/homebrew/lib/node_modules`
-4. **Orchestrator**:
-   - Analyze: "login bug" → domains: [frontend, backend]
-   - Load agents: frontend.md, backend.md
-   - Invoke skills: ui-design, api-design
-5. Read: `/opt/homebrew/lib/node_modules/prjct-cli/templates/commands/task.md`
-6. Execute with: "fix the login bug" + orchestrator context
+## Quick Routing
 
-## Available Commands
+Parse ARGUMENTS and route to the correct command template.
+
+```
+PARSE: $ARGUMENTS
+SET: command = first word (lowercase)
+SET: commandArgs = rest of arguments
+```
+
+---
+
+## Command Aliases (Redirects)
+
+These commands redirect to unified commands:
+
+| Input | Redirects To |
+|-------|--------------|
+| `p. undo` | `p. history undo` |
+| `p. redo` | `p. history redo` |
+
+If command is `undo` or `redo`:
+  PREPEND "history" to arguments
+  SET: command = "history"
+  SET: commandArgs = "{original_command} {commandArgs}"
+
+---
+
+## Command Categories
+
+### Core Workflow (use orchestrator)
+- `task` - Start any task with PM Expert enrichment
+- `done` - Complete current subtask
+- `ship` - Ship feature with version bump
+
+### Planning (use orchestrator for task context)
+- `plan` - Quarter-based roadmap planning
+- `prd` - Create PRD with Chief Architect
+- `spec` - Spec-driven development
+- `design` - Design workflow
+- `enrich` - Ticket enrichment
+
+### Project Management (no orchestrator)
+- `init` - Initialize project
+- `sync` - Deep project analysis
+- `setup` - Configure prjct
+- `dash` - View dashboard
+
+### Queue & Ideas (no orchestrator)
+- `next` - Show priority queue
+- `idea` - Quick idea capture
+- `bug` - Report bug with auto-priority
+
+### Issue Trackers (own logic)
+- `linear` - Linear integration
+- `jira` - JIRA integration
+- `github` - GitHub Issues integration
+- `monday` - Monday.com integration
+
+### Git Operations (use orchestrator)
+- `git` - Smart git operations
+- `merge` - Merge PR
+- `review` - Code review
+
+### Analysis (no orchestrator)
+- `analyze` - Analyze project
+- `history` - View/undo/redo snapshots
+- `impact` - Track outcomes
+
+### Utilities (no orchestrator)
+- `cleanup` - Code cleanup
+- `update` - Force update prjct
+- `verify` - Verify completion
+- `test` - Run tests
+- `serve` - Start web server
+- `auth` - Manage authentication
+- `skill` - Skill management
+- `pause` - Pause current task
+- `resume` - Resume paused task
+
+---
+
+## Execution Flow
+
+### Step 1: Get npm global root
+
+```bash
+npm root -g
+```
+
+SET: npmRoot = result
+
+### Step 2: Load State (always)
+
+```
+READ: .prjct/prjct.config.json
+EXTRACT: projectId
+
+IF file exists:
+  SET: globalPath = ~/.prjct-cli/projects/{projectId}
+  READ: {globalPath}/storage/state.json (if exists)
+  SET: hasActiveTask = state.currentTask != null
+```
+
+### Step 3: Load Agent (if project has one)
+
+```
+IF {globalPath}/agents/ has files:
+  # Load the main project agent (generated by sync)
+  GLOB: {globalPath}/agents/*.md
+  READ: first agent file (project-specific patterns)
+  SET: agentContext = agent content
+```
+
+### Step 4: Check if orchestrator needed
 
-**Core**: `task` `done` `ship` `pause` `resume`
-**Project**: `init` `sync` `setup` `dash`
-**Planning**: `plan` `prd` `spec` `design` `enrich`
-**Queue**: `next` `idea` `bug`
-**Integrations**: `linear` `jira` `github` `monday`
-**Git**: `git` `merge` `review`
-**Analysis**: `analyze` `history` `impact`
-**Utils**: `cleanup` `update` `verify` `test` `undo` `redo` `serve` `auth` `skill`
+Commands that benefit from orchestrator (task context + agent loading):
+- `task`, `done`, `ship`
+- `bug`, `plan`, `prd`, `spec`, `design`
+- `review`, `merge`
 
-## Orchestrator Output
+For these commands:
+```
+READ: {npmRoot}/prjct-cli/templates/agentic/orchestrator.md
+EXECUTE: orchestrator Steps 1-5 to build execution context
+```
+
+### Step 5: Load and execute command template
+
+```
+READ: {npmRoot}/prjct-cli/templates/commands/{command}.md
+EXECUTE: template with:
+  - commandArgs as $ARGUMENTS
+  - orchestrator context (if loaded)
+  - agent context (if loaded)
+  - state context (if available)
+```
+
+---
+
+## State Context Injection
+
+When executing any command, include:
+
+```
+## Current State
+
+Project: {projectId}
+{IF hasActiveTask:}
+Active Task: {state.currentTask.description}
+Branch: {state.currentTask.branch.name}
+Subtask: {state.currentTask.currentSubtaskIndex + 1}/{state.currentTask.subtasks.length}
+{ELSE:}
+No active task.
+{ENDIF}
+```
+
+---
 
-When orchestrator runs, output:
+## Output Format
+
+For orchestrator-enabled commands, output context header:
 
 ```
 🎯 Task: {commandArgs}
 
 📦 Context:
-├── Agents: {loadedAgents}
-├── Skills: {activeSkills}
-└── Domain: {primaryDomain}
+├── Agent: {loadedAgent || 'none'}
+├── State: {hasActiveTask ? 'active task' : 'no task'}
+└── Domain: {detectedDomain || 'general'}
+
+{Continue with command execution...}
 ```
 
-Then proceed with command execution.
+For utility commands, execute directly without context header.
+
+---
+
+## Error Handling
+
+| Error | Action |
+|-------|--------|
+| Unknown command | "Unknown command: {command}. Run `p. help` for available commands." |
+| No project | "No prjct project. Run `p. init` first." (for commands that need project) |
+| Template not found | "Template not found: {command}.md" |
+
+---
+
+## Available Commands
+
+```
+Core:     task  done  ship  pause  resume
+Project:  init  sync  setup  dash
+Planning: plan  prd  spec  design  enrich
+Queue:    next  idea  bug
+Trackers: linear  jira  github  monday
+Git:      git  merge  review
+Analysis: analyze  history  impact
+Utils:    cleanup  update  verify  test  serve  auth  skill
+```
+
+---
 
-## Action
+## NOW: Execute
 
-NOW:
-1. Run `npm root -g`
-2. Check if command needs orchestrator
-3. If yes: Read and execute orchestrator.md
-4. Read the command template
-5. Execute with full context
+1. Parse command from $ARGUMENTS
+2. Handle aliases (undo → history undo, redo → history redo)
+3. Run `npm root -g` to get template path
+4. Load state and agent context
+5. Check if orchestrator needed
+6. Load and execute command template

package/templates/commands/pause.md

@@ -1,290 +1,39 @@
 ---
 allowed-tools: [Read, Write, Bash, AskUserQuestion]
-description: 'Pause current session with reason'
-timestamp-rule: 'GetTimestamp() for all timestamps'
-architecture: 'Write-Through (JSON → MD → Events)'
-storage-layer: true
-source-of-truth: 'storage/state.json'
-claude-context: 'context/now.md'
-backend-sync: 'sync/pending.json'
 ---
 
-# /p:pause - Pause Current Session
+# p. pause "$ARGUMENTS"
 
-## Architecture: Write-Through Pattern
-
-```
-User Action → Storage (JSON) → Context (MD) → Sync Events
+```bash
+prjct context pause
 ```
 
-**Source of Truth**: `storage/state.json`
-**Claude Context**: `context/now.md` (generated)
-**Backend Sync**: `sync/pending.json` (events)
+IF no `currentTask` → "No active task to pause"
+IF already paused → Show paused state, STOP
 
-## Context Variables
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{statePath}`: `{globalPath}/storage/state.json`
-- `{nowContextPath}`: `{globalPath}/context/now.md`
-- `{syncPath}`: `{globalPath}/sync/pending.json`
-- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
-- `{reason}`: User-provided reason (optional)
+IF no reason provided, Ask: "Why pausing?"
+- Blocked (waiting on external)
+- Switching task
+- Taking a break
+- Researching
 
-## Pause Reasons
+IF blocked → Ask what's blocking
 
-When pausing, capture WHY to enable blocker tracking:
+Calculate duration since `startedAt`
 
-| Reason | Meaning | Dashboard Impact |
-|--------|---------|------------------|
-| `blocked` | Waiting on external dependency | Shows in Blockers list |
-| `switch` | Switching to higher priority task | Context switch metric |
-| `break` | Taking a break | Normal pause |
-| `research` | Need to investigate more | Research time tracked |
+UPDATE `{globalPath}/storage/state.json`:
+- `pausedTask` = currentTask with `status: "paused"`, `pausedAt`, `pauseReason`
+- `currentTask` = null
 
-If no reason provided, ask:
-```
-Why are you pausing?
-1. blocked - Waiting on something external
-2. switch - Starting a different task
-3. break - Taking a break
-4. research - Need to investigate
+**Output**:
 ```
+⏸️ Paused: {task}
 
-## Step 1: Read Config
-
-READ: `.prjct/prjct.config.json`
-EXTRACT: `projectId`
-
-IF file not found:
-  OUTPUT: "No prjct project. Run /p:init first."
-  STOP
-
-## Step 2: Check Current State
-
-### Read state.json (source of truth)
-READ: `{statePath}`
-
-IF file not found OR no currentTask:
-  OUTPUT: "⚠️ No active session to pause. Use /p:now to start one."
-  STOP
-
-PARSE JSON
-EXTRACT: {currentTask}, {pausedTask}
-
-IF {currentTask} is null OR {currentTask.status} != "active":
-  IF {pausedTask} exists:
-    CALCULATE: {elapsed} = time since {pausedTask.pausedAt}
-    OUTPUT:
-    ```
-    ⏸️ Already paused: {pausedTask.description}
-
-    Paused: {elapsed} ago
-    Duration so far: {pausedTask.duration}
-    Reason: {pausedTask.pauseReason}
-
-    /p:resume to continue | /p:done to complete
-    ```
-    STOP
-  ELSE:
-    OUTPUT: "⚠️ No active session to pause."
-    STOP
-
-## Step 3: Get Pause Reason (AGENTIC)
-
-IF {reason} not provided:
-  USE AskUserQuestion:
-  ```
-  question: "Why are you pausing '{currentTask.description}'?"
-  header: "Pause Reason"
-  options:
-    - label: "Blocked"
-      description: "Waiting on external dependency"
-    - label: "Switching task"
-      description: "Starting a different, higher priority task"
-    - label: "Taking a break"
-      description: "Stepping away temporarily"
-    - label: "Researching"
-      description: "Need to investigate more before continuing"
-  ```
-
-  SET: {reason} = choice mapped to (blocked, switch, break, research)
-
-IF {reason} == "blocked":
-  USE AskUserQuestion:
-  ```
-  question: "What's blocking you?"
-  header: "Blocker"
-  options:
-    - label: "Waiting for review"
-      description: "Code review or approval needed"
-    - label: "Waiting for API/credentials"
-      description: "External access or keys needed"
-    - label: "Waiting for clarification"
-      description: "Need more info on requirements"
-    - label: "Technical blocker"
-      description: "Dependency or infrastructure issue"
-  ```
-  SET: {blockerNote} = choice (user can also provide custom text)
-
-## Step 4: Calculate Duration So Far
-
-SET: {now} = GetTimestamp()
-SET: {durationSeconds} = seconds between {currentTask.startedAt} and {now}
-SET: {durationFormatted} = format as "Xh Ym" or "Xm"
-
-## Step 5: Update Storage (SOURCE OF TRUTH)
-
-### Prepare paused task
-```json
-{
-  "id": "{currentTask.id}",
-  "description": "{currentTask.description}",
-  "status": "paused",
-  "startedAt": "{currentTask.startedAt}",
-  "pausedAt": "{now}",
-  "sessionId": "{currentTask.sessionId}",
-  "duration": {durationSeconds},
-  "pauseReason": "{reason}",
-  "pauseNote": "{blockerNote}",
-  "estimate": "{currentTask.estimate}",
-  "estimateSeconds": {currentTask.estimateSeconds},
-  "workflow": "{currentTask.workflow}",
-  "subtasks": "{currentTask.subtasks}",
-  "currentSubtaskIndex": {currentTask.currentSubtaskIndex},
-  "branch": "{currentTask.branch}"
-}
-```
-
-**Note**: The workflow field is preserved so the task can resume at the correct phase.
-
-### Update state.json
-READ: `{statePath}`
-SET: state.pausedTask = paused task object
-SET: state.currentTask = null
-SET: state.lastUpdated = {now}
-WRITE: `{statePath}`
-
-## Step 6: Generate Context (FOR CLAUDE)
-
-WRITE: `{nowContextPath}`
-
-```markdown
-# NOW
-
-⏸️ **{currentTask.description}** (paused)
-
-Started: {currentTask.startedAt}
-Paused: {now}
-Duration: {durationFormatted}
+Duration: {time}
 Reason: {reason}
-Session: {currentTask.sessionId}
-{IF blockerNote: Note: {blockerNote}}
-```
-
-## Step 7: Queue Sync Event (FOR BACKEND)
-
-READ: `{syncPath}` or create empty array
-APPEND event:
-```json
-{
-  "type": "task.paused",
-  "path": ["state"],
-  "data": {
-    "taskId": "{currentTask.id}",
-    "description": "{currentTask.description}",
-    "pausedAt": "{now}",
-    "duration": {durationSeconds},
-    "reason": "{reason}",
-    "note": "{blockerNote}"
-  },
-  "timestamp": "{now}",
-  "projectId": "{projectId}"
-}
-```
-WRITE: `{syncPath}`
-
-## Step 8: Log to Memory (AUDIT TRAIL)
-
-APPEND to: `{memoryPath}`
-
-Single line (JSONL):
-```json
-{"timestamp":"{now}","action":"task_paused","taskId":"{currentTask.id}","sessionId":"{currentTask.sessionId}","task":"{currentTask.description}","duration":{durationSeconds},"reason":"{reason}","note":"{blockerNote}"}
-```
-
-## Output
-
-SUCCESS:
-```
-⏸️ Paused: {currentTask.description}
-
-Session: {currentTask.sessionId}
-Active time: {durationFormatted}
-Reason: {reason}
-{IF blockerNote: Note: {blockerNote}}
-
-Next:
-• /p:resume - Continue this task
-• /p:now <task> - Start different task
-• /p:done - Complete without resuming
-```
-
-## Error Handling
-
-| Error | Response | Action |
-|-------|----------|--------|
-| No project | "No prjct project" | STOP |
-| No session | "No active session" | STOP |
-| Already paused | Show paused state | STOP |
-| Write fails | Log warning | CONTINUE |
-
-## Examples
-
-### Example 1: Pause with Blocked Reason
-**Input:** `/p:pause blocked`
-**Prompt:** "What's blocking you?"
-**User:** "Waiting for API credentials from vendor"
-
-**Output:**
-```
-⏸️ Paused: implement auth
-
-Session: 550e8400-e29b-41d4-a716-446655440000
-Active time: 2h 30m
-Reason: blocked
-Note: Waiting for API credentials from vendor
-
-Next:
-• /p:resume - Continue this task
-• /p:now <task> - Start different task
-```
-
-### Example 2: Quick Break
-**Input:** `/p:pause break`
-
-**Output:**
-```
-⏸️ Paused: implement auth
-
-Session: 550e8400-e29b-41d4-a716-446655440000
-Active time: 2h 30m
-Reason: break
-
-Next:
-• /p:resume - Continue this task
-```
-
-### Example 3: Context Switch
-**Input:** `/p:pause switch`
-
-**Output:**
-```
-⏸️ Paused: implement auth
-
-Session: 550e8400-e29b-41d4-a716-446655440000
-Active time: 2h 30m
-Reason: switch
 
 Next:
-• /p:now <task> - Start the urgent task
+- Resume → `p. resume`
+- New task → `p. task "description"`
+- Complete without resuming → `p. done`
 ```