npm - @masslessai/push-todo - Versions diffs - 4.2.9 → 4.3.0 - Mend

@masslessai/push-todo 4.2.9 → 4.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/SKILL.md CHANGED Viewed

@@ -433,6 +433,11 @@ The `push-todo` CLI supports these commands:
 | `push-todo --status` | Show connection status |
 | `push-todo --mark-completed <uuid>` | Mark task as completed |
 | `push-todo --json` | Output as JSON |
+| `push-todo schedule add` | Create a remote schedule (Supabase-backed) |
+| `push-todo schedule list` | List all remote schedules |
+| `push-todo schedule remove <id>` | Remove a schedule |
+| `push-todo schedule enable <id>` | Enable a schedule |
+| `push-todo schedule disable <id>` | Disable a schedule |
 ## What is Push?

package/lib/api.js CHANGED Viewed

@@ -521,4 +521,4 @@ export async function requestInput(todoId, question, timeoutMs = 300000) {
   return null; // Timeout
 }
-export { API_BASE };
+export { API_BASE, apiRequest };

package/lib/cli.js CHANGED Viewed

@@ -49,6 +49,7 @@ ${bold('USAGE:')}
   push-todo search <query>         Search tasks
   push-todo review                 Review completed tasks
   push-todo update                 Update CLI, check agents, refresh projects
+  push-todo schedule               Manage remote schedules (add/list/remove)
 ${bold('OPTIONS:')}
   --all-projects, -a               List tasks from all projects
@@ -116,17 +117,20 @@ ${bold('CONFIRM (for daemon skills):')}
   --metadata <json>                Optional JSON metadata for rich rendering
   --task <number>                  Display number (auto-detected in daemon)
-${bold('CRON (scheduled jobs):')}
-  push-todo cron add               Add a cron job
-    --name <name>                  Job name (required)
-    --every <interval>             Repeat interval: 30m, 1h, 24h, 7d
-    --at <iso-date>                One-shot at specific time
-    --cron <expression>            5-field cron expression
-    --notify <message>             Send Mac notification
-    --create-todo <content>        Create todo reminder
-    --health-check <path>          Run codebase health check (scope: general|tests|deps)
-  push-todo cron list              List all cron jobs
-  push-todo cron remove <id>       Remove a cron job by ID
+${bold('SCHEDULE (remote scheduled jobs):')}
+  push-todo schedule add             Create a schedule
+    --name <name>                    Schedule name (required)
+    --every <interval>               Repeat interval: 30m, 1h, 24h, 7d
+    --at <iso-date>                  One-shot at specific time
+    --cron <expression>              5-field cron expression
+    --create-todo <title>            Create a new todo each fire
+    --queue-todo <todoId>            Re-queue an existing todo each fire
+    --git-remote <remote>            Route created todos to a project
+    --content <body>                 Expanded content for created todos
+  push-todo schedule list            List all schedules
+  push-todo schedule remove <id>     Remove a schedule
+  push-todo schedule enable <id>     Enable a schedule
+  push-todo schedule disable <id>    Disable a schedule
 ${bold('SETTINGS:')}
   push-todo setting                Show all settings
