@masslessai/push-todo 3.8.3 → 3.9.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/connect.js

@@ -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,31 @@ 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',
+};
+
 /**
  * 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);
 }
 
 /**
@@ -1128,7 +1144,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 +1225,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() {
@@ -1200,6 +1252,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 +1272,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");

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.9.0",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {