@masslessai/push-todo 4.1.8 → 4.2.0

package/lib/api.js

@@ -381,4 +381,144 @@ export async function learnVocabulary(todoId, keywords) {
   return response.json();
 }
 
+// ==================== Phase 3: Extended Skill CLI ====================
+
+/**
+ * Report structured progress for a running task.
+ * Called by the agent during execution to push activity updates to Supabase.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {Object} options - Progress details
+ * @param {string} options.phase - Current phase (e.g., "testing", "implementing")
+ * @param {string} [options.detail] - Human-readable detail
+ * @returns {Promise<Object>}
+ */
+export async function reportProgress(todoId, { phase, detail }) {
+  const response = await apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId,
+      event: {
+        type: 'progress',
+        timestamp: new Date().toISOString(),
+        summary: detail ? `${phase}: ${detail}` : phase,
+        phase
+      }
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to report progress: ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Update execution status/phase for a running task.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {string} status - New phase label (e.g., "implementing", "testing", "reviewing")
+ * @returns {Promise<Object>}
+ */
+export async function updateStatus(todoId, status) {
+  const response = await apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId,
+      event: {
+        type: 'progress',
+        timestamp: new Date().toISOString(),
+        summary: `Phase: ${status}`
+      }
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to update status: ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Check for messages from the human for a running task.
+ * Returns pending messages or empty array.
+ *
+ * @param {string} todoId - UUID of the task
+ * @returns {Promise<Object[]>} Array of pending messages
+ */
+export async function checkMessages(todoId) {
+  const params = new URLSearchParams({ todo_id: todoId, direction: 'to_agent' });
+  const response = await apiRequest(`task-messages?${params}`, {
+    method: 'GET'
+  });
+
+  if (!response.ok) {
+    // 404 = no task_messages table/function yet — return empty gracefully
+    if (response.status === 404) return [];
+    const text = await response.text();
+    throw new Error(`Failed to check messages: ${text}`);
+  }
+
+  const result = await response.json();
+  return result.messages || [];
+}
+
+/**
+ * Request input from the human for a running task.
+ * Posts a question and polls until the human responds or timeout.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {string} question - Question to ask the human
+ * @param {number} [timeoutMs=300000] - Timeout in ms (default 5 min)
+ * @returns {Promise<string|null>} Human's response or null if timeout
+ */
+export async function requestInput(todoId, question, timeoutMs = 300000) {
+  // Post the question
+  const postResponse = await apiRequest('task-messages', {
+    method: 'POST',
+    body: JSON.stringify({
+      todo_id: todoId,
+      direction: 'to_human',
+      message: question,
+      type: 'input_request'
+    })
+  });
+
+  if (!postResponse.ok) {
+    // 404 = task-messages endpoint not deployed yet
+    if (postResponse.status === 404) {
+      console.error('Message system not available yet. Use [push-confirm] pattern instead.');
+      return null;
+    }
+    const text = await postResponse.text();
+    throw new Error(`Failed to request input: ${text}`);
+  }
+
+  const { message_id } = await postResponse.json();
+
+  // Poll for response
+  const startTime = Date.now();
+  const pollInterval = 5000; // 5s
+
+  while (Date.now() - startTime < timeoutMs) {
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+
+    const checkResponse = await apiRequest(`task-messages?message_id=${message_id}&direction=to_agent`, {
+      method: 'GET'
+    });
+
+    if (checkResponse.ok) {
+      const result = await checkResponse.json();
+      const reply = (result.messages || []).find(m => m.in_reply_to === message_id);
+      if (reply) return reply.message;
+    }
+  }
+
+  return null; // Timeout
+}
+
 export { API_BASE };

package/lib/cli.js

@@ -68,6 +68,13 @@ ${bold('OPTIONS:')}
   --view-screenshot <idx>          Open screenshot for viewing (index or filename)
   --learn-vocabulary <uuid>        Contribute vocabulary for a task
   --keywords <terms>               Comma-separated vocabulary terms (with --learn-vocabulary)
+  --report-progress <uuid>         Report progress for a running task
+  --phase <name>                   Phase name (with --report-progress)
+  --detail <text>                  Detail text (with --report-progress)
+  --update-status <uuid>           Update execution phase for a running task
+  --check-messages <uuid>          Check for messages from the human
+  --request-input <uuid>           Request input from the human (blocking)
+  --question <text>                Question to ask (with --request-input)
   --set-batch-size <N>             Set max tasks for batch queue (1-20)
   --daemon-status                  Show daemon status
   --daemon-start                   Start daemon manually
@@ -114,6 +121,7 @@ ${bold('CRON (scheduled jobs):')}
     --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
 
@@ -175,6 +183,16 @@ const options = {
   'create-todo': { type: 'string' },
   'notify': { type: 'string' },
   'queue-execution': { type: 'string' },
+  'health-check': { type: 'string' },
+  'scope': { type: 'string' },
+  // Skill CLI options (Phase 3)
+  'report-progress': { type: 'string' },
+  'phase': { type: 'string' },
+  'detail': { type: 'string' },
+  'update-status': { type: 'string' },
+  'check-messages': { type: 'string' },
+  'request-input': { type: 'string' },
+  'question': { type: 'string' },
 };
 
 /**
@@ -512,6 +530,91 @@ export async function run(argv) {
     return;
   }
 
+  // Handle --report-progress (report structured progress for a running task)
+  if (values['report-progress']) {
+    try {
+      const result = await api.reportProgress(values['report-progress'], {
+        phase: values.phase || 'progress',
+        detail: values.detail || undefined,
+      });
+      if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(green('Progress reported.'));
+      }
+    } catch (error) {
+      console.error(red(`Failed to report progress: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --update-status (update execution phase for a running task)
+  if (values['update-status']) {
+    const status = positionals[0] || values.phase;
+    if (!status) {
+      console.error(red('Status required. Usage: --update-status <uuid> <status>'));
+      process.exit(1);
+    }
+    try {
+      const result = await api.updateStatus(values['update-status'], status);
+      if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(green(`Status updated to: ${status}`));
+      }
+    } catch (error) {
+      console.error(red(`Failed to update status: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --check-messages (check for messages from the human)
+  if (values['check-messages']) {
+    try {
+      const messages = await api.checkMessages(values['check-messages']);
+      if (values.json) {
+        console.log(JSON.stringify(messages, null, 2));
+      } else if (messages.length === 0) {
+        console.log(dim('No pending messages.'));
+      } else {
+        for (const msg of messages) {
+          console.log(`[${msg.created_at || 'unknown'}] ${msg.message}`);
+        }
+      }
+    } catch (error) {
+      console.error(red(`Failed to check messages: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --request-input (ask the human a question, poll for response)
+  if (values['request-input']) {
+    const question = values.question || positionals.slice(0).join(' ');
+    if (!question) {
+      console.error(red('--question required with --request-input'));
+      console.error('Usage: --request-input <uuid> --question "What should I do?"');
+      process.exit(1);
+    }
+    try {
+      console.log(dim('Waiting for human response (timeout: 5 min)...'));
+      const reply = await api.requestInput(values['request-input'], question);
+      if (values.json) {
+        console.log(JSON.stringify({ reply }, null, 2));
+      } else if (reply) {
+        console.log(green('Response:'), reply);
+      } else {
+        console.log(dim('No response received (timeout).'));
+      }
+    } catch (error) {
+      console.error(red(`Failed to request input: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
   // Auto-start daemon on every command (self-healing behavior)
   ensureDaemonRunning();
 
@@ -588,8 +691,14 @@ export async function run(argv) {
         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',
+        };
       } else {
-        console.error(red('Action required: --create-todo, --notify, or --queue-execution'));
+        console.error(red('Action required: --create-todo, --notify, --queue-execution, or --health-check'));
         process.exit(1);
       }
 

package/lib/cron.js

@@ -301,8 +301,11 @@ export function listJobs() {
  *
  * @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) {
+async function executeAction(job, logFn, context = {}) {
   const log = logFn || (() => {});
 
   switch (job.action.type) {
@@ -312,17 +315,69 @@ async function executeAction(job, logFn) {
       break;
 
     case 'create-todo':
-      // Phase 2: notification-based (no Supabase edge function yet)
-      sendMacNotification('Push: Scheduled Todo', job.action.content || job.name);
-      log(`Cron "${job.name}": todo reminder sent (notification)`);
+      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);
+        }
+      } 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':
-      // Requires todoId — log warning if missing
       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', {
+            method: 'PATCH',
+            body: JSON.stringify({
+              todoId: job.action.todoId,
+              status: 'queued',
+            }),
+          });
+          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}`);
+        }
+      } 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}`);
+        }
       } else {
-        log(`Cron "${job.name}": queue-execution for todo ${job.action.todoId} (not yet implemented)`);
+        log(`Cron "${job.name}": health-check not available (no daemon context)`);
       }
       break;
 
@@ -336,8 +391,9 @@ async function executeAction(job, logFn) {
  * 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) {
+export async function checkAndRunDueJobs(logFn, context = {}) {
   const jobs = loadJobs();
   if (jobs.length === 0) return;
 
@@ -353,7 +409,7 @@ export async function checkAndRunDueJobs(logFn) {
 
     // Job is due — execute
     try {
-      await executeAction(job, logFn);
+      await executeAction(job, logFn, context);
     } catch (error) {
       if (logFn) logFn(`Cron "${job.name}" execution failed: ${error.message}`);
     }

package/lib/daemon.js

@@ -1514,6 +1514,295 @@ function handleCancellation(displayNumber, source) {
   });
 }
 
+// ==================== Message Injection (Phase 4) ====================
+
+const MESSAGE_POLL_INTERVAL_MS = 30000; // Check for messages every 30s
+let lastMessagePoll = 0;
+
+/**
+ * Poll for urgent messages directed to running tasks.
+ * Called from checkTimeouts() on each poll cycle.
+ *
+ * Normal messages: agent picks up via push-todo --check-messages at natural pauses.
+ * Urgent messages: daemon kills the session and respawns with --continue + injected message.
+ */
+async function checkUrgentMessages() {
+  const now = Date.now();
+  if (now - lastMessagePoll < MESSAGE_POLL_INTERVAL_MS) return;
+  lastMessagePoll = now;
+
+  if (runningTasks.size === 0) return;
+
+  for (const [displayNumber, taskInfo] of runningTasks) {
+    const info = taskDetails.get(displayNumber) || {};
+    const taskId = info.taskId;
+    if (!taskId) continue;
+
+    // Skip tasks already being cancelled or injected
+    if (info.phase === 'cancelled' || info.phase === 'injecting_message') continue;
+
+    try {
+      const params = new URLSearchParams({
+        todo_id: taskId,
+        direction: 'to_agent',
+      });
+
+      const response = await apiRequest(`task-messages?${params}`, {}, false);
+      if (!response.ok) continue;
+
+      const data = await response.json();
+      const messages = data.messages || [];
+
+      // Only process urgent messages via kill+continue
+      const urgentMessages = messages.filter(m => m.is_urgent || m.type === 'urgent');
+      if (urgentMessages.length === 0) continue;
+
+      // Combine all urgent messages into one injection
+      const combinedMessage = urgentMessages
+        .map(m => m.message)
+        .join('\n\n');
+
+      log(`Task #${displayNumber}: ${urgentMessages.length} urgent message(s) detected, initiating kill+continue`);
+
+      // Mark messages as read
+      for (const msg of urgentMessages) {
+        apiRequest('task-messages', {
+          method: 'PATCH',
+          body: JSON.stringify({ message_id: msg.id }),
+        }).catch(() => {}); // fire-and-forget
+      }
+
+      // Kill the current session and respawn with injected message
+      await injectMessageViaKillContinue(displayNumber, combinedMessage);
+    } catch (err) {
+      log(`Task #${displayNumber}: message poll failed (non-fatal): ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Kill the current Claude session and respawn with --continue, injecting a human message.
+ *
+ * Flow:
+ * 1. SIGTERM the running process
+ * 2. Wait for it to exit (handleTaskCompletion sees phase='injecting_message' and skips cleanup)
+ * 3. Respawn with `claude --continue <sessionId> -p "Human sent: <message>"`
+ *
+ * The ~12s penalty is for Claude to reload context from the session transcript.
+ */
+async function injectMessageViaKillContinue(displayNumber, message) {
+  const taskInfo = runningTasks.get(displayNumber);
+  if (!taskInfo) return;
+
+  const sessionId = taskInfo.sessionId;
+  const projectPath = taskInfo.projectPath || taskProjectPaths.get(displayNumber);
+  const info = taskDetails.get(displayNumber) || {};
+  const taskId = info.taskId;
+
+  // Mark phase so handleTaskCompletion knows to respawn instead of cleaning up
+  updateTaskDetail(displayNumber, {
+    phase: 'injecting_message',
+    detail: `Injecting message: ${message.slice(0, 50)}...`
+  });
+
+  // Report the injection event to Supabase
+  apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId: taskId,
+      displayNumber,
+      event: {
+        type: 'message_injected',
+        timestamp: new Date().toISOString(),
+        machineName: getMachineName() || undefined,
+        summary: `Human message injected: ${message.slice(0, 100)}`,
+      }
+    })
+  }).catch(() => {});
+
+  // Store the message for respawn (handleTaskCompletion will read this)
+  taskInfo.pendingInjection = { message, sessionId, projectPath, taskId };
+
+  // Kill the current process
+  try {
+    taskInfo.process.kill('SIGTERM');
+  } catch (err) {
+    log(`Task #${displayNumber}: SIGTERM for injection failed: ${err.message}`);
+    // Reset phase if kill failed
+    updateTaskDetail(displayNumber, { phase: 'executing' });
+    delete taskInfo.pendingInjection;
+  }
+}
+
+/**
+ * Respawn a Claude session after kill, with the human message injected.
+ * Called from handleTaskCompletion when phase === 'injecting_message'.
+ */
+function respawnWithInjectedMessage(displayNumber) {
+  const taskInfo = runningTasks.get(displayNumber);
+  if (!taskInfo || !taskInfo.pendingInjection) {
+    log(`Task #${displayNumber}: no pending injection found, cannot respawn`);
+    return;
+  }
+
+  const { message, sessionId, projectPath, taskId } = taskInfo.pendingInjection;
+  delete taskInfo.pendingInjection;
+
+  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 = [
+    '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(',');
+
+  // Generate new session ID for the respawned session
+  const newSessionId = randomUUID();
+
+  const claudeArgs = [
+    '--continue', sessionId,
+    '-p', injectionPrompt,
+    '--allowedTools', allowedTools,
+    '--output-format', 'stream-json',
+    '--permission-mode', 'bypassPermissions',
+    '--session-id', newSessionId,
+  ];
+
+  log(`Task #${displayNumber}: respawning with injected message (session: ${sessionId} -> ${newSessionId})`);
+
+  try {
+    const child = spawn('claude', claudeArgs, {
+      cwd: projectPath || process.cwd(),
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: (() => {
+        const env = { ...process.env, PUSH_TASK_ID: taskId, PUSH_DISPLAY_NUMBER: String(displayNumber) };
+        delete env.CLAUDECODE;
+        delete env.CLAUDE_CODE_ENTRYPOINT;
+        return env;
+      })()
+    });
+
+    // Replace the old process info
+    taskInfo.process = child;
+    taskInfo.sessionId = newSessionId;
+    taskInfo.startTime = taskInfo.startTime; // Keep original start time
+
+    // Re-initialize stream parsing state
+    taskStreamLineBuffer.set(displayNumber, '');
+    taskActivityState.set(displayNumber, {
+      filesRead: new Set(), filesEdited: new Set(),
+      currentTool: null, lastText: '', sessionId: null
+    });
+    taskLastStreamProgress.set(displayNumber, Date.now());
+    taskLastOutput.set(displayNumber, Date.now());
+    taskStdoutBuffer.set(displayNumber, []);
+    taskStderrBuffer.set(displayNumber, []);
+    taskLastHeartbeat.set(displayNumber, Date.now());
+
+    // Re-attach stdout handler (same as executeTask)
+    child.stdout.on('data', (data) => {
+      taskLastOutput.set(displayNumber, Date.now());
+
+      const pending = (taskStreamLineBuffer.get(displayNumber) || '') + data.toString();
+      const lines = pending.split('\n');
+      taskStreamLineBuffer.set(displayNumber, lines.pop() || '');
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        const buffer = taskStdoutBuffer.get(displayNumber) || [];
+        buffer.push(line);
+        if (buffer.length > 50) buffer.shift();
+        taskStdoutBuffer.set(displayNumber, buffer);
+
+        const event = parseStreamJsonLine(line);
+        if (event) {
+          processStreamEvent(displayNumber, event);
+        } else {
+          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}`);
+            updateTaskDetail(displayNumber, { phase: 'stuck', detail: `Waiting for input: ${stuckReason}` });
+          }
+        }
+      }
+    });
+
+    child.stderr.on('data', (data) => {
+      const lines = data.toString().split('\n');
+      for (const line of lines) {
+        if (line.trim()) {
+          const buffer = taskStderrBuffer.get(displayNumber) || [];
+          buffer.push(line);
+          if (buffer.length > 20) buffer.shift();
+          taskStderrBuffer.set(displayNumber, buffer);
+        }
+      }
+    });
+
+    child.on('close', (code) => {
+      handleTaskCompletion(displayNumber, code);
+    });
+
+    child.on('error', async (error) => {
+      logError(`Task #${displayNumber} respawn error: ${error.message}`);
+      runningTasks.delete(displayNumber);
+      await updateTaskStatus(displayNumber, 'failed', { error: `Respawn failed: ${error.message}` }, taskId);
+      taskDetails.delete(displayNumber);
+      taskLastHeartbeat.delete(displayNumber);
+      taskStreamLineBuffer.delete(displayNumber);
+      taskActivityState.delete(displayNumber);
+      taskLastStreamProgress.delete(displayNumber);
+      updateStatusFile();
+    });
+
+    updateTaskDetail(displayNumber, {
+      phase: 'executing',
+      detail: 'Resumed with injected message',
+      claudePid: child.pid
+    });
+
+    // Update session ID in Supabase
+    apiRequest('update-task-execution', {
+      method: 'PATCH',
+      body: JSON.stringify({
+        todoId: taskId,
+        displayNumber,
+        sessionId: newSessionId,
+        event: {
+          type: 'progress',
+          timestamp: new Date().toISOString(),
+          machineName: getMachineName() || undefined,
+          summary: `Respawned with injected human message (new session: ${newSessionId.slice(0, 8)})`,
+        }
+      })
+    }).catch(() => {});
+
+    log(`Task #${displayNumber}: respawned successfully (PID: ${child.pid})`);
+  } catch (error) {
+    logError(`Task #${displayNumber}: respawn failed: ${error.message}`);
+    // Clean up — task is effectively dead
+    runningTasks.delete(displayNumber);
+    updateTaskStatus(displayNumber, 'failed', {
+      error: `Message injection respawn failed: ${error.message}`
+    }, taskId).catch(() => {});
+    taskDetails.delete(displayNumber);
+    taskStreamLineBuffer.delete(displayNumber);
+    taskActivityState.delete(displayNumber);
+    taskLastStreamProgress.delete(displayNumber);
+    updateStatusFile();
+  }
+}
+
 function monitorTaskStdout(displayNumber, proc) {
   if (!proc.stdout) return;
 
@@ -2188,10 +2477,19 @@ async function handleTaskCompletion(displayNumber, exitCode) {
   const taskInfo = runningTasks.get(displayNumber);
   if (!taskInfo) return;
 
+  const info = taskDetails.get(displayNumber) || {};
+
+  // Message injection: process was killed to inject a human message.
+  // Don't clean up — respawn with --continue instead.
+  if (info.phase === 'injecting_message' && taskInfo.pendingInjection) {
+    log(`Task #${displayNumber}: process exited for message injection (code ${exitCode}), respawning...`);
+    respawnWithInjectedMessage(displayNumber);
+    return;
+  }
+
   runningTasks.delete(displayNumber);
 
   const duration = Math.floor((Date.now() - taskInfo.startTime) / 1000);
-  const info = taskDetails.get(displayNumber) || {};
   const summary = info.summary || 'Unknown task';
   const projectPath = taskProjectPaths.get(displayNumber);
 
@@ -2502,6 +2800,13 @@ async function checkTimeouts() {
   // Level A: Send progress heartbeats for long-running tasks
   await sendProgressHeartbeats();
 
+  // Phase 4: Check for urgent human messages to inject into running tasks
+  try {
+    await checkUrgentMessages();
+  } catch (error) {
+    logError(`Urgent message check failed (non-fatal): ${error.message}`);
+  }
+
   // Level B: Kill tasks that have been idle too long (fires at 15 min, before 60 min absolute)
   await killIdleTasks();
 
@@ -2684,6 +2989,127 @@ 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,
+    '--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() {
@@ -2845,7 +3271,7 @@ async function mainLoop() {
 
       // Cron jobs (check every poll cycle, execution throttled by nextRunAt)
       try {
-        await checkAndRunDueJobs(log);
+        await checkAndRunDueJobs(log, { apiRequest, spawnHealthCheck });
       } catch (error) {
         logError(`Cron check error: ${error.message}`);
       }

package/package.json

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