@masslessai/push-todo 3.6.4 → 3.6.6

package/SKILL.md

@@ -36,13 +36,23 @@ When this command is invoked:
 
 5. Ask which task the user wants to work on
 
-6. **Check for resumable daemon sessions first:**
+6. **Check if the daemon is currently working on this task:**
+   - If the task output shows `**Status:** 🔄 Running`:
+     - The daemon is actively working on this task RIGHT NOW
+     - Follow the [Live Session Status](#live-session-status) procedure to show progress
+     - Do NOT start working on this task — the daemon is already on it
+   - If the task output shows `**Status:** ⚡ Queued for Mac execution`:
+     - The task is queued and waiting for the daemon to pick it up
+     - Tell the user: "This task is queued and will be picked up by the daemon shortly."
+     - Do NOT start working on this task
+
+7. **Check for resumable daemon sessions:**
    - If the task output contains `**Session:** Resumable`, the daemon already ran Claude Code on this task
    - Do NOT start working from scratch — automatically load the daemon's session context
    - Follow the [Auto-Resume from Session Transcript](#auto-resume-from-session-transcript) procedure below
    - Only if the session transcript cannot be found should you begin working from scratch
 
-7. If no resumable session exists, begin working on the task normally
+8. If no resumable session exists, begin working on the task normally
 
 ## Review Mode
 
@@ -203,13 +213,64 @@ If no CLAUDE.md or README.md exists, generate minimal keywords from:
 - Git repo name
 - Primary file extensions (`.swift` -> iOS, `.py` -> Python, `.rs` -> Rust)
 
-## Auto-Resume from Session Transcript
+## Auto-Resume from Daemon Session
 
-When a task has a resumable daemon session, automatically load the session context instead of starting from scratch. The daemon's session transcript contains every file read, edit, and decision — use it to continue intelligently.
+When a task has a resumable daemon session, use the git worktree branch directly instead of starting from scratch. The daemon commits its changes to a worktree branch — use that branch to see exactly what was done.
 
-### Step 1: Locate the Session File
+### Step 1: Find the Worktree Branch
 
-The daemon runs in a git worktree. Find the session transcript:
+The daemon creates a branch named `push-{number}-{suffix}`:
+
+```bash
+# Get machine ID suffix
+MACHINE_ID=$(cat ~/.config/push/machine_id 2>/dev/null)
+SUFFIX=$(echo "$MACHINE_ID" | rev | cut -d'-' -f1 | rev | cut -c1-8)
+TASK_NUM=<display_number>
+BRANCH="push-${TASK_NUM}-${SUFFIX}"
+
+# Check if branch exists and has commits
+git log master..${BRANCH} --oneline 2>/dev/null
+```
+
+### Step 2: Get Semantic Summary from Session Transcript
+
+Read the session transcript for context on *what* and *why* (reasoning, decisions):
+
+```bash
+SESSION_DIR="$HOME/.claude/projects/-Users-$(whoami)-projects-push-${TASK_NUM}-${SUFFIX}"
+SESSION_ID=<session_id_from_task>
+
+# Extract just the text reasoning (not file edits — we get those from git)
+cat "${SESSION_DIR}/${SESSION_ID}.jsonl" 2>/dev/null | node -e "
+const lines = [];
+process.stdin.on('data', d => lines.push(d));
+process.stdin.on('end', () => {
+  const entries = Buffer.concat(lines).toString().split('\n')
+    .filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean);
+  const texts = entries.filter(e => e.type === 'assistant')
+    .flatMap(a => (a.message?.content || []).filter(b => b.type === 'text' && b.text.trim()).map(b => b.text.trim()));
+  texts.forEach(t => console.log(t));
+});
+"
+```
+
+### Step 3: Review Changes and Act
+
+1. **Show the user** what the daemon did: semantic summary + `git diff master...${BRANCH}`
+2. **If the branch has commits** (daemon committed):
+   - Show the diff and ask if user wants to cherry-pick/merge to current branch
+   - Use `git cherry-pick <commit>` or `git merge ${BRANCH}` as appropriate
+3. **If the branch has NO commits** (daemon didn't commit — older daemon versions):
+   - Fall back to reading edits from the session transcript JSONL
+4. **If work is incomplete**, continue from where the daemon left off using the context from the transcript and the branch state
+
+## Live Session Status
+
+When a task is currently running (daemon is actively working on it), read the live session transcript to show the user what's happening.
+
+### Step 1: Locate the Live Session File
+
+The daemon runs Claude in a git worktree. Find the active session:
 
 ```bash
 # Get machine ID suffix for worktree name
@@ -219,18 +280,17 @@ TASK_NUM=<display_number>
 
 # Session files are stored under ~/.claude/projects/ with path-encoded directory names
 SESSION_DIR="$HOME/.claude/projects/-Users-$(whoami)-projects-push-${TASK_NUM}-${SUFFIX}"
-SESSION_ID=<session_id_from_task>
 
-# Check if transcript exists
-ls "${SESSION_DIR}/${SESSION_ID}.jsonl" 2>/dev/null
+# Find the most recent .jsonl file (the active session)
+ls -t "${SESSION_DIR}"/*.jsonl 2>/dev/null | head -1
 ```
 
-### Step 2: Extract Session Context
+### Step 2: Extract Recent Activity
 
-Read the JSONL transcript and extract what the daemon did:
+Read the last portion of the JSONL transcript to see what Claude is currently doing:
 
 ```bash
-cat "${SESSION_DIR}/${SESSION_ID}.jsonl" | node -e "
+tail -100 "<session_file>" | node -e "
 const lines = [];
 process.stdin.on('data', d => lines.push(d));
 process.stdin.on('end', () => {
@@ -239,38 +299,43 @@ process.stdin.on('end', () => {
 
   const assistantMsgs = entries.filter(e => e.type === 'assistant');
   const edits = [];
+  const reads = [];
   const texts = [];
 
   assistantMsgs.forEach(a => {
     (a.message?.content || []).forEach(b => {
       if (b.type === 'text' && b.text.trim()) texts.push(b.text.trim());
-      if (b.type === 'tool_use' && (b.name === 'Edit' || b.name === 'Write'))
-        edits.push(b.input?.file_path);
+      if (b.type === 'tool_use') {
+        if (b.name === 'Edit' || b.name === 'Write') edits.push(b.input?.file_path);
+        if (b.name === 'Read') reads.push(b.input?.file_path);
+      }
     });
   });
 
-  console.log('FILES_EDITED:', JSON.stringify(edits));
-  console.log('---TRANSCRIPT_START---');
-  texts.forEach(t => console.log(t));
-  console.log('---TRANSCRIPT_END---');
+  console.log('FILES_READ:', JSON.stringify([...new Set(reads)].slice(-10)));
+  console.log('FILES_EDITED:', JSON.stringify([...new Set(edits)]));
+  console.log('---RECENT_ACTIVITY---');
+  texts.slice(-5).forEach(t => console.log(t.slice(0, 200)));
+  console.log('---END---');
 });
 "
 ```
 
-### Step 3: Present Context and Continue
+### Step 3: Present Status to User
 
-1. Tell the user what the daemon did (root cause found, files edited, commits made)
-2. Check if the daemon's changes are already in the main branch (it may have committed to a worktree branch)
-3. If the daemon's work is complete but not merged, help merge/cherry-pick the changes
-4. If the daemon's work is incomplete, continue from where it left off using the context
+Show a concise summary:
+1. "The daemon is currently working on this task"
+2. Files it has read so far
+3. Files it has edited so far
+4. Its most recent reasoning/activity (last few text messages)
+5. "Check back in a few minutes, or run `/push-todo <number>` again for an update"
 
-### Fallback: Terminal Resume
+Do NOT offer to start working on the task — the daemon is already handling it.
 
-If the session transcript can't be read (file not found, parse error), tell the user they can also resume interactively in a **new terminal**:
-```
-push-todo resume <number>
-```
-This launches a full interactive Claude Code session with the daemon's complete conversation history.
+### Fallback
+
+If the session file cannot be found (daemon just started, no output yet):
+- Tell the user: "The daemon just started working on this task. Run `/push-todo <number>` again in a minute for a progress update."
 
 ## CLI Reference
 

package/lib/daemon.js

@@ -780,9 +780,10 @@ function executeTask(task) {
 
 ${content}
 
-IMPORTANT: When you're done, the SessionEnd hook will automatically report completion to Supabase.
-
-If you need to understand the codebase, start by reading the CLAUDE.md file if it exists.`;
+IMPORTANT:
+1. If you need to understand the codebase, start by reading the CLAUDE.md file if it exists.
+2. ALWAYS commit your changes before finishing. Use a descriptive commit message summarizing what you did. This is critical — uncommitted changes will be lost when the worktree is cleaned up.
+3. When you're done, the SessionEnd hook will automatically report completion to Supabase.`;
 
   // Update status to running
   updateTaskStatus(displayNumber, 'running');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masslessai/push-todo",
-  "version": "3.6.4",
+  "version": "3.6.6",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {