@masslessai/push-todo 4.5.1 → 4.5.3

package/lib/cli.js

@@ -17,7 +17,7 @@ import { showSettings, toggleSetting, setMaxBatchSize } from './config.js';
 import { ensureDaemonRunning, getDaemonStatus, startDaemon, stopDaemon } from './daemon-health.js';
 import { install as installLaunchAgent, uninstall as uninstallLaunchAgent, getStatus as getLaunchAgentStatus } from './launchagent.js';
 import { getScreenshotPath, screenshotExists, openScreenshot } from './utils/screenshots.js';
-import { bold, red, cyan, dim, green } from './utils/colors.js';
+import { bold, red, cyan, dim, green, yellow } from './utils/colors.js';
 import { getMachineId } from './machine-id.js';
 import { parseReminder } from './reminder-parser.js';
 
@@ -139,6 +139,12 @@ ${bold('SCHEDULE (remote scheduled jobs):')}
   push-todo schedule enable <id>     Enable a schedule
   push-todo schedule disable <id>    Disable a schedule
 
+${bold('JOURNAL (daily automated journal):')}
+  push-todo journal setup            Install daily journal cron (default: 9pm)
+    --time <HH:MM>                   Time to run daily (e.g., "21:00", "09:30")
+  push-todo journal status           Show journal cron status
+  push-todo journal remove           Uninstall journal cron
+
 ${bold('SETTINGS:')}
   push-todo setting                Show all settings
   push-todo setting auto-commit    Toggle auto-commit
