@masslessai/push-todo 4.0.7 → 4.1.0

package/lib/auto-connect.js

@@ -0,0 +1,195 @@
+/**
+ * Auto-connect orchestrator for Push CLI.
+ *
+ * Scans the user's home folder for Claude Code, Codex, and OpenClaw projects,
+ * then batch-registers them all with the Push backend in one shot.
+ *
+ * Usage: push-todo connect --auto
+ */
+
+import { getApiKey, saveCredentials, getEmail } from './config.js';
+import {
+  CLIENT_TO_ACTION_TYPE,
+  registerProjectWithBackendExplicit,
+  registerProjectLocally,
+  doFullDeviceAuth,
+} from './connect.js';
+import { getRegistry } from './project-registry.js';
+import { normalizeGitRemote } from './utils/git.js';
+import { discoverAllProjects } from './discovery.js';
+import { createSpinner } from './utils/spinner.js';
+import { bold, green, red, dim, cyan } from './utils/colors.js';
+import { ensureDaemonRunning } from './daemon-health.js';
+
+/**
+ * Run the auto-connect flow.
+ *
+ * 1. Ensure authenticated
+ * 2. Scan for projects across all agents
+ * 3. Deduplicate and filter already-registered
+ * 4. Batch-register with backend + local registry
+ * 5. Display progress and summary
+ *
+ * @param {Object} options - CLI options
+ */
+export async function runAutoConnect(options = {}) {
+  // Self-healing: ensure daemon is running
+  ensureDaemonRunning();
+
+  console.log('');
+  console.log(`  ${bold('Push Auto-Connect')}`);
+  console.log(`  ${'='.repeat(40)}`);
+  console.log('');
+
+  // Phase 1: Ensure authenticated
+  let apiKey;
+  try {
+    apiKey = getApiKey();
+  } catch {
+    apiKey = null;
+  }
+  const email = getEmail();
+
+  if (!apiKey || !email) {
+    console.log('  Not authenticated. Starting auth flow...');
+    console.log('');
+    const authResult = await doFullDeviceAuth('claude-code');
+    saveCredentials(authResult.api_key, authResult.email);
+    apiKey = authResult.api_key;
+    console.log('');
+    console.log(`  ${green('✓')} Authenticated as ${authResult.email}`);
+    console.log('');
+  } else {
+    console.log(`  ${green('✓')} Authenticated as ${email}`);
+    console.log('');
+  }
+
+  // Phase 2: Scan for projects
+  console.log('  Scanning for projects...');
+
+  const spinner = createSpinner();
+
+  spinner.start('Scanning Claude Code projects...');
+  const { projects, counts } = discoverAllProjects();
+
+  // Show per-agent results
+  if (counts.claudeCode > 0) {
+    spinner.succeed(`Claude Code: ${counts.claudeCode} projects found`);
+  } else {
+    spinner.info('Claude Code: no projects found');
+  }
+
+  const spinner2 = createSpinner();
+  if (counts.codex > 0) {
+    spinner2.succeed(`Codex: ${counts.codex} projects found`);
+  } else {
+    spinner2.info('Codex: not installed or no projects');
+  }
+
+  const spinner3 = createSpinner();
+  if (counts.openclaw > 0) {
+    spinner3.succeed(`OpenClaw: ${counts.openclaw} projects found`);
+  } else {
+    spinner3.info('OpenClaw: not installed or no projects');
+  }
+
+  if (projects.length === 0) {
+    console.log('');
+    console.log('  No projects with git remotes found.');
+    console.log(`  ${dim('Projects must have a git remote to be registered.')}`);
+    console.log('');
+    return;
+  }
+
+  console.log('');
+  console.log(`  ${bold(`${projects.length} unique projects`)} to process`);
+  console.log(`  ${'─'.repeat(40)}`);
+  console.log('');
+
+  // Phase 3: Check which are already registered
+  const registry = getRegistry();
+  const toRegister = [];
+  let alreadyConnected = 0;
+
+  for (const project of projects) {
+    const actionType = CLIENT_TO_ACTION_TYPE[project.agentType] || project.agentType;
+    const existingPath = registry.getPathWithoutUpdate(project.gitRemote, actionType);
+    if (existingPath) {
+      alreadyConnected++;
+      console.log(`  ${dim('○')} ${dim(project.gitRemote)} ${dim(`(${project.agentType})`)} ${dim('— already connected')}`);
+    } else {
+      toRegister.push(project);
+    }
+  }
+
+  if (toRegister.length === 0) {
+    console.log('');
+    console.log(`  ${'='.repeat(40)}`);
+    console.log(`  All ${alreadyConnected} projects already connected.`);
+    console.log('');
+    return;
+  }
+
+  // Phase 4: Register new projects
+  let registered = 0;
+  let failed = 0;
+
+  for (const project of toRegister) {
+    const regSpinner = createSpinner();
+    const label = `${project.gitRemote} (${project.agentType})`;
+    regSpinner.start(`Registering ${label}...`);
+
+    try {
+      const result = await registerProjectWithBackendExplicit(
+        apiKey,
+        project.agentType,
+        project.projectPath,
+        project.gitRemote,
+        project.projectContext
+      );
+
+      if (result.status === 'unauthorized') {
+        regSpinner.fail(`${label} — session expired`);
+        console.log('');
+        console.log(`  ${red('Error:')} API key invalid or revoked.`);
+        console.log(`  Run ${cyan("'push-todo connect --reauth'")} to re-authenticate.`);
+        console.log('');
+        return;
+      }
+
+      if (result.status === 'success') {
+        // Register locally
+        const actionType = result.action_type || CLIENT_TO_ACTION_TYPE[project.agentType] || project.agentType;
+        registerProjectLocally(project.gitRemote, project.projectPath, {
+          actionType,
+          actionId: result.action_id,
+          actionName: result.action_name,
+        });
+        regSpinner.succeed(label);
+        registered++;
+      } else {
+        regSpinner.fail(`${label} — ${result.message || 'unknown error'}`);
+        failed++;
+      }
+    } catch (error) {
+      regSpinner.fail(`${label} — ${error.message}`);
+      failed++;
+    }
+  }
+
+  // Phase 5: Summary
+  console.log('');
+  console.log(`  ${'='.repeat(40)}`);
+
+  const parts = [];
+  if (registered > 0) parts.push(green(`${registered} registered`));
+  if (alreadyConnected > 0) parts.push(dim(`${alreadyConnected} already connected`));
+  if (failed > 0) parts.push(red(`${failed} failed`));
+
+  console.log(`  ${parts.join(', ')}`);
+
+  if (registered > 0) {
+    console.log(`  Run ${cyan("'push-todo'")} to see your tasks.`);
+  }
+  console.log('');
+}