@@ -180,16 +184,14 @@ const options = {
   'content': { type: 'string' },
   'metadata': { type: 'string' },
   'task': { type: 'string' },
-  // Cron command options
+  // Schedule command options
   'name': { type: 'string' },
   'every': { type: 'string' },
   'at': { type: 'string' },
   'cron': { type: 'string' },
   'create-todo': { type: 'string' },
-  'notify': { type: 'string' },
-  'queue-execution': { type: 'string' },
-  'health-check': { type: 'string' },
-  'scope': { type: 'string' },
+  'git-remote': { type: 'string' },
+  'queue-todo': { type: 'string' },
   // Skill CLI options (Phase 3)
   'report-progress': { type: 'string' },
   'phase': { type: 'string' },
@@ -706,99 +708,194 @@ export async function run(argv) {
     return;
   }
-  // Cron command - scheduled jobs
-  if (command === 'cron') {
-    const { addJob, removeJob, listJobs } = await import('./cron.js');
+  // Schedule command - Supabase-backed unified scheduling
+  if (command === 'schedule') {
+    const { computeNextRun } = await import('./cron.js');
     const subCommand = positionals[1];
     if (subCommand === 'add') {
       if (!values.name) {
-        console.error(red('--name is required for cron add'));
+        console.error(red('--name is required for schedule add'));
         process.exit(1);
       }
-      // Determine schedule
-      let schedule;
+      // Determine schedule timing
+      let scheduleType, scheduleValue;
       if (values.every) {
-        schedule = { type: 'every', value: values.every };
+        scheduleType = 'every';
+        scheduleValue = values.every;
       } else if (values.at) {
-        schedule = { type: 'at', value: values.at };
+        scheduleType = 'at';
+        scheduleValue = values.at;
       } else if (values.cron) {
-        schedule = { type: 'cron', value: values.cron };
+        scheduleType = 'cron';
+        scheduleValue = values.cron;
       } else {
         console.error(red('Schedule required: --every, --at, or --cron'));
         process.exit(1);
       }
+      // Validate schedule and compute next run
+      let nextRunAt;
+      try {
+        nextRunAt = computeNextRun({ type: scheduleType, value: scheduleValue });
+        if (!nextRunAt) {
+          console.error(red('Schedule has no future run time'));
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error(red(`Invalid schedule: ${error.message}`));
+        process.exit(1);
+      }
       // Determine action
-      let action;
+      let actionType, actionTitle, actionContent, gitRemote, todoId;
       if (values['create-todo']) {
-        action = { type: 'create-todo', content: values['create-todo'] };
-      } else if (values.notify) {
-        action = { type: 'notify', content: values.notify };
-      } else if (values['queue-execution']) {
-        action = { type: 'queue-execution', todoId: values['queue-execution'] };
-      } else if (values['health-check']) {
-        action = {
-          type: 'health-check',
-          projectPath: values['health-check'],
-          scope: values.scope || 'general',
-        };
+        actionType = 'create-todo';
+        actionTitle = values['create-todo'];
+        actionContent = values.content || null;
+        gitRemote = values['git-remote'] || null;
+      } else if (values['queue-todo']) {
+        actionType = 'queue-todo';
+        todoId = values['queue-todo'];
       } else {
-        console.error(red('Action required: --create-todo, --notify, --queue-execution, or --health-check'));
+        console.error(red('Action required: --create-todo <title> or --queue-todo <todoId>'));
         process.exit(1);
       }
       try {
-        const job = addJob({ name: values.name, schedule, action });
-        console.log(green(`Created cron job: ${job.name} (ID: ${job.id.slice(0, 8)})`));
-        console.log(dim(`Next run: ${job.nextRunAt}`));
+        const response = await api.apiRequest('manage-schedules', {
+          method: 'POST',
+          body: JSON.stringify({
+            name: values.name,
+            scheduleType,
+            scheduleValue,
+            actionType,
+            actionTitle,
+            actionContent,
+            gitRemote,
+            todoId,
+            nextRunAt,
+          }),
+        });
+        if (!response.ok) {
+          const data = await response.json();
+          console.error(red(`Failed to create schedule: ${data.error || response.status}`));
+          process.exit(1);
+        }
+        const data = await response.json();
+        const s = data.schedule;
+        console.log(green(`Created schedule: ${s.name} (ID: ${s.id.slice(0, 8)})`));
+        console.log(dim(`Next run: ${s.next_run_at}`));
       } catch (error) {
-        console.error(red(`Failed to create cron job: ${error.message}`));
+        console.error(red(`Failed to create schedule: ${error.message}`));
         process.exit(1);
       }
       return;
     }
     if (subCommand === 'list') {
-      const jobs = listJobs();
-      if (jobs.length === 0) {
-        console.log('No cron jobs configured.');
-        console.log(dim('Add one with: push-todo cron add --name "..." --every "24h" --notify "..."'));
-        return;
-      }
-      console.log(bold('Cron Jobs:'));
-      for (const job of jobs) {
-        const status = job.enabled ? green('ON') : dim('OFF');
-        const schedStr = job.schedule.type === 'every' ? `every ${job.schedule.value}` :
-                         job.schedule.type === 'at' ? `at ${job.schedule.value}` :
-                         `cron: ${job.schedule.value}`;
-        console.log(`  ${status} ${job.name} [${schedStr}] → ${job.action.type}: ${job.action.content || job.action.todoId || ''}`);
-        console.log(dim(`     ID: ${job.id.slice(0, 8)} | Next: ${job.nextRunAt || 'N/A'} | Last: ${job.lastRunAt || 'never'}`));
+      try {
+        const response = await api.apiRequest('manage-schedules', { method: 'GET' });
+        if (!response.ok) {
+          console.error(red(`Failed to list schedules: HTTP ${response.status}`));
+          process.exit(1);
+        }
+        const data = await response.json();
+        const schedules = data.schedules || [];
+        if (schedules.length === 0) {
+          console.log('No schedules configured.');
+          console.log(dim('Add one with: push-todo schedule add --name "..." --every "4h" --create-todo "..."'));
+          return;
+        }
+        console.log(bold('Schedules:'));
+        for (const s of schedules) {
+          const status = s.enabled ? green('ON') : dim('OFF');
+          const schedStr = s.schedule_type === 'every' ? `every ${s.schedule_value}` :
+                           s.schedule_type === 'at' ? `at ${s.schedule_value}` :
+                           `cron: ${s.schedule_value}`;
+          const actionStr = s.action_type === 'create-todo'
+            ? `create-todo: ${s.action_title || ''}`
+            : `queue-todo: ${s.todo_id || '?'}`;
+          console.log(`  ${status} ${s.name} [${schedStr}] → ${actionStr}`);
+          console.log(dim(`     ID: ${s.id.slice(0, 8)} | Next: ${s.next_run_at || 'N/A'} | Last: ${s.last_run_at || 'never'}`));
+        }
+      } catch (error) {
+        console.error(red(`Failed to list schedules: ${error.message}`));
+        process.exit(1);
       }
       return;
     }
     if (subCommand === 'remove') {
-      const jobId = positionals[2];
-      if (!jobId) {
-        console.error(red('Usage: push-todo cron remove <id>'));
+      const scheduleId = positionals[2];
+      if (!scheduleId) {
+        console.error(red('Usage: push-todo schedule remove <id>'));
         process.exit(1);
       }
-      if (removeJob(jobId)) {
-        console.log(green(`Removed cron job ${jobId}`));
-      } else {
-        console.error(red(`Cron job not found: ${jobId}`));
+      try {
+        const response = await api.apiRequest(`manage-schedules?id=${scheduleId}`, {
+          method: 'DELETE',
+        });
+        if (response.ok) {
+          console.log(green(`Removed schedule ${scheduleId}`));
+        } else {
+          const data = await response.json();
+          console.error(red(`Failed to remove schedule: ${data.error || response.status}`));
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error(red(`Failed to remove schedule: ${error.message}`));
+        process.exit(1);
+      }
+      return;
+    }
+    if (subCommand === 'enable' || subCommand === 'disable') {
+      const scheduleId = positionals[2];
+      if (!scheduleId) {
+        console.error(red(`Usage: push-todo schedule ${subCommand} <id>`));
+        process.exit(1);
+      }
+      const enabled = subCommand === 'enable';
+      try {
+        const response = await api.apiRequest('manage-schedules', {
+          method: 'PATCH',
+          body: JSON.stringify({ id: scheduleId, enabled }),
+        });
+        if (response.ok) {
+          console.log(green(`Schedule ${scheduleId} ${enabled ? 'enabled' : 'disabled'}`));
+        } else {
+          const data = await response.json();
+          console.error(red(`Failed to ${subCommand} schedule: ${data.error || response.status}`));
+          process.exit(1);
+        }
+      } catch (error) {
+        console.error(red(`Failed to ${subCommand} schedule: ${error.message}`));
         process.exit(1);
       }
       return;
     }
-    // Default: show help for cron
-    console.log(`${bold('Cron Commands:')}
-  push-todo cron add     Add a new scheduled job
-  push-todo cron list    List all jobs
-  push-todo cron remove  Remove a job by ID
+    // Default: show help for schedule
+    console.log(`${bold('Schedule Commands:')}
+  push-todo schedule add      Create a new remote schedule
+  push-todo schedule list     List all schedules
+  push-todo schedule remove   Remove a schedule by ID
+  push-todo schedule enable   Enable a schedule
+  push-todo schedule disable  Disable a schedule
+${bold('Examples:')}
+  push-todo schedule add --name "Daily standup" --every 24h --create-todo "Write standup update"
+  push-todo schedule add --name "Weekly review" --cron "0 9 * * 1" --create-todo "Weekly code review" --git-remote github.com/user/repo
+  push-todo schedule add --name "Re-run task" --every 4h --queue-todo <todoId>
     `);
     return;
   }

package/lib/context-engine.js CHANGED Viewed

@@ -110,10 +110,16 @@ export function scanProjectSkills(projectPath) {
         const content = readFileSync(skillFile, 'utf8');
         const { frontmatter, body } = parseFrontmatter(content);
+        // Parse tools field: comma-separated list of tool names/patterns
+        const tools = frontmatter.tools
+          ? frontmatter.tools.split(',').map(t => t.trim()).filter(Boolean)
+          : [];
         skills.push({
           name: frontmatter.name || entry,
           description: frontmatter.description || '',
           requiresConfirmation: body.includes('push-todo confirm'),
+          tools,
         });
       } catch {
         // Skip unreadable skill files

package/lib/cron.js CHANGED Viewed

@@ -1,51 +1,13 @@
 /**
- * Cron job scheduler for Push daemon.
+ * Schedule engine for Push daemon.
  *
- * Stores recurring/one-shot jobs in ~/.push/cron/jobs.json.
- * Called from daemon main loop on each poll cycle.
+ * Pure scheduling logic (interval parsing, cron expressions, next-run computation)
+ * plus the remote schedule checker that polls Supabase.
  *
  * No npm dependencies — includes minimal cron expression parser.
- * Architecture: docs/20260214_push_daemon_evolution_complete_architecture.md §23
- * Pattern: Follow self-update.js — pure functions, called from daemon.js.
+ * Architecture: docs/20260301_system_architecture_complete_reference.md
  */
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-import { randomUUID } from 'crypto';
-import { sendMacNotification } from './utils/notify.js';
-const CRON_DIR = join(homedir(), '.push', 'cron');
-const JOBS_FILE = join(CRON_DIR, 'jobs.json');
-// ==================== Storage ====================
-function ensureCronDir() {
-  mkdirSync(CRON_DIR, { recursive: true });
-}
-/**
- * Load all cron jobs from disk.
- * @returns {Array} Job objects
- */
-export function loadJobs() {
-  if (!existsSync(JOBS_FILE)) return [];
-  try {
-    return JSON.parse(readFileSync(JOBS_FILE, 'utf8'));
-  } catch {
-    return [];
-  }
-}
-/**
- * Save all cron jobs to disk.
- * @param {Array} jobs
- */
-export function saveJobs(jobs) {
-  ensureCronDir();
-  writeFileSync(JOBS_FILE, JSON.stringify(jobs, null, 2) + '\n');
-}
 // ==================== Interval Parsing ====================
 /**
@@ -225,214 +187,135 @@ export function computeNextRun(schedule, fromDate = new Date()) {
   }
 }
-// ==================== Job Management ====================
+// ==================== Remote Schedules (Supabase) ====================
 /**
- * Add a new cron job.
+ * Check for and run any due remote schedules from Supabase.
+ * Called from daemon poll loop on every cycle.
  *
- * @param {Object} config
- * @param {string} config.name - Job name
- * @param {{ type: string, value: string }} config.schedule - Schedule definition
- * @param {{ type: string, content: string }} config.action - Action to perform
- * @returns {Object} Created job
+ * @param {Function} [logFn] - Optional log function
+ * @param {Object} [context] - Injected dependencies from daemon
+ * @param {Function} [context.apiRequest] - API request function
  */
-export function addJob(config) {
-  const { name, schedule, action } = config;
+export async function checkAndRunRemoteSchedules(logFn, context = {}) {
+  const log = logFn || (() => {});
-  if (!name) throw new Error('Job name is required');
-  if (!schedule || !schedule.type || !schedule.value) throw new Error('Schedule is required');
-  if (!action || !action.type) throw new Error('Action is required');
+  if (!context.apiRequest) return;
-  // Validate schedule by computing next run
-  const nextRunAt = computeNextRun(schedule);
-  if (!nextRunAt) {
-    throw new Error(`Schedule "${schedule.type}: ${schedule.value}" has no future run time`);
+  // 1. Fetch due schedules
+  let schedules;
+  try {
+    const response = await context.apiRequest('manage-schedules?due=true', {
+      method: 'GET',
+    });
+    if (!response.ok) {
+      log(`Remote schedules: fetch failed (HTTP ${response.status})`);
+      return;
+    }
+    const data = await response.json();
+    schedules = data.schedules || [];
+  } catch (error) {
+    log(`Remote schedules: fetch error: ${error.message}`);
+    return;
   }
-  const job = {
-    id: randomUUID(),
-    name,
-    schedule,
-    action,
-    enabled: true,
-    createdAt: new Date().toISOString(),
-    lastRunAt: null,
-    nextRunAt,
-  };
-  const jobs = loadJobs();
-  jobs.push(job);
-  saveJobs(jobs);
-  return job;
-}
+  if (schedules.length === 0) return;
-/**
- * Remove a cron job by ID or ID prefix.
- *
- * @param {string} idOrPrefix - Full UUID or prefix (min 4 chars)
- * @returns {boolean} True if found and removed
- */
-export function removeJob(idOrPrefix) {
-  const jobs = loadJobs();
-  const idx = jobs.findIndex(j =>
-    j.id === idOrPrefix || j.id.startsWith(idOrPrefix)
-  );
+  log(`Remote schedules: ${schedules.length} due`);
-  if (idx === -1) return false;
+  // 2. Fire each due schedule
+  for (const schedule of schedules) {
+    const expectedNextRunAt = schedule.next_run_at;
-  jobs.splice(idx, 1);
-  saveJobs(jobs);
-  return true;
-}
-/**
- * List all cron jobs.
- * @returns {Array} Job objects
- */
-export function listJobs() {
-  return loadJobs();
-}
-// ==================== Execution ====================
-/**
- * Execute a cron job action.
- *
- * @param {Object} job - Job object
- * @param {Function} [logFn] - Optional log function
- * @param {Object} [context] - Injected dependencies from daemon
- * @param {Function} [context.apiRequest] - API request function
- * @param {Function} [context.spawnHealthCheck] - Spawn a health check Claude session
- */
-async function executeAction(job, logFn, context = {}) {
-  const log = logFn || (() => {});
+    try {
+      if (schedule.action_type === 'create-todo') {
+        // Create a new todo
+        const payload = {
+          title: schedule.action_title || schedule.name,
+          normalizedContent: schedule.action_content || null,
+          isBacklog: false,
+          createdByClient: 'daemon-schedule',
+        };
+        if (schedule.git_remote) {
+          payload.gitRemote = schedule.git_remote;
+          payload.actionType = 'claude-code';
+        }
-  switch (job.action.type) {
-    case 'notify':
-      sendMacNotification('Push Cron', job.action.content || job.name);
-      log(`Cron "${job.name}": notification sent`);
-      break;
-    case 'create-todo':
-      if (context.apiRequest) {
-        try {
-          const response = await context.apiRequest('create-todo', {
-            method: 'POST',
-            body: JSON.stringify({
-              title: job.action.content || job.name,
-              normalizedContent: job.action.detail || null,
-              isBacklog: job.action.backlog || false,
-              createdByClient: 'daemon-cron',
-            }),
-          });
-          if (response.ok) {
-            const data = await response.json();
-            log(`Cron "${job.name}": created todo #${data.todo?.displayNumber || '?'}`);
-          } else {
-            log(`Cron "${job.name}": create-todo failed (HTTP ${response.status})`);
-            // Fall back to notification
-            sendMacNotification('Push: Scheduled Todo', job.action.content || job.name);
-          }
-        } catch (error) {
-          log(`Cron "${job.name}": create-todo error: ${error.message}`);
-          sendMacNotification('Push: Scheduled Todo', job.action.content || job.name);
+        const todoResponse = await context.apiRequest('create-todo', {
+          method: 'POST',
+          body: JSON.stringify(payload),
+        });
+        if (todoResponse.ok) {
+          const todoData = await todoResponse.json();
+          log(`Schedule "${schedule.name}": created todo #${todoData.todo?.displayNumber || '?'}`);
+        } else {
+          log(`Schedule "${schedule.name}": create-todo failed (HTTP ${todoResponse.status})`);
         }
-      } else {
-        sendMacNotification('Push: Scheduled Todo', job.action.content || job.name);
-        log(`Cron "${job.name}": todo reminder sent (notification, no API context)`);
-      }
-      break;
-    case 'queue-execution':
-      if (!job.action.todoId) {
-        log(`Cron "${job.name}": queue-execution requires todoId, skipping`);
-      } else if (context.apiRequest) {
-        try {
-          const response = await context.apiRequest('update-task-execution', {
+      } else if (schedule.action_type === 'queue-todo') {
+        // Re-queue an existing todo
+        if (!schedule.todo_id) {
+          log(`Schedule "${schedule.name}": queue-todo has no todo_id, disabling`);
+          await context.apiRequest('manage-schedules', {
             method: 'PATCH',
             body: JSON.stringify({
-              todoId: job.action.todoId,
-              status: 'queued',
+              id: schedule.id,
+              enabled: false,
+              lastRunAt: new Date().toISOString(),
+              nextRunAt: null,
             }),
           });
-          if (response.ok) {
-            log(`Cron "${job.name}": queued todo ${job.action.todoId} for execution`);
-          } else {
-            log(`Cron "${job.name}": queue-execution failed (HTTP ${response.status})`);
-          }
-        } catch (error) {
-          log(`Cron "${job.name}": queue-execution error: ${error.message}`);
+          continue;
         }
-      } else {
-        log(`Cron "${job.name}": queue-execution not available (no API context)`);
-      }
-      break;
-    case 'health-check':
-      if (context.spawnHealthCheck) {
-        try {
-          await context.spawnHealthCheck(job, log);
-        } catch (error) {
-          log(`Cron "${job.name}": health-check error: ${error.message}`);
+        const queueResponse = await context.apiRequest('update-task-execution', {
+          method: 'PATCH',
+          body: JSON.stringify({
+            todoId: schedule.todo_id,
+            status: 'queued',
+          }),
+        });
+        if (queueResponse.ok) {
+          log(`Schedule "${schedule.name}": queued todo ${schedule.todo_id}`);
+        } else {
+          log(`Schedule "${schedule.name}": queue-todo failed (HTTP ${queueResponse.status})`);
         }
-      } else {
-        log(`Cron "${job.name}": health-check not available (no daemon context)`);
       }
-      break;
-    default:
-      log(`Cron "${job.name}": unknown action type "${job.action.type}"`);
-  }
-}
-/**
- * Check for and run any due cron jobs.
- * Called from daemon poll loop on every cycle.
- *
- * @param {Function} [logFn] - Optional log function
- * @param {Object} [context] - Injected dependencies (apiRequest, spawnHealthCheck)
- */
-export async function checkAndRunDueJobs(logFn, context = {}) {
-  const jobs = loadJobs();
-  if (jobs.length === 0) return;
-  const now = new Date();
-  let modified = false;
-  for (const job of jobs) {
-    if (!job.enabled) continue;
-    if (!job.nextRunAt) continue;
-    const nextRun = new Date(job.nextRunAt);
-    if (nextRun > now) continue;
-    // Job is due — execute
-    try {
-      await executeAction(job, logFn, context);
     } catch (error) {
-      if (logFn) logFn(`Cron "${job.name}" execution failed: ${error.message}`);
+      log(`Schedule "${schedule.name}": execution error: ${error.message}`);
     }
-    // Update timing
-    job.lastRunAt = now.toISOString();
+    // 3. Advance next_run_at (with optimistic lock)
+    const now = new Date();
+    const scheduleConfig = { type: schedule.schedule_type, value: schedule.schedule_value };
-    if (job.schedule.type === 'at') {
+    let nextRunAt = null;
+    let enabled = true;
+    if (schedule.schedule_type === 'at') {
       // One-shot: disable after run
-      job.enabled = false;
-      job.nextRunAt = null;
+      enabled = false;
     } else {
       // Recurring: compute next run
-      job.nextRunAt = computeNextRun(job.schedule, now);
-      if (!job.nextRunAt) {
-        job.enabled = false; // No more future runs
+      nextRunAt = computeNextRun(scheduleConfig, now);
+      if (!nextRunAt) {
+        enabled = false;
       }
     }
-    modified = true;
-  }
-  if (modified) {
-    saveJobs(jobs);
+    try {
+      await context.apiRequest('manage-schedules', {
+        method: 'PATCH',
+        body: JSON.stringify({
+          id: schedule.id,
+          enabled,
+          lastRunAt: now.toISOString(),
+          nextRunAt,
+          expectedNextRunAt,
+        }),
+      });
+    } catch (error) {
+      log(`Schedule "${schedule.name}": failed to advance next_run_at: ${error.message}`);
+    }
   }
 }

package/lib/daemon.js CHANGED Viewed

@@ -23,7 +23,7 @@ import { fileURLToPath } from 'url';
 import { checkForUpdate, performUpdate } from './self-update.js';
 import { getProjectContext, buildSmartPrompt, invalidateCache } from './context-engine.js';
 import { sendMacNotification } from './utils/notify.js';
-import { checkAndRunDueJobs } from './cron.js';
+import { checkAndRunRemoteSchedules } from './cron.js';
 import { runHeartbeatChecks } from './heartbeat.js';
 import { getAgentVersions, formatAgentVersionSummary, checkAllAgentUpdates, performAgentUpdate, checkVersionParity, ensureAgentReady } from './agent-versions.js';
 import { checkAllProjectsFreshness } from './project-freshness.js';
@@ -1693,14 +1693,22 @@ function respawnWithInjectedMessage(displayNumber) {
   const injectionPrompt = `IMPORTANT: The human sent you an urgent message while you were working:\n\n---\n${message}\n---\n\nPlease address this message and then continue with your task.`;
-  const allowedTools = [
+  // Reuse the same expanded tool list as executeTask
+  const baseTools = [
     'Read', 'Edit', 'Write', 'Glob', 'Grep',
     'Bash(git *)',
     'Bash(npm *)', 'Bash(npx *)', 'Bash(yarn *)',
     'Bash(python *)', 'Bash(python3 *)', 'Bash(pip *)', 'Bash(pip3 *)',
     'Bash(push-todo *)',
-    'Task'
-  ].join(',');
+    'Task',
+    'WebSearch', 'WebFetch',
+    'ToolSearch',
+  ];
+  const projectContext = projectPath ? getProjectContext(projectPath) : { skills: [], state: {} };
+  const skillTools = (projectContext.skills || [])
+    .flatMap(s => s.tools || [])
+    .filter(t => !baseTools.includes(t));
+  const allowedTools = [...baseTools, ...skillTools].join(',');
   // Generate new session ID for the respawned session
   const newSessionId = randomUUID();
@@ -2371,14 +2379,22 @@ async function executeTask(task) {
   // No duplicate status update needed here (was causing race conditions)
   // Build Claude command
-  const allowedTools = [
+  const baseTools = [
     'Read', 'Edit', 'Write', 'Glob', 'Grep',
     'Bash(git *)',
     'Bash(npm *)', 'Bash(npx *)', 'Bash(yarn *)',
     'Bash(python *)', 'Bash(python3 *)', 'Bash(pip *)', 'Bash(pip3 *)',
     'Bash(push-todo *)',
-    'Task'
-  ].join(',');
+    'Task',
+    'WebSearch', 'WebFetch',
+    'ToolSearch',
+  ];
+  // Merge tools declared by project skills (via `tools` frontmatter in SKILL.md)
+  const skillTools = (projectContext.skills || [])
+    .flatMap(s => s.tools || [])
+    .filter(t => !baseTools.includes(t));
+  const allowedTools = [...baseTools, ...skillTools].join(',');
   // For follow-ups: try --continue with previous session for full context.
   // Falls back to new session with prompt context if session is stale/unavailable.
@@ -3062,126 +3078,6 @@ function logVersionParityWarnings() {
 // ==================== Health Check (Phase 5) ====================
-/**
- * Spawn a health check Claude session for a project.
- * Called by the cron module when a health-check job fires.
- *
- * The session runs in the project directory with a special prompt that asks
- * Claude to review the codebase and suggest tasks. Results are created as
- * draft todos via the create-todo API.
- *
- * @param {Object} job - Cron job object
- * @param {Function} logFn - Log function
- */
-async function spawnHealthCheck(job, logFn) {
-  const projectPath = job.action.projectPath;
-  if (!projectPath || !existsSync(projectPath)) {
-    logFn(`Health check: project path not found: ${projectPath}`);
-    return;
-  }
-  // Don't run if task slots are full
-  if (runningTasks.size >= MAX_CONCURRENT_TASKS) {
-    logFn(`Health check: all ${MAX_CONCURRENT_TASKS} slots in use, deferring`);
-    return;
-  }
-  const scope = job.action.scope || 'general';
-  const customPrompt = job.action.prompt || '';
-  const healthPrompts = {
-    general: `Review this codebase briefly. Check for:
-1. Failing tests (run the test suite if one exists)
-2. Obvious bugs or issues in recently modified files (last 7 days)
-3. Outdated dependencies worth updating
-For each issue found, create a todo using: push-todo create "<clear description of the issue>"
-Only create todos for real, actionable issues — not style preferences or minor improvements.
-If everything looks good, just say "No issues found" and don't create any todos.`,
-    tests: `Run the test suite for this project. If any tests fail, create a todo for each failure:
-push-todo create "Fix failing test: <test name> - <brief reason>"
-If all tests pass, say "All tests pass" and don't create any todos.`,
-    dependencies: `Check for outdated dependencies in this project. Only flag dependencies with:
-- Known security vulnerabilities
-- Major version bumps (not minor/patch)
-For each, create a todo: push-todo create "Update <dep> from <old> to <new> (<reason>)"
-If dependencies are current, say "All dependencies up to date."`,
-  };
-  const prompt = customPrompt || healthPrompts[scope] || healthPrompts.general;
-  const allowedTools = [
-    'Read', 'Glob', 'Grep',
-    'Bash(git *)',
-    'Bash(npm *)', 'Bash(npx *)',
-    'Bash(python *)', 'Bash(python3 *)',
-    'Bash(push-todo create *)',
-  ].join(',');
-  const claudeArgs = [
-    '-p', prompt,
-    '--verbose',
-    '--allowedTools', allowedTools,
-    '--output-format', 'stream-json',
-    '--permission-mode', 'bypassPermissions',
-  ];
-  logFn(`Health check "${job.name}": spawning Claude in ${projectPath} (scope: ${scope})`);
-  try {
-    const child = spawn('claude', claudeArgs, {
-      cwd: projectPath,
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: (() => {
-        const env = { ...process.env };
-        delete env.CLAUDECODE;
-        delete env.CLAUDE_CODE_ENTRYPOINT;
-        return env;
-      })(),
-      timeout: 300000, // 5 min max for health checks
-    });
-    // Simple output tracking — health checks are lightweight, no full task tracking
-    let output = '';
-    child.stdout.on('data', (data) => {
-      output += data.toString();
-    });
-    child.stderr.on('data', (data) => {
-      const errLine = data.toString().trim();
-      if (errLine) logFn(`Health check "${job.name}" stderr: ${errLine}`);
-    });
-    await new Promise((resolve) => {
-      child.on('close', (code) => {
-        if (code === 0) {
-          logFn(`Health check "${job.name}": completed successfully`);
-        } else {
-          logFn(`Health check "${job.name}": exited with code ${code}`);
-        }
-        resolve();
-      });
-      child.on('error', (err) => {
-        logFn(`Health check "${job.name}": spawn error: ${err.message}`);
-        resolve();
-      });
-    });
-    // Extract any text summary from stream-json output
-    const lines = output.split('\n').filter(l => l.trim());
-    for (const line of lines) {
-      try {
-        const event = JSON.parse(line);
-        if (event.type === 'result' && event.result) {
-          logFn(`Health check "${job.name}" result: ${event.result.slice(0, 200)}`);
-        }
-      } catch { /* ignore non-JSON lines */ }
-    }
-  } catch (error) {
-    logFn(`Health check "${job.name}": error: ${error.message}`);
-  }
-}
 // ==================== Main Loop ====================
 async function pollAndExecute() {
@@ -3352,11 +3248,11 @@ async function mainLoop() {
       await pollAndExecute();
-      // Cron jobs (check every poll cycle, execution throttled by nextRunAt)
+      // Remote schedules from Supabase
       try {
-        await checkAndRunDueJobs(log, { apiRequest, spawnHealthCheck });
+        await checkAndRunRemoteSchedules(log, { apiRequest });
       } catch (error) {
-        logError(`Cron check error: ${error.message}`);
+        logError(`Remote schedules error: ${error.message}`);
       }
       // Heartbeat checks (internally throttled: 10min fast, 1hr slow)

package/package.json CHANGED Viewed

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