@masslessai/push-todo 3.8.3 → 3.10.0

package/lib/api.js

@@ -52,6 +52,9 @@ export async function fetchTasks(gitRemote, options = {}) {
   if (gitRemote) {
     params.set('git_remote', gitRemote);
   }
+  if (options.actionType) {
+    params.set('action_type', options.actionType);
+  }
   if (options.backlogOnly) {
     params.set('later_only', 'true');
   }

package/lib/cli.js

@@ -93,6 +93,14 @@ ${bold('CONNECT OPTIONS:')}
   --store-e2ee-key <key>           Import E2EE encryption key
   --description <text>             Project description (with connect)
 
+${bold('CONFIRM (for daemon skills):')}
+  push-todo confirm --type "social_post" --title "Post tweet" --content "..."
+  --type <type>                    Confirmation category (social_post, email, etc.)
+  --title <text>                   Short description of the action
+  --content <text>                 Content to be confirmed
+  --metadata <json>                Optional JSON metadata for rich rendering
+  --task <number>                  Display number (auto-detected in daemon)
+
 ${bold('SETTINGS:')}
   push-todo setting                Show all settings
   push-todo setting auto-commit    Toggle auto-commit
@@ -135,7 +143,13 @@ const options = {
   'validate-key': { type: 'boolean' },
   'validate-project': { type: 'boolean' },
   'store-e2ee-key': { type: 'string' },
-  'description': { type: 'string' }
+  'description': { type: 'string' },
+  // Confirm command options
+  'type': { type: 'string' },
+  'title': { type: 'string' },
+  'content': { type: 'string' },
+  'metadata': { type: 'string' },
+  'task': { type: 'string' },
 };
 
 /**
@@ -465,6 +479,12 @@ export async function run(argv) {
   // Get the command (first positional)
   const command = positionals[0];
 
+  // Confirm command - request user confirmation for irreversible actions
+  if (command === 'confirm') {
+    const { requestConfirmation } = await import('./confirm.js');
+    return requestConfirmation(values, positionals);
+  }
+
   // Connect command
   if (command === 'connect') {
     return runConnect(values);

package/lib/confirm.js

@@ -0,0 +1,226 @@
+/**
+ * Remote confirmation command for Push CLI.
+ *
+ * Requests user confirmation before irreversible external actions.
+ * Claude calls `push-todo confirm --type X --title Y --content Z`
+ * which blocks until the user approves or rejects from the iOS app.
+ *
+ * See: docs/20260212_remote_confirmation_protocol_architecture.md
+ */
+
+import { getApiKey } from './config.js';
+import { getMachineName } from './machine-id.js';
+import { bold, red, cyan, dim, green, yellow } from './utils/colors.js';
+
+const API_BASE = 'https://jxuzqcbqhiaxmfitzxlo.supabase.co/functions/v1';
+
+const POLL_INTERVAL_MS = 3000;
+
+/**
+ * Make an authenticated API request to the Push backend.
+ */
+async function apiRequest(endpoint, options = {}) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error('No API key configured. Run "push-todo connect" first.');
+  }
+
+  const url = `${API_BASE}/${endpoint}`;
+  return fetch(url, {
+    ...options,
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      ...options.headers,
+    },
+  });
+}
+
+/**
+ * Request confirmation and poll until user responds.
+ *
+ * @param {Object} values - Parsed CLI values
+ * @param {string[]} positionals - Positional arguments
+ */
+export async function requestConfirmation(values, positionals) {
+  const type = values.type;
+  const title = values.title;
+  const content = values.content;
+  const metadataStr = values.metadata;
+  const taskArg = values.task;
+
+  // Validate required fields
+  if (!type || !title || !content) {
+    console.error(red('Error: --type, --title, and --content are required.'));
+    console.error('');
+    console.error('Usage:');
+    console.error('  push-todo confirm --type "social_post" --title "Reply to @user" --content "Your reply text..."');
+    console.error('');
+    console.error('Options:');
+    console.error('  --type      Confirmation category (social_post, email, publish, etc.)');
+    console.error('  --title     Short description of the action');
+    console.error('  --content   The actual content to be confirmed');
+    console.error('  --metadata  Optional JSON metadata for rich rendering');
+    console.error('  --task      Display number (auto-detected from PUSH_DISPLAY_NUMBER)');
+    process.exit(1);
+  }
+
+  // Resolve display number: explicit --task > PUSH_DISPLAY_NUMBER env
+  let displayNumber = taskArg ? parseInt(taskArg, 10) : null;
+  let todoId = null;
+
+  if (!displayNumber) {
+    const envDisplayNumber = process.env.PUSH_DISPLAY_NUMBER;
+    if (envDisplayNumber) {
+      displayNumber = parseInt(envDisplayNumber, 10);
+    }
+  }
+
+  if (!displayNumber) {
+    todoId = process.env.PUSH_TASK_ID || null;
+  }
+
+  if (!displayNumber && !todoId) {
+    console.error(red('Error: Cannot determine task. Use --task <number> or set PUSH_DISPLAY_NUMBER env.'));
+    process.exit(1);
+  }
+
+  // Parse metadata if provided
+  let metadata = null;
+  if (metadataStr) {
+    try {
+      metadata = JSON.parse(metadataStr);
+    } catch {
+      console.error(red('Error: --metadata must be valid JSON.'));
+      process.exit(1);
+    }
+  }
+
+  const machineName = getMachineName() || null;
+
+  // Build request payload
+  const payload = {
+    type,
+    title,
+    body: content,
+  };
+  if (displayNumber) payload.displayNumber = displayNumber;
+  if (todoId) payload.todoId = todoId;
+  if (metadata) payload.metadata = metadata;
+  if (machineName) payload.machineName = machineName;
+
+  // Send confirmation request
+  console.error(`[push-confirm] Requesting confirmation for task #${displayNumber || '?'}...`);
+  console.error(`[push-confirm] Type: ${type}`);
+  console.error(`[push-confirm] Title: ${title}`);
+  console.error(`[push-confirm] Content: ${content.slice(0, 100)}${content.length > 100 ? '...' : ''}`);
+
+  let confirmationId;
+  try {
+    const response = await apiRequest('request-confirmation', {
+      method: 'POST',
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      console.error(red(`[push-confirm] Failed to request confirmation: ${text}`));
+      // Output JSON for Claude to parse
+      console.log(JSON.stringify({ approved: false, error: `Request failed: ${text}` }));
+      process.exit(1);
+    }
+
+    const data = await response.json();
+    confirmationId = data.confirmationId;
+    console.error(`[push-confirm] Confirmation ID: ${confirmationId}`);
+    console.error(`[push-confirm] Waiting for user response on iPhone...`);
+  } catch (err) {
+    console.error(red(`[push-confirm] Error: ${err.message}`));
+    console.log(JSON.stringify({ approved: false, error: err.message }));
+    process.exit(1);
+  }
+
+  // Poll for response
+  const taskFilter = displayNumber
+    ? `display_number=${displayNumber}`
+    : `todo_id=${todoId}`;
+
+  while (true) {
+    try {
+      const response = await apiRequest(`synced-todos?${taskFilter}`);
+
+      if (!response.ok) {
+        console.error(dim(`[push-confirm] Poll error (${response.status}), retrying...`));
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+
+      const data = await response.json();
+      const todos = data.todos || [];
+
+      if (todos.length === 0) {
+        console.error(dim(`[push-confirm] Task not found, retrying...`));
+        await sleep(POLL_INTERVAL_MS);
+        continue;
+      }
+
+      const todo = todos[0];
+
+      // Check if confirmation was responded to
+      if (todo.executionStatus !== 'awaiting_confirmation') {
+        // Confirmation was responded to — check events for the result
+        const approved = wasApproved(todo, confirmationId);
+
+        if (approved) {
+          console.error(green(`[push-confirm] Approved by user.`));
+          console.log(JSON.stringify({ approved: true, message: 'Confirmed by user' }));
+          process.exit(0);
+        } else {
+          console.error(yellow(`[push-confirm] Rejected by user.`));
+          console.log(JSON.stringify({ approved: false, message: 'Rejected by user' }));
+          process.exit(1);
+        }
+      }
+
+      // Still waiting
+      await sleep(POLL_INTERVAL_MS);
+    } catch (err) {
+      console.error(dim(`[push-confirm] Poll error: ${err.message}, retrying...`));
+      await sleep(POLL_INTERVAL_MS);
+    }
+  }
+}
+
+/**
+ * Check execution events to determine if confirmation was approved.
+ */
+function wasApproved(todo, confirmationId) {
+  try {
+    const events = todo.executionEventsJson
+      ? (typeof todo.executionEventsJson === 'string'
+        ? JSON.parse(todo.executionEventsJson)
+        : todo.executionEventsJson)
+      : [];
+
+    // Find the most recent confirmation response event
+    for (let i = events.length - 1; i >= 0; i--) {
+      const event = events[i];
+      if (event.type === 'confirmation_approved') {
+        return true;
+      }
+      if (event.type === 'confirmation_rejected') {
+        return false;
+      }
+    }
+  } catch {
+    // Parse error — fall through
+  }
+
+  // If no event found but status changed from awaiting_confirmation,
+  // check if pendingConfirmation was cleared (approved is more likely)
+  return !todo.pendingConfirmation;
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/lib/connect.js

@@ -12,7 +12,7 @@
  * Ported from: plugins/push-todo/scripts/connect.py (1866 lines)
  */
 
-import { execSync, spawnSync, spawn } from 'child_process';
+import { execSync, execFileSync, spawnSync, spawn } from 'child_process';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, chmodSync, statSync } from 'fs';
 import { setTimeout as sleep } from 'timers/promises';
 import { homedir } from 'os';
@@ -937,6 +937,8 @@ async function registerProjectWithBackend(apiKey, clientType = 'claude-code', ke
   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 || ''
@@ -946,17 +948,119 @@ async function registerProjectWithBackend(apiKey, clientType = 'claude-code', ke
   return { status: 'error', message: 'Unknown error' };
 }
 
+// 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 = {
+  'claude-code': 'claude-code',
+  'openai-codex': 'openai-codex',
+  'openclaw': 'clawdbot',
+  'clawdbot': 'clawdbot',
+};
+
+// ============================================================================
+// AGENT CALLER DETECTION
+// ============================================================================
+// See: /docs/20260212_agent_caller_identity_detection_investigation_and_implementation_plan.md
+
+// Known agent process names -> client_type mapping
+const PROCESS_NAME_TO_CLIENT = {
+  'claude': 'claude-code',
+  'openclaw': 'openclaw',
+  'openclaw-tui': 'openclaw',
+  'codex': 'openai-codex',
+};
+
+/**
+ * Walk up the process tree and collect ancestor process names.
+ * Uses execFileSync (no shell) for safety. Works on macOS and Linux.
+ */
+function getAncestorProcessNames(maxDepth = 8) {
+  const names = [];
+  let pid = process.ppid;
+
+  for (let i = 0; i < maxDepth && pid > 1; i++) {
+    try {
+      const info = execFileSync('ps', ['-o', 'ppid=,comm=', '-p', String(pid)], {
+        encoding: 'utf8',
+        timeout: 1000,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      }).trim();
+
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+
+      const comm = match[2].trim();
+      const name = comm.split('/').pop();
+      names.push(name);
+      pid = parseInt(match[1]);
+    } catch {
+      break;
+    }
+  }
+
+  return names;
+}
+
+/**
+ * Detect which AI agent is calling us.
+ *
+ * Detection layers (in order of reliability):
+ * 1. Explicit --client flag (manual override, always wins)
+ * 2. Environment variables (agent explicitly identifies itself)
+ * 3. Process tree inspection (universal, no agent cooperation needed)
+ * 4. Default to 'claude-code' (backward compatibility)
+ *
+ * @param {string|undefined} explicitClient - Value from --client flag
+ * @returns {{ clientType: string, method: string }}
+ */
+function detectCallerAgent(explicitClient) {
+  // Layer 1: Explicit --client flag always wins
+  if (explicitClient) {
+    return { clientType: explicitClient, method: 'flag' };
+  }
+
+  // Layer 2: Known environment variables
+  if (process.env.CLAUDECODE === '1') {
+    return { clientType: 'claude-code', method: 'env' };
+  }
+
+  // Layer 3: Process tree inspection
+  try {
+    const ancestors = getAncestorProcessNames();
+    for (const name of ancestors) {
+      if (PROCESS_NAME_TO_CLIENT[name]) {
+        return { clientType: PROCESS_NAME_TO_CLIENT[name], method: 'process-tree' };
+      }
+      for (const [processName, clientType] of Object.entries(PROCESS_NAME_TO_CLIENT)) {
+        if (name.startsWith(processName)) {
+          return { clientType, method: 'process-tree' };
+        }
+      }
+    }
+  } catch {
+    // Process tree inspection failed — continue to default
+  }
+
+  // Layer 4: Default (backward compatibility)
+  return { clientType: 'claude-code', method: 'default' };
+}
+
 /**
  * Register project in local registry for daemon routing.
+ *
+ * @param {string} gitRemoteRaw - Raw git remote URL
+ * @param {string} localPath - Absolute local path
+ * @param {Object} [actionMeta] - Action metadata from register-project response
+ * @returns {boolean}
  */
-function registerProjectLocally(gitRemoteRaw, localPath) {
+function registerProjectLocally(gitRemoteRaw, localPath, actionMeta = {}) {
   if (!gitRemoteRaw) return false;
 
   const gitRemote = normalizeGitRemote(gitRemoteRaw);
   if (!gitRemote) return false;
 
   const registry = getRegistry();
-  return registry.register(gitRemote, localPath);
+  return registry.register(gitRemote, localPath, actionMeta);
 }
 
 /**
@@ -1037,8 +1141,9 @@ export async function runConnect(options = {}) {
   // Self-healing: ensure daemon is running
   ensureDaemonRunning();
 
-  // Auto-detect client type from installation method
-  let clientType = options.client || 'claude-code';
+  // Auto-detect calling agent (Claude Code, OpenClaw, Codex, etc.)
+  const detection = detectCallerAgent(options.client);
+  let clientType = detection.clientType;
   const clientName = CLIENT_NAMES[clientType] || 'Claude Code';
 
   // Handle --check-version (JSON output)
@@ -1096,6 +1201,9 @@ export async function runConnect(options = {}) {
   console.log('');
   console.log(`  Push Voice Tasks Connect`);
   console.log('  ' + '='.repeat(40));
+  if (detection.method !== 'default') {
+    console.log(`  Agent: ${clientName} (detected via ${detection.method})`);
+  }
   console.log('');
 
   // Step 1: Check for updates
@@ -1128,7 +1236,12 @@ export async function runConnect(options = {}) {
       // Register in local project registry for global daemon routing
       const gitRemoteRaw = getGitRemote();
       const localPath = process.cwd();
-      const isNewLocal = registerProjectLocally(gitRemoteRaw, localPath);
+      const actionType = result.action_type || CLIENT_TO_ACTION_TYPE[clientType] || clientType;
+      const isNewLocal = registerProjectLocally(gitRemoteRaw, localPath, {
+        actionType,
+        actionId: result.action_id,
+        actionName: result.action_name,
+      });
 
       console.log('');
       console.log('  ' + '='.repeat(40));
@@ -1204,7 +1317,11 @@ export async function runConnect(options = {}) {
   // Register in local project registry for global daemon routing
   const gitRemoteRaw = getGitRemote();
   const localPath = process.cwd();
-  const isNewLocal = registerProjectLocally(gitRemoteRaw, localPath);
+  const actionType = CLIENT_TO_ACTION_TYPE[clientType] || clientType;
+  const isNewLocal = registerProjectLocally(gitRemoteRaw, localPath, {
+    actionType,
+    actionName: authResult.action_name,
+  });
 
   // Show success
   console.log('');

package/lib/daemon.js

@@ -372,13 +372,19 @@ async function fetchQueuedTasks() {
     const projects = getListedProjects();
     const gitRemotes = Object.keys(projects);
 
+    // Get projects with action type for structured heartbeat (multi-agent support)
+    const projectsWithType = getListedProjectsWithActionType();
+
     // Add machine registry headers for daemon status tracking
     // See: /docs/20260204_daemon_heartbeat_status_indicator_implementation_plan.md (machine_registry table)
     const heartbeatHeaders = {};
     if (machineId && gitRemotes.length > 0) {
       heartbeatHeaders['X-Machine-Id'] = machineId;
       heartbeatHeaders['X-Machine-Name'] = machineName || 'Unknown Mac';
-      heartbeatHeaders['X-Git-Remotes'] = gitRemotes.join(',');
+      // Structured format: "remote::type,remote::type" (backward compat: old parsers split on , and ignore ::)
+      heartbeatHeaders['X-Git-Remotes'] = projectsWithType
+        .map(p => `${p.gitRemote}::${p.actionType}`)
+        .join(',');
       heartbeatHeaders['X-Daemon-Version'] = getVersion();
       heartbeatHeaders['X-Capabilities'] = JSON.stringify(getCapabilities());
     }
@@ -503,19 +509,38 @@ async function claimTask(displayNumber) {
 
 // ==================== Project Registry ====================
 
-function getProjectPath(gitRemote) {
+function getProjectPath(gitRemote, actionType) {
   if (!existsSync(REGISTRY_FILE)) {
     return null;
   }
 
   try {
     const data = JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
-    return data.projects?.[gitRemote]?.localPath || data.projects?.[gitRemote]?.local_path || null;
+    const projects = data.projects || {};
+
+    // Try exact composite key first (V2 format)
+    if (actionType) {
+      const key = `${gitRemote}::${actionType}`;
+      if (projects[key]) {
+        return projects[key].localPath || projects[key].local_path || null;
+      }
+    }
+
+    // Fall back to scanning for matching gitRemote (V2 or V1 format)
+    for (const [key, info] of Object.entries(projects)) {
+      if ((info.gitRemote || key) === gitRemote) {
+        return info.localPath || info.local_path || null;
+      }
+    }
+    return null;
   } catch {
     return null;
   }
 }
 
+/**
+ * List all registered projects (backward-compatible: gitRemote -> localPath).
+ */
 function getListedProjects() {
   if (!existsSync(REGISTRY_FILE)) {
     return {};
@@ -524,8 +549,11 @@ function getListedProjects() {
   try {
     const data = JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
     const result = {};
-    for (const [remote, info] of Object.entries(data.projects || {})) {
-      result[remote] = info.localPath || info.local_path;
+    for (const [key, info] of Object.entries(data.projects || {})) {
+      const remote = info.gitRemote || key;
+      if (!(remote in result)) {
+        result[remote] = info.localPath || info.local_path;
+      }
     }
     return result;
   } catch {
@@ -533,6 +561,30 @@ function getListedProjects() {
   }
 }
 
+/**
+ * List all registered projects with action type info.
+ * Returns array of {gitRemote, actionType} for structured heartbeat.
+ */
+function getListedProjectsWithActionType() {
+  if (!existsSync(REGISTRY_FILE)) {
+    return [];
+  }
+
+  try {
+    const data = JSON.parse(readFileSync(REGISTRY_FILE, 'utf8'));
+    const result = [];
+    for (const [key, info] of Object.entries(data.projects || {})) {
+      result.push({
+        gitRemote: info.gitRemote || key,
+        actionType: info.actionType || 'claude-code',
+      });
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+
 // ==================== Git Worktree Management ====================
 
 function getWorktreeSuffix() {
@@ -1100,6 +1152,10 @@ function monitorTaskStdout(displayNumber, proc) {
 }
 
 function checkTaskIdle(displayNumber) {
+  // Skip idle check for tasks awaiting user confirmation
+  const info = taskDetails.get(displayNumber) || {};
+  if (info.phase === 'awaiting_confirmation') return false;
+
   const lastOutput = taskLastOutput.get(displayNumber);
   if (!lastOutput) return false;
 
@@ -1200,6 +1256,7 @@ async function executeTask(task) {
 
   const displayNumber = task.displayNumber || task.display_number;
   const gitRemote = task.gitRemote || task.git_remote;
+  const taskActionType = task.actionType || task.action_type || null;
   const summary = task.summary || 'No summary';
   const content = task.normalizedContent || task.normalized_content ||
     task.content || task.summary || 'Work on this task';
@@ -1219,10 +1276,10 @@ async function executeTask(task) {
     return null;
   }
 
-  // Get project path
+  // Get project path (use action_type for multi-agent routing)
   let projectPath = null;
   if (gitRemote) {
-    projectPath = getProjectPath(gitRemote);
+    projectPath = getProjectPath(gitRemote, taskActionType);
     if (!projectPath) {
       log(`Task #${displayNumber}: Project not registered: ${gitRemote}`);
       log("Run '/push-todo connect' in the project directory to register");
@@ -1340,6 +1397,14 @@ IMPORTANT:
           if (buffer.length > 20) buffer.shift();
           taskStdoutBuffer.set(displayNumber, buffer);
 
+          // Detect confirmation waiting (exempt from timeouts)
+          if (line.includes('[push-confirm] Waiting for')) {
+            updateTaskDetail(displayNumber, {
+              phase: 'awaiting_confirmation',
+              detail: 'Waiting for user confirmation on iPhone'
+            });
+          }
+
           const stuckReason = checkStuckPatterns(displayNumber, line);
           if (stuckReason) {
             log(`Task #${displayNumber} may be stuck: ${stuckReason}`);
@@ -1622,6 +1687,13 @@ async function checkTimeouts() {
   const timedOut = [];
 
   for (const [displayNumber, taskInfo] of runningTasks) {
+    const info = taskDetails.get(displayNumber) || {};
+
+    // Skip timeout checks for tasks awaiting user confirmation on iPhone
+    if (info.phase === 'awaiting_confirmation') {
+      continue;
+    }
+
     const elapsed = now - taskInfo.startTime;
 
     if (elapsed > TASK_TIMEOUT_MS) {

package/lib/project-registry.js

@@ -12,7 +12,7 @@ import { homedir } from 'os';
 import { join } from 'path';
 
 const REGISTRY_FILE = join(homedir(), '.config', 'push', 'projects.json');
-const REGISTRY_VERSION = 1;
+const REGISTRY_VERSION = 2;
 
 /**
  * Project Registry class.
@@ -62,36 +62,91 @@ class ProjectRegistry {
   }
 
   _migrate(data) {
-    // Future: handle migrations as needed
+    const oldVersion = data.version || 0;
+
+    // V1 → V2: Add actionType to project keys
+    // V1 keys: "github.com/user/repo" → V2 keys: "github.com/user/repo::claude-code"
+    // All V1 projects were Claude Code (the only agent type that existed)
+    if (oldVersion < 2 && data.projects) {
+      const newProjects = {};
+      for (const [key, info] of Object.entries(data.projects)) {
+        // Skip if already in V2 format (contains ::)
+        if (key.includes('::')) {
+          newProjects[key] = { ...info, gitRemote: info.gitRemote || key.split('::')[0] };
+          continue;
+        }
+        const v2Key = `${key}::claude-code`;
+        newProjects[v2Key] = {
+          ...info,
+          gitRemote: key,
+          actionType: 'claude-code',
+          actionId: null,
+          actionName: null,
+        };
+      }
+      data.projects = newProjects;
+
+      // Migrate defaultProject key too
+      if (data.defaultProject && !data.defaultProject.includes('::')) {
+        data.defaultProject = `${data.defaultProject}::claude-code`;
+      }
+    }
+
     data.version = REGISTRY_VERSION;
+    // Persist the migrated data immediately
+    writeFileSync(REGISTRY_FILE, JSON.stringify(data, null, 2));
     return data;
   }
 
+  /**
+   * Build the composite key for a project entry.
+   * Format: "gitRemote::actionType" (e.g., "github.com/user/repo::claude-code")
+   *
+   * @param {string} gitRemote - Normalized git remote
+   * @param {string} actionType - Action type (e.g., "claude-code", "clawdbot")
+   * @returns {string}
+   */
+  _makeKey(gitRemote, actionType) {
+    return `${gitRemote}::${actionType || 'claude-code'}`;
+  }
+
   /**
    * Register a project.
    *
    * @param {string} gitRemote - Normalized git remote (e.g., "github.com/user/repo")
    * @param {string} localPath - Absolute local path
+   * @param {Object} [actionMeta] - Action metadata from register-project response
+   * @param {string} [actionMeta.actionType] - Action type (e.g., "claude-code", "clawdbot")
+   * @param {string} [actionMeta.actionId] - Action UUID
+   * @param {string} [actionMeta.actionName] - Action display name
    * @returns {boolean} True if newly registered, false if updated existing
    */
-  register(gitRemote, localPath) {
-    const isNew = !(gitRemote in this._data.projects);
+  register(gitRemote, localPath, actionMeta = {}) {
+    const actionType = actionMeta.actionType || 'claude-code';
+    const key = this._makeKey(gitRemote, actionType);
+    const isNew = !(key in this._data.projects);
     const now = new Date().toISOString();
 
     if (isNew) {
-      this._data.projects[gitRemote] = {
+      this._data.projects[key] = {
+        gitRemote,
         localPath,
+        actionType,
+        actionId: actionMeta.actionId || null,
+        actionName: actionMeta.actionName || null,
         registeredAt: now,
         lastUsed: now
       };
     } else {
-      this._data.projects[gitRemote].localPath = localPath;
-      this._data.projects[gitRemote].lastUsed = now;
+      this._data.projects[key].localPath = localPath;
+      this._data.projects[key].lastUsed = now;
+      if (actionMeta.actionId) this._data.projects[key].actionId = actionMeta.actionId;
+      if (actionMeta.actionName) this._data.projects[key].actionName = actionMeta.actionName;
     }
 
     // Set as default if first project
     if (this._data.defaultProject === null) {
-      this._data.defaultProject = gitRemote;
+      this._data.defaultProject = key;
     }
 
     this._save();
@@ -99,16 +154,20 @@ class ProjectRegistry {
   }
 
   /**
-   * Get local path for a git remote.
+   * Get local path for a git remote (and optional action type).
    * Updates lastUsed timestamp.
    *
+   * Supports both:
+   * - getPath("github.com/user/repo", "claude-code") → exact match
+   * - getPath("github.com/user/repo") → first match for that repo (backward compat)
+   *
    * @param {string} gitRemote - Normalized git remote
+   * @param {string} [actionType] - Optional action type for exact match
    * @returns {string|null} Local path or null if not registered
    */
-  getPath(gitRemote) {
-    const project = this._data.projects[gitRemote];
+  getPath(gitRemote, actionType) {
+    const project = this._findProject(gitRemote, actionType);
     if (project) {
-      // Update last_used
       project.lastUsed = new Date().toISOString();
       this._save();
       return project.localPath;
@@ -121,55 +180,126 @@ class ProjectRegistry {
    * Useful for status checks and listing operations.
    *
    * @param {string} gitRemote - Normalized git remote
+   * @param {string} [actionType] - Optional action type
    * @returns {string|null} Local path or null if not registered
    */
-  getPathWithoutUpdate(gitRemote) {
-    const project = this._data.projects[gitRemote];
+  getPathWithoutUpdate(gitRemote, actionType) {
+    const project = this._findProject(gitRemote, actionType);
     return project ? project.localPath : null;
   }
 
   /**
-   * List all registered projects.
+   * Find a project entry by gitRemote and optional actionType.
+   * If actionType provided, tries exact composite key first.
+   * Falls back to scanning all entries for matching gitRemote.
+   *
+   * @param {string} gitRemote
+   * @param {string} [actionType]
+   * @returns {Object|null}
+   */
+  _findProject(gitRemote, actionType) {
+    // Try exact composite key first
+    if (actionType) {
+      const key = this._makeKey(gitRemote, actionType);
+      if (key in this._data.projects) {
+        return this._data.projects[key];
+      }
+    }
+
+    // Fall back to scanning for matching gitRemote (backward compat + no actionType case)
+    for (const [key, info] of Object.entries(this._data.projects)) {
+      // V2 format: check the stored gitRemote field
+      if (info.gitRemote === gitRemote) {
+        return info;
+      }
+      // V1 format fallback: key IS the gitRemote (pre-migration)
+      if (key === gitRemote) {
+        return info;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * List all registered projects (backward-compatible format).
+   * Returns unique gitRemote -> localPath mapping (first entry per remote wins).
    *
    * @returns {Object} Dict of gitRemote -> localPath
    */
   listProjects() {
     const result = {};
-    for (const [remote, info] of Object.entries(this._data.projects)) {
-      result[remote] = info.localPath;
+    for (const [_key, info] of Object.entries(this._data.projects)) {
+      const remote = info.gitRemote || _key;
+      // First entry per gitRemote wins (backward compat)
+      if (!(remote in result)) {
+        result[remote] = info.localPath;
+      }
     }
     return result;
   }
 
   /**
    * List all registered projects with full metadata.
+   * V2 format: includes actionType, actionId, gitRemote per entry.
    *
-   * @returns {Object} Dict of gitRemote -> {localPath, registeredAt, lastUsed}
+   * @returns {Object} Dict of compositeKey -> {gitRemote, localPath, actionType, ...}
    */
   listProjectsWithMetadata() {
     return { ...this._data.projects };
   }
 
+  /**
+   * List all registered projects with action type info.
+   * Returns array of {gitRemote, localPath, actionType} for daemon routing.
+   *
+   * @returns {Array<{gitRemote: string, localPath: string, actionType: string}>}
+   */
+  listProjectsWithActionType() {
+    const result = [];
+    for (const [_key, info] of Object.entries(this._data.projects)) {
+      result.push({
+        gitRemote: info.gitRemote || _key,
+        localPath: info.localPath,
+        actionType: info.actionType || 'claude-code',
+      });
+    }
+    return result;
+  }
+
   /**
    * Unregister a project.
+   * Accepts either composite key ("remote::type") or plain gitRemote (removes all entries for that remote).
    *
-   * @param {string} gitRemote - Normalized git remote
+   * @param {string} keyOrRemote - Composite key or plain git remote
    * @returns {boolean} True if was registered, false if not found
    */
-  unregister(gitRemote) {
-    if (gitRemote in this._data.projects) {
-      delete this._data.projects[gitRemote];
+  unregister(keyOrRemote) {
+    let found = false;
 
-      if (this._data.defaultProject === gitRemote) {
-        // Set new default
+    // Try as exact key first
+    if (keyOrRemote in this._data.projects) {
+      delete this._data.projects[keyOrRemote];
+      found = true;
+    } else {
+      // Remove all entries matching this gitRemote
+      for (const [key, info] of Object.entries(this._data.projects)) {
+        if ((info.gitRemote || key) === keyOrRemote) {
+          delete this._data.projects[key];
+          found = true;
+        }
+      }
+    }
+
+    if (found) {
+      // Fix default if needed
+      if (this._data.defaultProject && !(this._data.defaultProject in this._data.projects)) {
         const remaining = Object.keys(this._data.projects);
         this._data.defaultProject = remaining.length > 0 ? remaining[0] : null;
       }
-
       this._save();
-      return true;
     }
-    return false;
+
+    return found;
   }
 
   /**
@@ -183,16 +313,26 @@ class ProjectRegistry {
 
   /**
    * Set a project as the default.
+   * Accepts composite key or plain gitRemote (finds first match).
    *
-   * @param {string} gitRemote
+   * @param {string} keyOrRemote
    * @returns {boolean} True if successful
    */
-  setDefaultProject(gitRemote) {
-    if (gitRemote in this._data.projects) {
-      this._data.defaultProject = gitRemote;
+  setDefaultProject(keyOrRemote) {
+    // Exact key match
+    if (keyOrRemote in this._data.projects) {
+      this._data.defaultProject = keyOrRemote;
       this._save();
       return true;
     }
+    // Find by gitRemote
+    for (const [key, info] of Object.entries(this._data.projects)) {
+      if ((info.gitRemote || key) === keyOrRemote) {
+        this._data.defaultProject = key;
+        this._save();
+        return true;
+      }
+    }
     return false;
   }
 
@@ -207,12 +347,14 @@ class ProjectRegistry {
 
   /**
    * Check if a project is registered.
+   * Checks both composite keys and plain gitRemote.
    *
    * @param {string} gitRemote
+   * @param {string} [actionType] - Optional action type for exact match
    * @returns {boolean}
    */
-  isRegistered(gitRemote) {
-    return gitRemote in this._data.projects;
+  isRegistered(gitRemote, actionType) {
+    return this._findProject(gitRemote, actionType) !== null;
   }
 
   /**
@@ -223,19 +365,22 @@ class ProjectRegistry {
   validatePaths() {
     const invalid = [];
 
-    for (const [gitRemote, info] of Object.entries(this._data.projects)) {
+    for (const [key, info] of Object.entries(this._data.projects)) {
       const path = info.localPath;
+      const gitRemote = info.gitRemote || key;
 
       try {
         const stats = statSync(path);
         if (!stats.isDirectory()) {
           invalid.push({
+            key,
             gitRemote,
             localPath: path,
             reason: 'not_a_directory'
           });
         } else if (!existsSync(join(path, '.git'))) {
           invalid.push({
+            key,
             gitRemote,
             localPath: path,
             reason: 'not_a_git_repo'
@@ -243,6 +388,7 @@ class ProjectRegistry {
         }
       } catch {
         invalid.push({
+          key,
           gitRemote,
           localPath: path,
           reason: 'path_not_found'

package/package.json

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