@@ -212,6 +218,8 @@ const options = {
   'check-messages': { type: 'string' },
   'request-input': { type: 'string' },
   'question': { type: 'string' },
+  // Journal cron options
+  'time': { type: 'string' },
 };
 
 /**
@@ -970,6 +978,63 @@ ${bold('Examples:')}
     return;
   }
 
+  // Journal cron command
+  if (command === 'journal') {
+    const { install, uninstall, getStatus, parseTime, formatTime, DEFAULT_HOUR, DEFAULT_MINUTE } = await import('./journal-cron.js');
+    const subCommand = positionals[1] || 'setup';
+
+    if (subCommand === 'setup') {
+      let hour = DEFAULT_HOUR;
+      let minute = DEFAULT_MINUTE;
+      if (values.time) {
+        try {
+          ({ hour, minute } = parseTime(values.time));
+        } catch (error) {
+          console.error(red(error.message));
+          process.exit(1);
+        }
+      }
+      const result = install({ hour, minute });
+      if (result.success) {
+        console.log(green(result.message));
+        console.log(dim(`Journal entries will be written to ~/journal/`));
+        console.log(dim(`Logs: ~/.push/journal.log`));
+      } else {
+        console.error(red(result.message));
+        process.exit(1);
+      }
+      return;
+    }
+
+    if (subCommand === 'status') {
+      const status = getStatus();
+      if (!status.installed) {
+        console.log(dim('Journal cron not installed. Run: push-todo journal setup'));
+        return;
+      }
+      const timeStr = typeof status.hour === 'number' ? formatTime(status.hour, status.minute) : 'unknown';
+      console.log(`Journal cron: ${status.loaded ? green('active') : yellow('installed (not loaded)')}`);
+      console.log(`  Runs daily at: ${bold(timeStr)}`);
+      console.log(`  Logs: ~/.push/journal.log`);
+      return;
+    }
+
+    if (subCommand === 'remove') {
+      const result = uninstall();
+      if (result.success) {
+        console.log(green(result.message));
+      } else {
+        console.error(red(result.message));
+        process.exit(1);
+      }
+      return;
+    }
+
+    console.error(red(`Unknown journal subcommand: ${subCommand}`));
+    console.log(dim('Usage: push-todo journal [setup|status|remove]'));
+    process.exit(1);
+  }
+
   // Connect command
   if (command === 'connect') {
     if (values.auto) {

package/lib/context-engine.js

@@ -111,8 +111,10 @@ export function scanProjectSkills(projectPath) {
         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 use "allowed-tools" in frontmatter, fall back to "tools" for compatibility
+        const toolsRaw = frontmatter['allowed-tools'] || frontmatter.tools;
+        const tools = toolsRaw
+          ? toolsRaw.split(',').map(t => t.trim()).filter(Boolean)
           : [];
 
         skills.push({

package/lib/daemon.js

@@ -1621,7 +1621,9 @@ function respawnWithInjectedMessage(displayNumber) {
     'Bash(npm *)', 'Bash(npx *)', 'Bash(yarn *)',
     'Bash(python *)', 'Bash(python3 *)', 'Bash(pip *)', 'Bash(pip3 *)',
     'Bash(push-todo *)',
-    'Task',
+    'Bash(bird *)', 'Bash(gh *)',
+    'Bash(redbook *)',
+    'Task', 'Agent',
     'WebSearch', 'WebFetch',
     'ToolSearch',
   ];
@@ -1943,8 +1945,15 @@ async function killIdleTasks() {
     if (!lastOutput) continue; // No output tracking yet — not idle, just starting
 
     const idleMs = now - lastOutput;
-    if (idleMs > IDLE_TIMEOUT_MS) {
-      log(`Task #${displayNumber} IDLE TIMEOUT: ${Math.floor(idleMs / 1000)}s since last output`);
+
+    // Agent subprocesses can run for minutes without producing stdout.
+    // Use a longer timeout (3x) when the last known tool is Agent.
+    const activity = taskActivityState.get(displayNumber) || {};
+    const isAgentRunning = activity.currentTool === 'Agent';
+    const effectiveTimeout = isAgentRunning ? IDLE_TIMEOUT_MS * 3 : IDLE_TIMEOUT_MS;
+
+    if (idleMs > effectiveTimeout) {
+      log(`Task #${displayNumber} IDLE TIMEOUT: ${Math.floor(idleMs / 1000)}s since last output${isAgentRunning ? ' (Agent extended)' : ''}`);
       idleTimedOut.push(displayNumber);
     }
   }
@@ -2274,9 +2283,11 @@ async function executeTask(task) {
       parts.push('Links:\n' + links.map(l => `  - ${l.url}${l.title ? ` (${l.title})` : ''}`).join('\n'));
     }
     if (screenshots.length > 0) {
-      parts.push('Screenshots:\n' + screenshots.map(s =>
-        `  - ${s.imageFilename || s.image_filename}${s.sourceApp ? ` (from ${s.sourceApp})` : ''}`
-      ).join('\n'));
+      const screenshotDir = join(homedir(), 'Library', 'Mobile Documents', 'iCloud~ai~massless~push', 'Documents', 'Screenshots');
+      parts.push('Screenshots (use Read tool on these paths):\n' + screenshots.map(s => {
+        const filename = s.imageFilename || s.image_filename;
+        return `  - ${join(screenshotDir, filename)}${s.sourceApp ? ` (from ${s.sourceApp})` : ''}`;
+      }).join('\n'));
     }
 
     if (parts.length > 0) {
@@ -2306,7 +2317,9 @@ async function executeTask(task) {
     'Bash(npm *)', 'Bash(npx *)', 'Bash(yarn *)',
     'Bash(python *)', 'Bash(python3 *)', 'Bash(pip *)', 'Bash(pip3 *)',
     'Bash(push-todo *)',
-    'Task',
+    'Bash(bird *)', 'Bash(gh *)',
+    'Bash(redbook *)',
+    'Task', 'Agent',
     'WebSearch', 'WebFetch',
     'ToolSearch',
   ];
@@ -2564,16 +2577,30 @@ async function handleTaskCompletion(displayNumber, exitCode) {
       executionSummary += ` PR: ${prUrl}`;
     }
 
+    // Build structured recap for briefing visualization (JSONB column)
+    const prNumber = prUrl ? parseInt((prUrl.match(/\/(\d+)$/) || [])[1] || '0', 10) || null : null;
+    const executionRecap = {
+      durationStr,
+      durationSeconds: duration,
+      diagram: visualArtifact || null,
+      machineName,
+      outcome: {
+        prUrl: prUrl || null,
+        prNumber,
+      },
+    };
+
     const statusUpdated = await updateTaskStatus(displayNumber, 'session_finished', {
       duration,
       sessionId,
-      summary: executionSummary
+      summary: executionSummary,
+      executionRecap,
     }, info.taskId);
     if (!statusUpdated) {
       logError(`Task #${displayNumber}: Failed to update status to session_finished — will retry`);
       // Retry once
       await updateTaskStatus(displayNumber, 'session_finished', {
-        duration, sessionId, summary: executionSummary
+        duration, sessionId, summary: executionSummary, executionRecap,
       }, info.taskId);
     }
 
@@ -2692,7 +2719,13 @@ async function handleTaskCompletion(displayNumber, exitCode) {
       ? `${failureSummary}\nExit code ${exitCode}. Ran for ${durationStr} on ${machineName}.`
       : `Exit code ${exitCode}: ${stderr.slice(0, 200)}`;
 
-    await updateTaskStatus(displayNumber, 'failed', { error: errorMsg, sessionId }, info.taskId);
+    const failedRecap = {
+      durationStr,
+      durationSeconds: duration,
+      machineName,
+      exitCode,
+    };
+    await updateTaskStatus(displayNumber, 'failed', { error: errorMsg, sessionId, executionRecap: failedRecap }, info.taskId);
 
     if (NOTIFY_ON_FAILURE) {
       sendMacNotification(

package/lib/journal-cron.js

@@ -0,0 +1,236 @@
+/**
+ * Daily journal cron via LaunchAgent.
+ *
+ * Installs a user-level LaunchAgent that fires claude with /journal today
+ * at a configurable daily time. More reliable than Supabase remote schedules:
+ * - System-level: survives daemon restarts and Supabase outages
+ * - StartCalendarInterval: native macOS daily scheduling (no polling)
+ * - Writes to ~/journal/ in the user's home directory
+ *
+ * Usage:
+ *   push-todo journal setup          Install at 9pm (default)
+ *   push-todo journal setup --time 21:30   Install at 9:30pm
+ *   push-todo journal status         Show status
+ *   push-todo journal remove         Uninstall
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from 'fs';
+import { execFileSync } from 'child_process';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const LABEL = 'ai.massless.push.journal';
+const LAUNCH_AGENTS_DIR = join(homedir(), 'Library', 'LaunchAgents');
+const PLIST_PATH = join(LAUNCH_AGENTS_DIR, `${LABEL}.plist`);
+const PUSH_DIR = join(homedir(), '.push');
+const LOG_FILE = join(PUSH_DIR, 'journal.log');
+
+// Default: 9pm daily
+const DEFAULT_HOUR = 21;
+const DEFAULT_MINUTE = 0;
+
+/**
+ * Find the claude binary (real binary, not shell function).
+ * Tries ~/.local/bin/claude first, then PATH.
+ */
+function findClaudeBinary() {
+  const candidates = [
+    join(homedir(), '.local', 'bin', 'claude'),
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+  // Fallback: search PATH via which
+  try {
+    const found = execFileSync('which', ['claude'], { encoding: 'utf8', timeout: 5000 }).trim();
+    if (found && existsSync(found)) return found;
+  } catch {}
+  return 'claude'; // last resort
+}
+
+/**
+ * Parse "HH:MM" string into { hour, minute }.
+ * Throws if format is invalid.
+ */
+export function parseTime(timeStr) {
+  const match = timeStr.match(/^(\d{1,2}):(\d{2})$/);
+  if (!match) throw new Error(`Invalid time format: "${timeStr}". Use HH:MM (e.g., "21:00", "09:30")`);
+  const hour = parseInt(match[1], 10);
+  const minute = parseInt(match[2], 10);
+  if (hour < 0 || hour > 23) throw new Error(`Hour must be 0-23, got ${hour}`);
+  if (minute < 0 || minute > 59) throw new Error(`Minute must be 0-59, got ${minute}`);
+  return { hour, minute };
+}
+
+/**
+ * Generate the plist XML for the daily journal LaunchAgent.
+ */
+function generatePlist(hour, minute) {
+  const claudeBin = findClaudeBinary();
+  const nodePath = join(homedir(), '.nvm', 'versions', 'node', 'v24.9.0', 'bin');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${LABEL}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${claudeBin}</string>
+        <string>-p</string>
+        <string>Run /journal today - generate today's journal entry summarizing the day's work, experiments, and learnings. Use the journal skill to write the entry to ~/journal/ with today's date.</string>
+        <string>--dangerously-skip-permissions</string>
+        <string>--allowedTools</string>
+        <string>Read,Write,Glob,Grep</string>
+    </array>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:${nodePath}:${join(homedir(), '.local', 'bin')}</string>
+        <key>HOME</key>
+        <string>${homedir()}</string>
+    </dict>
+
+    <key>WorkingDirectory</key>
+    <string>${homedir()}</string>
+
+    <key>StartCalendarInterval</key>
+    <dict>
+        <key>Hour</key>
+        <integer>${hour}</integer>
+        <key>Minute</key>
+        <integer>${minute}</integer>
+    </dict>
+
+    <key>StandardOutPath</key>
+    <string>${LOG_FILE}</string>
+
+    <key>StandardErrorPath</key>
+    <string>${LOG_FILE}</string>
+</dict>
+</plist>
+`;
+}
+
+/**
+ * Read the hour/minute from an installed plist.
+ * Returns null if not installed or can't parse.
+ */
+function readInstalledTime() {
+  if (!existsSync(PLIST_PATH)) return null;
+  try {
+    const content = readFileSync(PLIST_PATH, 'utf8');
+    const hourMatch = content.match(/<key>Hour<\/key>\s*<integer>(\d+)<\/integer>/);
+    const minMatch = content.match(/<key>Minute<\/key>\s*<integer>(\d+)<\/integer>/);
+    if (hourMatch && minMatch) {
+      return { hour: parseInt(hourMatch[1], 10), minute: parseInt(minMatch[1], 10) };
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * Format hour/minute as "HH:MM am/pm".
+ */
+function formatTime(hour, minute) {
+  const suffix = hour >= 12 ? 'pm' : 'am';
+  const displayHour = hour % 12 || 12;
+  const displayMin = String(minute).padStart(2, '0');
+  return `${displayHour}:${displayMin}${suffix}`;
+}
+
+/**
+ * Check installation status.
+ * @returns {{ installed: boolean, loaded: boolean, hour?: number, minute?: number }}
+ */
+export function getStatus() {
+  const installed = existsSync(PLIST_PATH);
+  let loaded = false;
+
+  if (installed) {
+    try {
+      execFileSync('launchctl', ['list', LABEL], {
+        timeout: 5000,
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
+      loaded = true;
+    } catch {}
+  }
+
+  const time = readInstalledTime();
+  return { installed, loaded, ...time };
+}
+
+/**
+ * Install (or update) the daily journal LaunchAgent.
+ *
+ * @param {{ hour?: number, minute?: number }} options
+ * @returns {{ success: boolean, message: string }}
+ */
+export function install({ hour = DEFAULT_HOUR, minute = DEFAULT_MINUTE } = {}) {
+  try {
+    mkdirSync(LAUNCH_AGENTS_DIR, { recursive: true });
+    mkdirSync(PUSH_DIR, { recursive: true });
+
+    const newContent = generatePlist(hour, minute);
+
+    // Unload existing if present (to apply time changes)
+    if (existsSync(PLIST_PATH)) {
+      try {
+        execFileSync('launchctl', ['unload', PLIST_PATH], {
+          timeout: 5000,
+          stdio: ['ignore', 'ignore', 'ignore'],
+        });
+      } catch {}
+    }
+
+    writeFileSync(PLIST_PATH, newContent);
+
+    execFileSync('launchctl', ['load', '-w', PLIST_PATH], {
+      timeout: 5000,
+      stdio: ['ignore', 'ignore', 'ignore'],
+    });
+
+    const timeStr = formatTime(hour, minute);
+    return {
+      success: true,
+      message: `Journal cron installed — runs daily at ${timeStr}`,
+      hour,
+      minute,
+    };
+  } catch (error) {
+    return { success: false, message: `Failed to install journal cron: ${error.message}` };
+  }
+}
+
+/**
+ * Uninstall the journal LaunchAgent.
+ *
+ * @returns {{ success: boolean, message: string }}
+ */
+export function uninstall() {
+  try {
+    if (!existsSync(PLIST_PATH)) {
+      return { success: true, message: 'Journal cron not installed (nothing to remove)' };
+    }
+
+    try {
+      execFileSync('launchctl', ['unload', PLIST_PATH], {
+        timeout: 5000,
+        stdio: ['ignore', 'ignore', 'ignore'],
+      });
+    } catch {}
+
+    unlinkSync(PLIST_PATH);
+    return { success: true, message: 'Journal cron removed' };
+  } catch (error) {
+    return { success: false, message: `Failed to remove journal cron: ${error.message}` };
+  }
+}
+
+export { PLIST_PATH, LABEL, LOG_FILE, DEFAULT_HOUR, DEFAULT_MINUTE, formatTime };

package/package.json

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