package/lib/cli.js

@@ -95,6 +95,7 @@ ${bold('CONNECT OPTIONS:')}
   --validate-project               Validate project registration (JSON output)
   --store-e2ee-key <key>           Import E2EE encryption key
   --description <text>             Project description (with connect)
+  --auto                           Auto-discover and register all projects
 
 ${bold('CONFIRM (for daemon skills):')}
   push-todo confirm --type "social_post" --title "Post tweet" --content "..."
@@ -158,6 +159,7 @@ const options = {
   'validate-project': { type: 'boolean' },
   'store-e2ee-key': { type: 'string' },
   'description': { type: 'string' },
+  'auto': { type: 'boolean' },
   // Confirm command options
   'type': { type: 'string' },
   'title': { type: 'string' },
@@ -351,21 +353,34 @@ export async function run(argv) {
       const suffix = parts.length > 1 ? parts[parts.length - 1].slice(0, 8) : machineId.slice(0, 8);
       const worktreeName = `push-${displayNumber}-${suffix}`;
 
-      // Try to find the worktree relative to CWD's parent (sibling directory)
-      const candidate = join(dirname(process.cwd()), worktreeName);
-      if (existsSync(candidate)) {
-        resumeCwd = candidate;
-        console.log(`Found daemon worktree: ${candidate}`);
+      // Check new location first (inside project at .claude/worktrees/)
+      const newCandidate = join(process.cwd(), '.claude', 'worktrees', worktreeName);
+      // Check legacy location (sibling directory, pre-migration daemon)
+      const legacyCandidate = join(dirname(process.cwd()), worktreeName);
+
+      if (existsSync(newCandidate)) {
+        resumeCwd = newCandidate;
+        console.log(`Found daemon worktree: ${newCandidate}`);
+      } else if (existsSync(legacyCandidate)) {
+        resumeCwd = legacyCandidate;
+        console.log(`Found daemon worktree (legacy): ${legacyCandidate}`);
       } else {
         // Worktree was cleaned up after daemon finished, but the session file
         // still exists at ~/.claude/projects/. Re-create the directory so Claude
         // maps CWD to the correct session directory and finds the session.
         try {
-          mkdirSync(candidate, { recursive: true });
-          resumeCwd = candidate;
-          console.log(`Re-created worktree directory for session lookup: ${candidate}`);
+          mkdirSync(newCandidate, { recursive: true });
+          resumeCwd = newCandidate;
+          console.log(`Re-created worktree directory for session lookup: ${newCandidate}`);
         } catch {
-          console.log(dim(`Could not create worktree dir at ${candidate}, using current directory`));
+          // Fall back to legacy location
+          try {
+            mkdirSync(legacyCandidate, { recursive: true });
+            resumeCwd = legacyCandidate;
+            console.log(`Re-created worktree directory for session lookup: ${legacyCandidate}`);
+          } catch {
+            console.log(dim(`Could not create worktree dir, using current directory`));
+          }
         }
       }
     } catch {
@@ -633,6 +648,10 @@ export async function run(argv) {
 
   // Connect command
   if (command === 'connect') {
+    if (values.auto) {
+      const { runAutoConnect } = await import('./auto-connect.js');
+      return runAutoConnect(values);
+    }
     return runConnect(values);
   }
 

package/lib/connect.js

@@ -950,7 +950,7 @@ async function registerProjectWithBackend(apiKey, clientType = 'claude-code', ke
 
 // Mapping from CLI client_type to canonical DB action_type
 // Must match CLIENT_TO_ACTION_TYPE in register-project edge function
-const CLIENT_TO_ACTION_TYPE = {
+export const CLIENT_TO_ACTION_TYPE = {
   'claude-code': 'claude-code',
   'openai-codex': 'openai-codex',
   'openclaw': 'openclaw',
@@ -1378,6 +1378,65 @@ export async function runConnect(options = {}) {
   console.log('');
 }
 
+/**
+ * Register a project with the backend using explicit path and remote.
+ * Used by auto-connect for registering discovered projects at arbitrary paths.
+ *
+ * @param {string} apiKey - Push API key
+ * @param {string} clientType - Agent type (claude-code, openai-codex, openclaw)
+ * @param {string} projectPath - Absolute path to the project
+ * @param {string} gitRemote - Raw git remote URL
+ * @param {string|null} projectContext - First 50 lines of CLAUDE.md/README.md for keyword generation
+ * @returns {Promise<Object>} Registration result with status, action_id, action_type, etc.
+ */
+async function registerProjectWithBackendExplicit(apiKey, clientType, projectPath, gitRemote, projectContext = null) {
+  const clientName = CLIENT_NAMES[clientType] || 'Claude Code';
+
+  const payload = {
+    client_type: clientType,
+    client_name: clientName,
+    device_name: getDeviceName(),
+    project_path: projectPath,
+    git_remote: gitRemote,
+  };
+
+  if (projectContext) {
+    payload.project_context = projectContext;
+  }
+
+  const response = await fetch(`${API_BASE}/register-project`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'apikey': ANON_KEY,
+      'Authorization': `Bearer ${apiKey}`
+    },
+    body: JSON.stringify(payload)
+  });
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      return { status: 'unauthorized', message: 'API key invalid or revoked' };
+    }
+    const body = await response.json().catch(() => ({}));
+    return { status: 'error', message: body.error_description || `HTTP ${response.status}` };
+  }
+
+  const data = await response.json();
+  if (data.success) {
+    return {
+      status: 'success',
+      action_id: data.action_id || null,
+      action_type: data.action_type || null,
+      action_name: data.normalized_name || data.action_name || 'Unknown',
+      created: data.created !== false,
+      message: data.message || ''
+    };
+  }
+
+  return { status: 'error', message: 'Unknown error' };
+}
+
 export {
   checkVersion,
   doUpdate,
@@ -1388,5 +1447,9 @@ export {
   storeE2EEKeyDirect,
   showStatus,
   getInstallationMethod,
+  registerProjectWithBackendExplicit,
+  registerProjectLocally,
+  doFullDeviceAuth,
+  CLIENT_NAMES,
   VERSION
 };

package/lib/daemon.js

@@ -448,10 +448,23 @@ async function fetchQueuedTasks() {
 
 async function fetchScheduledTodos() {
   try {
+    const machineId = getMachineId();
     const params = new URLSearchParams();
     params.set('scheduled_before', new Date().toISOString());
+    if (machineId) {
+      params.set('machine_id', machineId);
+    }
 
-    const response = await apiRequest(`synced-todos?${params}`);
+    // Include registered git_remotes so backend can scope to this machine's projects
+    const projects = getListedProjects();
+    const gitRemotes = Object.keys(projects);
+    const headers = {};
+    if (machineId && gitRemotes.length > 0) {
+      headers['X-Machine-Id'] = machineId;
+      headers['X-Git-Remotes'] = gitRemotes.join(',');
+    }
+
+    const response = await apiRequest(`synced-todos?${params}`, { headers });
     if (!response.ok) return [];
 
     const data = await response.json();
@@ -466,11 +479,33 @@ async function checkAndQueueScheduledTodos() {
   const scheduledTodos = await fetchScheduledTodos();
   if (scheduledTodos.length === 0) return;
 
+  const registeredProjects = getListedProjects();
+
   for (const todo of scheduledTodos) {
-    const dn = todo.displayNumber;
+    const dn = todo.displayNumber || todo.display_number;
     const todoId = todo.id;
 
-    log(`Schedule triggered for #${dn} (reminder_date: ${todo.reminderDate})`);
+    // Skip tasks already in an execution state (running, queued, completed, failed, etc.)
+    const execStatus = todo.executionStatus || todo.execution_status;
+    if (execStatus && execStatus !== 'none') {
+      continue;
+    }
+
+    // Skip completed tasks
+    if (todo.isCompleted || todo.is_completed) {
+      continue;
+    }
+
+    // Skip tasks whose project is not registered on this machine
+    const gitRemote = todo.gitRemote || todo.git_remote;
+    if (gitRemote && Object.keys(registeredProjects).length > 0) {
+      if (!(gitRemote in registeredProjects)) {
+        log(`Schedule skipped #${dn}: project ${gitRemote} not registered on this machine`);
+        continue;
+      }
+    }
+
+    log(`Schedule triggered for #${dn} (reminder_date: ${todo.reminderDate || todo.reminder_date})`);
 
     try {
       await updateTaskStatus(dn, 'queued', {
@@ -557,8 +592,7 @@ async function claimTask(displayNumber, todoId, sessionId) {
     return true;
   }
 
-  const suffix = getWorktreeSuffix();
-  const branch = `push-${displayNumber}-${suffix}`;
+  const branch = getBranchName(displayNumber);
 
   const payload = {
     todoId: todoId || undefined,     // UUID lookup (primary, avoids display_number collisions)
@@ -731,62 +765,32 @@ function getWorktreeSuffix() {
   return 'local';
 }
 
-function getWorktreePath(displayNumber, projectPath) {
+// Worktree name passed to Claude Code's --worktree flag
+function getWorktreeName(displayNumber) {
   const suffix = getWorktreeSuffix();
-  const worktreeName = `push-${displayNumber}-${suffix}`;
-
-  if (projectPath) {
-    return join(dirname(projectPath), worktreeName);
-  }
-  return join(process.cwd(), '..', worktreeName);
+  return `push-${displayNumber}-${suffix}`;
 }
 
-function createWorktree(displayNumber, projectPath) {
-  const suffix = getWorktreeSuffix();
-  const branch = `push-${displayNumber}-${suffix}`;
-  const worktreePath = getWorktreePath(displayNumber, projectPath);
-
-  if (existsSync(worktreePath)) {
-    log(`Worktree already exists: ${worktreePath}`);
-    return worktreePath;
-  }
-
-  const gitCwd = projectPath || process.cwd();
+// Branch name created by Claude Code's --worktree (adds "worktree-" prefix)
+function getBranchName(displayNumber) {
+  return `worktree-${getWorktreeName(displayNumber)}`;
+}
 
-  try {
-    // Try to create with new branch
-    execSync(`git worktree add "${worktreePath}" -b ${branch}`, {
-      cwd: gitCwd,
-      timeout: 30000,
-      stdio: 'pipe'
-    });
-    log(`Created worktree: ${worktreePath}`);
-    return worktreePath;
-  } catch {
-    // Branch might already exist, try without -b
-    try {
-      execSync(`git worktree add "${worktreePath}" ${branch}`, {
-        cwd: gitCwd,
-        timeout: 30000,
-        stdio: 'pipe'
-      });
-      log(`Created worktree (existing branch): ${worktreePath}`);
-      return worktreePath;
-    } catch (e) {
-      logError(`Failed to create worktree: ${e.message}`);
-      return null;
-    }
-  }
+function getWorktreePath(displayNumber, projectPath) {
+  const wtName = getWorktreeName(displayNumber);
+  const basePath = projectPath || process.cwd();
+  return join(basePath, '.claude', 'worktrees', wtName);
 }
 
+// createWorktree() removed — Claude Code's --worktree flag handles creation
+
 function cleanupWorktree(displayNumber, projectPath) {
   const worktreePath = getWorktreePath(displayNumber, projectPath);
 
   if (!existsSync(worktreePath)) return;
 
   const gitCwd = projectPath || process.cwd();
-  const suffix = getWorktreeSuffix();
-  const branch = `push-${displayNumber}-${suffix}`;
+  const branch = getBranchName(displayNumber);
 
   try {
     execSync(`git worktree remove "${worktreePath}" --force`, {
@@ -804,8 +808,7 @@ function cleanupWorktree(displayNumber, projectPath) {
 // ==================== PR Auto-Creation ====================
 
 function createPRForTask(displayNumber, summary, projectPath) {
-  const suffix = getWorktreeSuffix();
-  const branch = `push-${displayNumber}-${suffix}`;
+  const branch = getBranchName(displayNumber);
   const gitCwd = projectPath || process.cwd();
 
   try {
@@ -889,8 +892,7 @@ function mergePRForTask(displayNumber, prUrl, projectPath) {
   if (firstResult !== 'conflict') return false;  // non-conflict failure
 
   // Conflict detected — try to resolve with Claude
-  const suffix = getWorktreeSuffix();
-  const branch = `push-${displayNumber}-${suffix}`;
+  const branch = getBranchName(displayNumber);
   const resolved = resolveConflictsWithClaude(displayNumber, branch, gitCwd);
   if (!resolved) return false;
 
@@ -1103,13 +1105,14 @@ async function hasApprovedConfirmation(displayNumber) {
  * Returns true if the task was healed (status updated, no re-execution needed).
  */
 async function autoHealExistingWork(displayNumber, summary, projectPath, taskId) {
-  const suffix = getWorktreeSuffix();
-  const branch = `push-${displayNumber}-${suffix}`;
+  const branch = getBranchName(displayNumber);
+  const legacyBranch = `push-${displayNumber}-${getWorktreeSuffix()}`;
   const gitCwd = projectPath || process.cwd();
 
   try {
-    // Check if branch has commits ahead of main
+    // Check if branch has commits ahead of main (try new name, then legacy)
     let hasCommits = false;
+    let activeBranch = branch;
     try {
       const logResult = execSync(
         `git log HEAD..origin/${branch} --oneline 2>/dev/null || git log HEAD..${branch} --oneline 2>/dev/null`,
@@ -1117,22 +1120,35 @@ async function autoHealExistingWork(displayNumber, summary, projectPath, taskId)
       ).toString().trim();
       hasCommits = logResult.length > 0;
     } catch {
-      // Branch doesn't exist — no previous work
-      return false;
+      // New branch doesn't exist — try legacy branch from pre-migration daemon
+      try {
+        const legacyResult = execSync(
+          `git log HEAD..origin/${legacyBranch} --oneline 2>/dev/null || git log HEAD..${legacyBranch} --oneline 2>/dev/null`,
+          { cwd: gitCwd, timeout: 10000, stdio: ['ignore', 'pipe', 'pipe'] }
+        ).toString().trim();
+        if (legacyResult.length > 0) {
+          hasCommits = true;
+          activeBranch = legacyBranch;
+          log(`Task #${displayNumber}: found work on legacy branch ${legacyBranch}`);
+        }
+      } catch {
+        // Neither branch exists — no previous work
+        return false;
+      }
     }
 
     if (!hasCommits) {
       return false;
     }
 
-    log(`Task #${displayNumber}: found existing commits on branch ${branch}`);
+    log(`Task #${displayNumber}: found existing commits on branch ${activeBranch}`);
 
     // Check for existing PR
     let prUrl = null;
     let prState = null;
     try {
       const prResult = execSync(
-        `gh pr list --head ${branch} --state all --json url,state --jq '.[0]' 2>/dev/null`,
+        `gh pr list --head ${activeBranch} --state all --json url,state --jq '.[0]' 2>/dev/null`,
         { cwd: gitCwd, timeout: 15000, stdio: ['ignore', 'pipe', 'pipe'] }
       ).toString().trim();
       if (prResult) {
@@ -1391,6 +1407,51 @@ function extractSemanticSummary(worktreePath, sessionId) {
   }
 }
 
+/**
+ * Ask Claude to generate a Mermaid diagram of the key change it made.
+ * Uses the same session-resume pattern as extractSemanticSummary.
+ *
+ * @param {string} worktreePath - Path to the git worktree where Claude ran
+ * @param {string} sessionId - Claude session ID
+ * @returns {string|null} Mermaid diagram source code, or null if extraction fails
+ */
+function extractVisualArtifact(worktreePath, sessionId) {
+  if (!worktreePath || !sessionId) return null;
+
+  try {
+    const result = execFileSync('claude', [
+      '--resume', sessionId,
+      '--print',
+      'Generate a Mermaid diagram showing the key architectural change or flow you implemented. ' +
+      'Use graph LR for component relationships, sequenceDiagram for API/data flow, ' +
+      'or gitGraph for branch operations. Keep it simple (5-10 nodes max). ' +
+      'Output ONLY the raw Mermaid code. No markdown fences, no explanation, no comments.'
+    ], {
+      cwd: worktreePath,
+      timeout: 30000,
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+
+    const mermaid = result.toString().trim();
+    if (!mermaid || mermaid.length === 0) return null;
+
+    // Validate: must start with a known Mermaid diagram keyword
+    const validStarts = ['graph ', 'graph\n', 'flowchart ', 'flowchart\n',
+      'sequenceDiagram', 'gitGraph', 'classDiagram', 'stateDiagram',
+      'erDiagram', 'gantt', 'pie'];
+    if (!validStarts.some(s => mermaid.startsWith(s))) {
+      log(`Visual artifact extraction returned non-Mermaid content, skipping`);
+      return null;
+    }
+
+    // Cap at 2000 chars — diagrams beyond this are too complex to be useful
+    return mermaid.length > 2000 ? mermaid.slice(0, 2000) : mermaid;
+  } catch (error) {
+    log(`Visual artifact extraction failed: ${error.message}`);
+    return null;
+  }
+}
+
 // ==================== Task Execution ====================
 
 function updateTaskDetail(displayNumber, updates) {
@@ -1479,13 +1540,9 @@ async function executeTask(task) {
 
   log(`Executing task #${displayNumber}: ${content.slice(0, 60)}...`);
 
-  // Create worktree
-  const worktreePath = createWorktree(displayNumber, projectPath);
-  if (!worktreePath) {
-    await updateTaskStatus(displayNumber, 'failed', { error: 'Failed to create git worktree' }, taskId);
-    taskDetails.delete(displayNumber);
-    return null;
-  }
+  // Worktree path — Claude Code's --worktree flag handles creation
+  const worktreeName = getWorktreeName(displayNumber);
+  const worktreePath = getWorktreePath(displayNumber, projectPath);
 
   taskProjectPaths.set(displayNumber, projectPath);
 
@@ -1540,6 +1597,7 @@ async function executeTask(task) {
 
   const claudeArgs = [
     '-p', prompt,
+    '--worktree', worktreeName,
     '--allowedTools', allowedTools,
     '--output-format', 'json',
     '--permission-mode', 'bypassPermissions',
@@ -1548,7 +1606,7 @@ async function executeTask(task) {
 
   try {
     const child = spawn('claude', claudeArgs, {
-      cwd: worktreePath,
+      cwd: projectPath || process.cwd(),
       stdio: ['ignore', 'pipe', 'pipe'],
       env: (() => {
         const env = { ...process.env, PUSH_TASK_ID: task.id, PUSH_DISPLAY_NUMBER: String(displayNumber) };
@@ -1675,8 +1733,11 @@ async function handleTaskCompletion(displayNumber, exitCode) {
     // Auto-create PR first so we can include it in the summary
     const prUrl = createPRForTask(displayNumber, summary, projectPath);
 
-    // Ask Claude to summarize what it accomplished (needs worktree path)
-    const semanticSummary = extractSemanticSummary(worktreePath, sessionId);
+    // Ask Claude to summarize what it accomplished.
+    // If --worktree auto-removed (no code changes), fall back to project path.
+    const summaryPath = existsSync(worktreePath) ? worktreePath : (projectPath || process.cwd());
+    const semanticSummary = extractSemanticSummary(summaryPath, sessionId);
+    const visualArtifact = extractVisualArtifact(summaryPath, sessionId);
 
     // Clean up worktree BEFORE merge — gh pr merge --delete-branch fails if
     // the local branch is still referenced by a worktree. The branch itself
@@ -1706,6 +1767,22 @@ async function handleTaskCompletion(displayNumber, exitCode) {
       }, info.taskId);
     }
 
+    // Append visual artifact as a separate timeline event (non-blocking)
+    if (visualArtifact) {
+      log(`Task #${displayNumber}: Sending visual artifact (${visualArtifact.length} chars)`);
+      await updateTaskStatus(displayNumber, 'session_finished', {
+        event: {
+          type: 'visual_artifact',
+          timestamp: new Date().toISOString(),
+          machineName: machineName || undefined,
+          format: 'mermaid',
+          content: visualArtifact
+        }
+      }, info.taskId).catch(err => {
+        log(`Task #${displayNumber}: Visual artifact upload failed (non-fatal): ${err.message}`);
+      });
+    }
+
     if (NOTIFY_ON_COMPLETE) {
       const prNote = prUrl ? ' PR ready for review.' : '';
       sendMacNotification(
@@ -1725,8 +1802,7 @@ async function handleTaskCompletion(displayNumber, exitCode) {
     // check if a previous PR for this branch was already merged.
     // See: docs/20260211_auto_complete_failure_investigation.md (Fix D)
     if (!prUrl && !merged) {
-      const suffix = getWorktreeSuffix();
-      const branch = `push-${displayNumber}-${suffix}`;
+      const branch = getBranchName(displayNumber);
       try {
         const prCheck = execFileSync('gh', [
           'pr', 'list', '--head', branch, '--state', 'merged',
@@ -1794,8 +1870,10 @@ async function handleTaskCompletion(displayNumber, exitCode) {
       log(`Task #${displayNumber} stderr: ${stderr.slice(0, 500)}`);
     }
 
-    // Ask Claude to explain what went wrong (needs worktree path)
-    const failureSummary = extractSemanticSummary(worktreePath, sessionId);
+    // Ask Claude to explain what went wrong.
+    // If --worktree auto-removed, fall back to project path.
+    const failSummaryPath = existsSync(worktreePath) ? worktreePath : (projectPath || process.cwd());
+    const failureSummary = extractSemanticSummary(failSummaryPath, sessionId);
 
     // Clean up worktree after summary extraction
     cleanupWorktree(displayNumber, projectPath);

package/lib/discovery.js

@@ -0,0 +1,334 @@
+/**
+ * Project Discovery Engine for Push CLI.
+ *
+ * Scans the user's home folder for projects used with Claude Code, Codex,
+ * and OpenClaw. Returns deduplicated list of (gitRemote, agentType) pairs.
+ *
+ * Discovery sources:
+ * - Claude Code: ~/.claude/projects/ (sessions-index.json or path decode)
+ * - Codex: ~/.codex/sessions/ (JSONL first-line cwd extraction)
+ * - OpenClaw: ~/.openclaw/agents/main/sessions/ (JSONL first-line cwd)
+ */
+
+import { readdirSync, readFileSync, existsSync, statSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { getGitRemoteForPath, normalizeGitRemote } from './utils/git.js';
+
+/**
+ * @typedef {Object} DiscoveredProject
+ * @property {string} projectPath - Absolute path to the project directory
+ * @property {string} gitRemote - Normalized git remote URL
+ * @property {string} agentType - 'claude-code' | 'openai-codex' | 'openclaw'
+ * @property {string} source - Human-readable description of discovery source
+ * @property {string|null} projectContext - First 50 lines of CLAUDE.md or README.md (for keyword generation)
+ */
+
+// ============================================================================
+// CLAUDE CODE DISCOVERY
+// ============================================================================
+
+/**
+ * Discover projects from Claude Code's ~/.claude/projects/ directory.
+ *
+ * Strategy:
+ * 1. List all dirs, skip worktree dirs (contain '--claude-worktrees')
+ * 2. For dirs WITH sessions-index.json: extract unique projectPaths
+ * 3. For dirs WITHOUT: decode path naively (replace - with /)
+ * 4. Verify each path exists and has a git remote
+ *
+ * @returns {DiscoveredProject[]}
+ */
+export function discoverClaudeCodeProjects() {
+  const projectsDir = join(homedir(), '.claude', 'projects');
+  if (!existsSync(projectsDir)) return [];
+
+  const results = [];
+  const seenPaths = new Set();
+
+  let dirs;
+  try {
+    dirs = readdirSync(projectsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+  } catch {
+    return [];
+  }
+
+  for (const dirName of dirs) {
+    // Skip worktree dirs
+    if (dirName.includes('--claude-worktrees')) continue;
+
+    const dirPath = join(projectsDir, dirName);
+
+    // Try sessions-index.json first (most reliable — contains real projectPath)
+    const indexPath = join(dirPath, 'sessions-index.json');
+    if (existsSync(indexPath)) {
+      try {
+        const data = JSON.parse(readFileSync(indexPath, 'utf8'));
+        if (data.entries && Array.isArray(data.entries)) {
+          for (const entry of data.entries) {
+            if (entry.projectPath && !seenPaths.has(entry.projectPath)) {
+              seenPaths.add(entry.projectPath);
+              addIfValid(results, entry.projectPath, 'claude-code', 'Claude Code session');
+            }
+          }
+        }
+        continue; // sessions-index.json handled this dir
+      } catch {
+        // Fall through to naive decode
+      }
+    }
+
+    // Fallback: naive path decode
+    // -Users-yuxianggu-projects-AppleWhisper → /Users/yuxianggu/projects/AppleWhisper
+    // This is lossy for paths containing hyphens, but we verify existence
+    if (dirName.startsWith('-')) {
+      const decoded = '/' + dirName.slice(1).replace(/-/g, '/');
+      if (!seenPaths.has(decoded) && existsSync(decoded)) {
+        seenPaths.add(decoded);
+        addIfValid(results, decoded, 'claude-code', 'Claude Code project');
+      }
+    }
+  }
+
+  return results;
+}
+
+// ============================================================================
+// CODEX DISCOVERY
+// ============================================================================
+
+/**
+ * Discover projects from Codex's ~/.codex/sessions/ directory.
+ *
+ * Strategy:
+ * 1. Recursively find *.jsonl files under ~/.codex/sessions/
+ * 2. Read first line, parse JSON, extract payload.cwd
+ * 3. Verify each path exists and has a git remote
+ *
+ * @returns {DiscoveredProject[]}
+ */
+export function discoverCodexProjects() {
+  const sessionsDir = join(homedir(), '.codex', 'sessions');
+  if (!existsSync(sessionsDir)) return [];
+
+  const results = [];
+  const seenPaths = new Set();
+
+  const jsonlFiles = findJsonlFiles(sessionsDir);
+
+  for (const filePath of jsonlFiles) {
+    const cwd = extractCwdFromJsonl(filePath, 'codex');
+    if (cwd && !seenPaths.has(cwd)) {
+      seenPaths.add(cwd);
+      addIfValid(results, cwd, 'openai-codex', 'Codex session');
+    }
+  }
+
+  return results;
+}
+
+// ============================================================================
+// OPENCLAW DISCOVERY
+// ============================================================================
+
+/**
+ * Discover projects from OpenClaw's session files.
+ *
+ * Strategy:
+ * 1. Read *.jsonl files from ~/.openclaw/agents/main/sessions/
+ * 2. Extract cwd from first line
+ * 3. Skip generic workspace (~/.openclaw/workspace) — not a real project
+ * 4. Verify each path exists and has a git remote
+ *
+ * @returns {DiscoveredProject[]}
+ */
+export function discoverOpenClawProjects() {
+  const sessionsDir = join(homedir(), '.openclaw', 'agents', 'main', 'sessions');
+  if (!existsSync(sessionsDir)) return [];
+
+  const results = [];
+  const seenPaths = new Set();
+  const workspacePath = join(homedir(), '.openclaw', 'workspace');
+
+  let files;
+  try {
+    files = readdirSync(sessionsDir).filter(f => f.endsWith('.jsonl') && !f.includes('.deleted.'));
+  } catch {
+    return [];
+  }
+
+  for (const fileName of files) {
+    const filePath = join(sessionsDir, fileName);
+    const cwd = extractCwdFromJsonl(filePath, 'openclaw');
+    if (cwd && cwd !== workspacePath && !seenPaths.has(cwd)) {
+      seenPaths.add(cwd);
+      addIfValid(results, cwd, 'openclaw', 'OpenClaw session');
+    }
+  }
+
+  return results;
+}
+
+// ============================================================================
+// UNIFIED DISCOVERY
+// ============================================================================
+
+/**
+ * Discover all projects from all supported agents.
+ *
+ * Runs each agent's scanner and deduplicates results by (gitRemote, agentType).
+ *
+ * @returns {{ projects: DiscoveredProject[], counts: { claudeCode: number, codex: number, openclaw: number } }}
+ */
+export function discoverAllProjects() {
+  const claudeCode = discoverClaudeCodeProjects();
+  const codex = discoverCodexProjects();
+  const openclaw = discoverOpenClawProjects();
+
+  const all = [...claudeCode, ...codex, ...openclaw];
+  const deduplicated = deduplicateProjects(all);
+
+  return {
+    projects: deduplicated,
+    counts: {
+      claudeCode: claudeCode.length,
+      codex: codex.length,
+      openclaw: openclaw.length,
+    }
+  };
+}
+
+/**
+ * Deduplicate discovered projects by (gitRemote, agentType) pair.
+ *
+ * @param {DiscoveredProject[]} projects
+ * @returns {DiscoveredProject[]}
+ */
+export function deduplicateProjects(projects) {
+  const seen = new Map();
+
+  for (const project of projects) {
+    const key = `${project.gitRemote}::${project.agentType}`;
+    if (!seen.has(key)) {
+      seen.set(key, project);
+    }
+  }
+
+  return Array.from(seen.values());
+}
+
+// ============================================================================
+// HELPERS
+// ============================================================================
+
+/**
+ * Check if a path is a valid project with a git remote, and add to results if so.
+ *
+ * @param {DiscoveredProject[]} results - Array to push to
+ * @param {string} projectPath - Absolute path to check
+ * @param {string} agentType - Agent type identifier
+ * @param {string} source - Human-readable source description
+ */
+function addIfValid(results, projectPath, agentType, source) {
+  if (!existsSync(projectPath)) return;
+
+  // Check it's a directory
+  try {
+    if (!statSync(projectPath).isDirectory()) return;
+  } catch {
+    return;
+  }
+
+  const gitRemote = getGitRemoteForPath(projectPath);
+  if (!gitRemote) return;
+
+  const projectContext = readProjectContext(projectPath);
+  results.push({ projectPath, gitRemote, agentType, source, projectContext });
+}
+
+/**
+ * Read project context for keyword generation.
+ *
+ * Tries CLAUDE.md first (richer, written for AI), then README.md.
+ * Returns first 50 lines or null if neither exists.
+ *
+ * @param {string} projectPath - Absolute path to the project
+ * @returns {string|null} First 50 lines of project documentation
+ */
+function readProjectContext(projectPath) {
+  for (const filename of ['CLAUDE.md', 'README.md']) {
+    const filePath = join(projectPath, filename);
+    if (!existsSync(filePath)) continue;
+
+    try {
+      const content = readFileSync(filePath, 'utf8');
+      const lines = content.split('\n').slice(0, 50);
+      const text = lines.join('\n').trim();
+      if (text.length > 0) return text;
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+/**
+ * Extract cwd from the first line of a JSONL session file.
+ *
+ * Handles two formats:
+ * - Codex: {"type":"session_meta","payload":{"cwd":"/path",...}}
+ * - OpenClaw: {"type":"session","cwd":"/path",...}
+ *
+ * @param {string} filePath - Absolute path to the JSONL file
+ * @param {'codex'|'openclaw'} format - Which format to expect
+ * @returns {string|null} The cwd value or null
+ */
+function extractCwdFromJsonl(filePath, format) {
+  try {
+    const content = readFileSync(filePath, 'utf8');
+    const firstLine = content.split('\n')[0];
+    if (!firstLine) return null;
+
+    const data = JSON.parse(firstLine);
+
+    if (format === 'codex') {
+      return data?.payload?.cwd || null;
+    }
+    // openclaw
+    return data?.cwd || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Recursively find all .jsonl files in a directory.
+ *
+ * @param {string} dir - Directory to search
+ * @param {number} maxDepth - Maximum recursion depth
+ * @returns {string[]}
+ */
+function findJsonlFiles(dir, maxDepth = 5) {
+  if (maxDepth <= 0) return [];
+
+  const results = [];
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      results.push(...findJsonlFiles(fullPath, maxDepth - 1));
+    } else if (entry.name.endsWith('.jsonl') && !entry.name.includes('.deleted.')) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}

package/lib/utils/git.js

@@ -4,7 +4,7 @@
  * Provides helpers for git operations like getting remote URLs.
  */
 
-import { execSync } from 'child_process';
+import { execSync, execFileSync } from 'child_process';
 
 /**
  * Get the normalized git remote URL for the current directory.
@@ -148,6 +148,31 @@ export function hasUncommittedChanges() {
   }
 }
 
+/**
+ * Get the normalized git remote URL for a specific directory path.
+ *
+ * Uses execFileSync (no shell) for safe execution with untrusted paths.
+ *
+ * @param {string} projectPath - Absolute path to the project directory
+ * @returns {string|null} Normalized git remote or null if not a git repo / no remote
+ */
+export function getGitRemoteForPath(projectPath) {
+  try {
+    const result = execFileSync('git', ['-C', projectPath, 'remote', 'get-url', 'origin'], {
+      encoding: 'utf8',
+      timeout: 5000,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+
+    const url = result.trim();
+    if (!url) return null;
+
+    return normalizeGitRemote(url);
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Normalize a git remote URL to a consistent format.
  *

package/lib/utils/spinner.js

@@ -0,0 +1,73 @@
+/**
+ * Simple ANSI spinner for Push CLI.
+ *
+ * Braille-frame spinner that overwrites a single terminal line.
+ * Uses the same ANSI patterns as watch.js (no external dependencies).
+ */
+
+import { codes } from './colors.js';
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const INTERVAL_MS = 80;
+
+/**
+ * Create a spinner that updates in-place on a single line.
+ *
+ * @returns {{ start(text: string): void, update(text: string): void, succeed(text: string): void, fail(text: string): void, stop(): void }}
+ */
+export function createSpinner() {
+  let frameIndex = 0;
+  let intervalId = null;
+  let currentText = '';
+
+  function render() {
+    const frame = `${codes.cyan}${FRAMES[frameIndex]}${codes.reset}`;
+    process.stdout.write(`\r${codes.clearLine}  ${frame} ${currentText}`);
+    frameIndex = (frameIndex + 1) % FRAMES.length;
+  }
+
+  return {
+    start(text) {
+      currentText = text;
+      frameIndex = 0;
+      render();
+      intervalId = setInterval(render, INTERVAL_MS);
+    },
+
+    update(text) {
+      currentText = text;
+    },
+
+    succeed(text) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}  ${codes.green}✓${codes.reset} ${text}\n`);
+    },
+
+    fail(text) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}  ${codes.red}✗${codes.reset} ${text}\n`);
+    },
+
+    info(text) {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}  ${codes.dim}○${codes.reset} ${text}\n`);
+    },
+
+    stop() {
+      if (intervalId) {
+        clearInterval(intervalId);
+        intervalId = null;
+      }
+      process.stdout.write(`\r${codes.clearLine}`);
+    }
+  };
+}

package/package.json

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