prjct-cli 0.13.3 → 0.15.0

package/templates/commands/resume.md

@@ -2,16 +2,32 @@
 allowed-tools: [Read, Write, Bash]
 description: 'Resume paused session'
 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:resume - Resume Paused Session
 
+## Architecture: Write-Through Pattern
+
+```
+User Action → Storage (JSON) → Context (MD) → Sync Events
+```
+
+**Source of Truth**: `storage/state.json`
+**Claude Context**: `context/now.md` (generated)
+**Backend Sync**: `sync/pending.json` (events)
+
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
-- `{sessionPath}`: `{globalPath}/sessions/current.json`
-- `{nowPath}`: `{globalPath}/core/now.md`
-- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+- `{statePath}`: `{globalPath}/storage/state.json`
+- `{nowContextPath}`: `{globalPath}/context/now.md`
+- `{syncPath}`: `{globalPath}/sync/pending.json`
+- `{memoryPath}`: `{globalPath}/memory/events.jsonl`
 
 ## Step 1: Read Config
 
@@ -22,11 +38,12 @@ IF file not found:
   OUTPUT: "No prjct project. Run /p:init first."
   STOP
 
-## Step 2: Check Session State
+## Step 2: Check Current State
 
-READ: `{sessionPath}`
+### Read state.json (source of truth)
+READ: `{statePath}`
 
-IF file not found OR empty:
+IF file not found:
   OUTPUT:
   ```
   ⚠️ No paused session to resume.
@@ -36,97 +53,115 @@ IF file not found OR empty:
   ```
   STOP
 
-PARSE as JSON → {session}
+PARSE JSON
+EXTRACT: {currentTask}, {pausedTask}
 
-IF {session.status} == "active":
-  CALCULATE: {elapsed} = time since last start/resume
+IF {currentTask} exists AND {currentTask.status} == "active":
+  CALCULATE: {elapsed} = time since last start
   OUTPUT:
   ```
-  ▶️ Already active: {session.task}
+  ▶️ Already active: {currentTask.description}
 
-  Session: {session.id}
+  Session: {currentTask.sessionId}
   Working for: {elapsed}
 
   /p:done to complete | /p:pause to pause
   ```
   STOP
 
-IF {session.status} == "completed":
+IF {pausedTask} is null:
   OUTPUT:
   ```
-  ⚠️ Session already completed.
+  ⚠️ No paused session to resume.
 
   Start a new task:
   • /p:now <task>
   ```
   STOP
 
-IF {session.status} != "paused":
-  OUTPUT: "⚠️ No paused session to resume."
-  STOP
-
 ## Step 3: Calculate Pause Duration
 
 SET: {now} = GetTimestamp()
-SET: {pauseDuration} = time since {session.pausedAt}
+SET: {pauseDurationSeconds} = seconds between {pausedTask.pausedAt} and {now}
 SET: {pauseFormatted} = format as "Xh Ym" or "Xm"
 
-## Step 4: Update Session
+## Step 4: Update Storage (SOURCE OF TRUTH)
 
-UPDATE {session}:
+### Prepare resumed task
 ```json
 {
-  "id": "{session.id}",
-  "projectId": "{session.projectId}",
-  "task": "{session.task}",
+  "id": "{pausedTask.id}",
+  "description": "{pausedTask.description}",
   "status": "active",
-  "startedAt": "{session.startedAt}",
-  "pausedAt": null,
-  "completedAt": null,
-  "duration": {session.duration},
-  "metrics": {session.metrics},
-  "timeline": [
-    ...{session.timeline},
-    {"type": "resume", "at": "{now}"}
-  ]
+  "startedAt": "{pausedTask.startedAt}",
+  "resumedAt": "{now}",
+  "sessionId": "{pausedTask.sessionId}",
+  "duration": {pausedTask.duration},
+  "estimate": "{pausedTask.estimate}",
+  "estimateSeconds": {pausedTask.estimateSeconds}
 }
 ```
 
-WRITE: `{sessionPath}`
-Content: Updated session JSON
+### Update state.json
+READ: `{statePath}`
+SET: state.currentTask = resumed task object
+SET: state.pausedTask = null
+SET: state.lastUpdated = {now}
+WRITE: `{statePath}`
 
-## Step 5: Update Legacy now.md
+## Step 5: Generate Context (FOR CLAUDE)
+
+WRITE: `{nowContextPath}`
 
-WRITE: `{nowPath}`
-Content:
 ```markdown
 # NOW
 
-**{session.task}**
+**{pausedTask.description}**
 
-Started: {session.startedAt}
+Started: {pausedTask.startedAt}
 Resumed: {now}
-Session: {session.id}
+Session: {pausedTask.sessionId}
+{IF pausedTask.estimate: Estimate: {pausedTask.estimate}}
+```
+
+## Step 6: Queue Sync Event (FOR BACKEND)
+
+READ: `{syncPath}` or create empty array
+APPEND event:
+```json
+{
+  "type": "task.resumed",
+  "path": ["state"],
+  "data": {
+    "taskId": "{pausedTask.id}",
+    "description": "{pausedTask.description}",
+    "resumedAt": "{now}",
+    "pauseDuration": {pauseDurationSeconds}
+  },
+  "timestamp": "{now}",
+  "projectId": "{projectId}"
+}
 ```
+WRITE: `{syncPath}`
 
-## Step 6: Log to Memory
+## Step 7: Log to Memory (AUDIT TRAIL)
 
 APPEND to: `{memoryPath}`
 
 Single line (JSONL):
 ```json
-{"timestamp":"{now}","action":"session_resumed","sessionId":"{session.id}","task":"{session.task}","pauseDuration":{pauseDurationSeconds}}
+{"timestamp":"{now}","action":"task_resumed","taskId":"{pausedTask.id}","sessionId":"{pausedTask.sessionId}","task":"{pausedTask.description}","pauseDuration":{pauseDurationSeconds}}
 ```
 
 ## Output
 
 SUCCESS:
 ```
-▶️ Resumed: {session.task}
+▶️ Resumed: {pausedTask.description}
 
-Session: {session.id}
+Session: {pausedTask.sessionId}
 Was paused: {pauseFormatted}
-Total active: {session.duration} (before this stretch)
+Total active: {pausedTask.duration} (before this stretch)
 
 /p:done when finished | /p:pause for another break
 ```
@@ -136,26 +171,24 @@ Total active: {session.duration} (before this stretch)
 | Error | Response | Action |
 |-------|----------|--------|
 | No project | "No prjct project" | STOP |
-| No session | "No paused session" | STOP |
+| No paused task | "No paused session" | STOP |
 | Already active | Show active state | STOP |
-| Already completed | Suggest /p:now | STOP |
 | Write fails | Log warning | CONTINUE |
 
 ## Examples
 
 ### Example 1: Resume Paused Session
-**Session:**
+**State:**
 ```json
 {
-  "id": "sess_abc12345",
-  "task": "implement auth",
-  "status": "paused",
-  "pausedAt": "2025-12-07T12:30:00.000Z",
-  "duration": 9000,
-  "timeline": [
-    {"type": "start", "at": "2025-12-07T10:00:00.000Z"},
-    {"type": "pause", "at": "2025-12-07T12:30:00.000Z"}
-  ]
+  "currentTask": null,
+  "pausedTask": {
+    "id": "550e8400-e29b-41d4-a716-446655440000",
+    "description": "implement auth",
+    "status": "paused",
+    "pausedAt": "2025-12-07T12:30:00.000Z",
+    "duration": 9000
+  }
 }
 ```
 
@@ -165,7 +198,7 @@ Total active: {session.duration} (before this stretch)
 ```
 ▶️ Resumed: implement auth
 
-Session: sess_abc12345
+Session: 550e8400-e29b-41d4-a716-446655440000
 Was paused: 1h 30m
 Total active: 2h 30m (before this stretch)
 
@@ -177,7 +210,7 @@ Total active: 2h 30m (before this stretch)
 ```
 ▶️ Already active: implement auth
 
-Session: sess_abc12345
+Session: 550e8400-e29b-41d4-a716-446655440000
 Working for: 45m
 
 /p:done to complete | /p:pause to pause
@@ -199,3 +232,52 @@ Detect intent for resume:
 - "p. continue" → Resume paused session
 - "p. back to work" → Resume paused session
 - "p. unpause" → Resume paused session
+- "p. recover" → Recovery mode (abandoned session)
+
+## Recovery Mode (Abandoned Sessions)
+
+When called as `/p:resume --recover` OR when detecting sessions older than 8 hours:
+
+### Detection
+IF {currentTask} exists AND hours since {lastActivity} >= 8:
+  TRIGGER: Recovery mode
+
+### Recovery Options
+
+OUTPUT:
+```
+🔄 Found abandoned session
+
+Task: {task.description}
+Session: {task.sessionId}
+Started: {task.startedAt}
+Last activity: {hoursAgo}h ago
+
+📝 Original prompt (if saved):
+┌────────────────────────────────────────
+│ {task.context.prompt}
+└────────────────────────────────────────
+
+Options:
+1. ▶️  Resume - Continue this session
+2. ✅ Close - Mark as partial completion (counts in metrics)
+3. 🗑️  Discard - Remove without logging
+4. ⏸️  Save - Archive for later reference
+
+Choose [1-4]:
+```
+
+### Choice Handling
+
+| Choice | Action | Storage Update |
+|--------|--------|----------------|
+| 1. Resume | Continue session | `status: active`, `resumedAt: now` |
+| 2. Close | Mark partial completion | Log to sessions, clear task |
+| 3. Discard | Remove without metrics | Clear task, audit log only |
+| 4. Save | Archive for later | `savedTask: {...}`, clear current |
+
+### Events Logged
+
+```json
+{"type": "session.recovered", "gapHours": {hoursAgo}, "choice": "{choice}"}
+```