@c4t4/heyamigo 0.9.4 → 0.9.5

package/dist/memory/scheduler.js

@@ -2,6 +2,8 @@ import fastq from 'fastq';
 import { config } from '../config.js';
 import { logger } from '../logger.js';
 import { prunePrompts } from '../promptlog.js';
+import { registerInternalCronHandler } from '../queue/cron-handlers.js';
+import { deleteCron, enqueueCron } from '../queue/crons.js';
 import { pruneMedia } from '../store/media.js';
 import { runDigest } from './digest.js';
 import { ensureScaffold, getLastDigestedAt, jsonlMtimeFor, loadDigestState, } from './store.js';
@@ -74,7 +76,6 @@ async function sweep() {
     }
 }
 let sweepTimer = null;
-let nudgeTimer = null;
 const NUDGE_TICK_MS = 5 * 60 * 1000; // 5 minutes
 export function startScheduler() {
     if (sweepTimer)
@@ -95,13 +96,17 @@ export function startScheduler() {
     sweepTimer = setInterval(() => {
         void sweep().catch((err) => logger.error({ err }, 'sweep failed'));
     }, config.memory.sweepIntervalMs);
-    // Faster tick just for proactive journal nudges (check-ins, silent-nudges).
-    // The memory-sweep cycle (default 3h) is too coarse for a "daily 21:00"
-    // check-in. This tick is cheap: it only spawns Claude when something is
-    // actually due for a journal.
-    nudgeTimer = setInterval(() => {
-        void runNudgeTickSafe();
-    }, NUDGE_TICK_MS);
+    // Proactive journal nudges (check-ins, silent-nudges). Migrated from
+    // setInterval to a cron row → orchestrator. Same cadence, same body;
+    // benefits are: survives restarts, visible in `crons` table, can be
+    // paused via control row without code change.
+    registerInternalCronHandler('journal-nudge-tick', runNudgeTickSafe);
+    enqueueCron({
+        name: 'journal-nudge-tick',
+        enqueueInto: 'internal',
+        payload: { handler: 'journal-nudge-tick' },
+        recurrence: `@every ${Math.floor(NUDGE_TICK_MS / 1000)}s`,
+    });
     logger.info({
         intervalMs: config.memory.sweepIntervalMs,
         nudgeTickMs: NUDGE_TICK_MS,
@@ -121,11 +126,18 @@ export function stopScheduler() {
         clearInterval(sweepTimer);
         sweepTimer = null;
     }
-    if (nudgeTimer) {
-        clearInterval(nudgeTimer);
-        nudgeTimer = null;
-    }
+    // Nudge cron is owned by the crons table; orchestrator stops on its
+    // own. Deleting the cron row here would re-arm itself on next boot,
+    // so leave it alone — disabling via the `enabled` column is the
+    // user-facing knob.
     for (const t of pendingTimers.values())
         clearTimeout(t);
     pendingTimers.clear();
 }
+// Exported for callers (CLI, /nudge command) that want to surgically
+// disable nudges without editing config. Use `setCronEnabled` from
+// crons.ts for the on/off switch; this is a hard delete (regenerated
+// on next startScheduler call).
+export function deleteNudgeCron() {
+    return deleteCron('journal-nudge-tick');
+}

package/dist/queue/cron-dispatch.js

@@ -5,6 +5,7 @@
 // in on later phases — when those queues exist, add their dispatch
 // here and a cron can fire into them with no other changes.
 import { logger } from '../logger.js';
+import { getInternalCronHandler } from './cron-handlers.js';
 import { enqueueOutbound } from './outbound.js';
 export function dispatchCron(row) {
     let payload;
@@ -19,6 +20,9 @@ export function dispatchCron(row) {
         case 'outbound':
             dispatchOutbound(row, payload);
             return;
+        case 'internal':
+            dispatchInternal(row, payload);
+            return;
         case 'inbound':
         case 'async':
         case 'memory_writes':
@@ -28,6 +32,34 @@ export function dispatchCron(row) {
             logger.error({ name: row.name, target: row.enqueueInto }, 'cron has unknown target queue');
     }
 }
+function dispatchInternal(row, payload) {
+    if (!payload || typeof payload !== 'object' || !('handler' in payload)) {
+        logger.error({ id: row.id, name: row.name }, "internal cron missing 'handler' in payload");
+        return;
+    }
+    const handlerName = payload.handler;
+    if (typeof handlerName !== 'string') {
+        logger.error({ id: row.id, name: row.name }, 'internal cron handler name not a string');
+        return;
+    }
+    const handler = getInternalCronHandler(handlerName);
+    if (!handler) {
+        logger.error({ id: row.id, name: row.name, handler: handlerName }, 'internal cron handler not registered');
+        return;
+    }
+    // Fire-and-forget. Handler errors are caught and logged but the
+    // cron row still gets marked fired so we don't stack up retries.
+    try {
+        const result = handler();
+        if (result && typeof result.catch === 'function') {
+            ;
+            result.catch((err) => logger.error({ err, handler: handlerName }, 'internal cron handler rejected'));
+        }
+    }
+    catch (err) {
+        logger.error({ err, handler: handlerName }, 'internal cron handler threw');
+    }
+}
 function dispatchOutbound(row, payload) {
     if (!isOutboundPayload(payload)) {
         logger.error({ id: row.id, payload }, 'cron outbound payload malformed');

package/dist/queue/cron-handlers.js

@@ -0,0 +1,25 @@
+// In-process handler registry for the 'internal' cron target.
+//
+// Not every periodic task fits the queue→worker model. Things like
+// "run the journal observer sweep" or "regenerate compressed memory"
+// are pure in-process work — there's no queue to enqueue into, the
+// orchestrator just needs to call a function.
+//
+// Mechanism: cron rows with enqueue_into='internal' carry a payload
+// with `handler: <name>`. The dispatcher looks up the name in this
+// registry and invokes the function. Registry is populated at boot,
+// before the orchestrator starts polling.
+import { logger } from '../logger.js';
+const registry = new Map();
+export function registerInternalCronHandler(name, handler) {
+    if (registry.has(name)) {
+        logger.warn({ name }, 'internal cron handler already registered; overwriting');
+    }
+    registry.set(name, handler);
+}
+export function getInternalCronHandler(name) {
+    return registry.get(name);
+}
+export function listInternalCronHandlers() {
+    return [...registry.keys()];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4t4/heyamigo",
-  "version": "0.9.4",
+  "version": "0.9.5",
   "description": "WhatsApp AI bot powered by Claude with long-term memory, browser control, and role-based access",
   "type": "module",
   "main": "dist/index.js",