prjct-cli 0.35.3 → 0.35.4

package/templates/commands/next.md

@@ -1,124 +1,42 @@
 ---
 allowed-tools: [Read]
-description: 'Show priority queue'
-architecture: 'Write-Through (JSON → MD → Events)'
-storage-layer: true
-source-of-truth: 'storage/queue.json'
-claude-context: 'context/next.md'
 ---
 
-# /p:next - Show Priority Queue
+# p. next
 
-## Architecture: Write-Through Pattern
-
-Reads from **Storage (JSON)** as source of truth.
-
-**Source of Truth**: `storage/queue.json`
-**Also reads**: `storage/state.json` for current task status
-
-## Context Variables
-- `{projectId}`: From `.prjct/prjct.config.json`
-- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{queuePath}`: `{globalPath}/storage/queue.json`
-- `{statePath}`: `{globalPath}/storage/state.json`
-
-## Flow
+```bash
+prjct context next
+```
 
-1. Read `storage/state.json` → Check if active task
-2. Read `storage/queue.json` → Get queue tasks
-3. Display top 5 non-blocked tasks
+READ `{globalPath}/storage/queue.json`
+READ `{globalPath}/storage/state.json`
 
-## Response
+IF `currentTask` active → Show warning first
 
-**If active task**:
+**Output (queue view)**:
 ```
-⚠️ Active: {currentTask.description}
-
-Complete with /p:done first, or:
-
 📋 Queue ({count})
-1. {task_1}
+
+1. {task_1} [{priority}]
 2. {task_2}
 3. {task_3}
 ...
 
-Start: /p:work {N}
+Next:
+- Start task → `p. task "{task_1}"`
+- Add task → `p. task "description"`
+- Report bug → `p. bug "description"`
 ```
 
-**If no active task**:
-```
-📋 Queue ({count})
-
-1. {task_1} {priority}
-2. {task_2} {priority}
-3. {task_3} {priority}
-4. {task_4}
-5. {task_5}
-
-{IF count > 5: ... and {count - 5} more}
-
-Start: /p:work 1 or /p:now "{task}"
-```
-
-**If empty queue**:
+**Output (empty)**:
 ```
 📋 Queue is empty
 
-Add tasks:
-• /p:feature "description"
-• /p:bug "description"
-• /p:idea "quick note"
+Next:
+- Add task → `p. task "description"`
+- Report bug → `p. bug "description"`
+- Capture idea → `p. idea "note"`
 ```
 
-## Data Source
-
-| Data | Storage File | Field |
-|------|--------------|-------|
-| Current Task | `storage/state.json` | `currentTask` |
-| Queue Tasks | `storage/queue.json` | `tasks[]` |
-| Shipped | `storage/shipped.json` | `shipped[]` |
-
-## Usage Variants
-
-```
-/p:next                    # Priority queue (default)
-/p:next roadmap            # Feature-grouped view
-/p:next --roadmap          # Same as above
-```
-
-## Roadmap View
-
-When called with `roadmap` parameter, show feature-grouped view:
-
-```
-📍 PRODUCT ROADMAP
-
-🚀 Current Sprint
-├── ✅ {completed_feature} - shipped {date}
-├── 🔄 {active_feature} ({X}% complete)
-│   └── 🎯 {current_task}
-└── ⏳ {pending_feature} ({N} tasks)
-
-📅 Next Up ({N} features)
-├── {feature_1} - {effort}
-└── {feature_2} - {effort}
-
-📊 Velocity: {X.X} features/week
-
-/p:now "{next}" | /p:done
-```
-
-### Roadmap Data Aggregation
-
-1. Group queue tasks by `featureId`
-2. Calculate completion % per feature
-3. Sort by priority/dependency
-4. Show current task within active feature
-
-## Natural Language Support
-
-- "p. next" → Priority queue
-- "p. queue" → Priority queue
-- "p. what's next" → Priority queue
-- "p. roadmap" → Roadmap view
-- "p. features" → Roadmap view
+**Roadmap view** (`p. next roadmap`):
+Group by feature, show completion %

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`
 ```