@c4t4/heyamigo 0.9.2 → 0.9.4

package/dist/db/schema.js

@@ -95,3 +95,36 @@ export const outbound = sqliteTable('outbound', {
         .on(t.idempotencyKey)
         .where(sql `${t.idempotencyKey} IS NOT NULL`),
 }));
+// ──────────────────────────────────────────────────────────────────
+// Cron table (Phase 2.2)
+// ──────────────────────────────────────────────────────────────────
+// Schedules. Not really a queue — a *table polled by the orchestrator*
+// that fires inserts into the other queues when next_run_at <= now.
+//
+// recurrence:
+//   null              → one-shot (deleted after firing)
+//   '@every <n><unit>' → 'every 30s', 'every 5m', 'every 3h', 'every 7d'
+//   '@daily HH:MM'    → daily at owner-tz local time
+//   '@weekly DOW HH:MM' → weekly at owner-tz local time
+//                        DOW = mon|tue|wed|thu|fri|sat|sun
+// (Cron expressions intentionally NOT supported until we need them —
+// own@every / @daily / @weekly covers every existing setInterval.)
+export const crons = sqliteTable('crons', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    name: text('name').notNull(), // human-readable; uniqueness enforced for non-oneshot
+    enqueueInto: text('enqueue_into').notNull(), // 'inbound'|'async'|'outbound'|'memory_writes'
+    payload: text('payload').notNull(), // JSON passed to the target queue
+    recurrence: text('recurrence'), // null = one-shot
+    nextRunAt: integer('next_run_at').notNull(),
+    lastRunAt: integer('last_run_at'),
+    enabled: integer('enabled').notNull().default(1), // SQLite bool = int
+    createdAt: integer('created_at').notNull(),
+}, t => ({
+    byDue: index('crons_by_due').on(t.enabled, t.nextRunAt),
+    // Named recurring crons must be unique — prevents accidental
+    // duplicate schedules from setup wizard re-runs etc. One-shots
+    // (recurrence IS NULL) can have any name.
+    uniqName: uniqueIndex('crons_name_uq')
+        .on(t.name)
+        .where(sql `${t.recurrence} IS NOT NULL`),
+}));

package/dist/index.js

@@ -5,6 +5,7 @@ import { attachIncoming } from './gateway/incoming.js';
 import { handleReply } from './gateway/outgoing.js';
 import { logger } from './logger.js';
 import { startScheduler } from './memory/scheduler.js';
+import { requestShutdown, startOrchestrator, stopOrchestrator, } from './queue/orchestrator.js';
 import { replayPending } from './queue/queue.js';
 import { startSenderWorker, stopSenderWorker } from './queue/sender-worker.js';
 import { startSocket } from './wa/socket.js';
@@ -14,6 +15,16 @@ async function main() {
     initDb();
     // Derived view: populate persons + identities from access.json.
     syncIdentitiesFromAccess();
+    // Orchestrator handles cross-cutting bookkeeping: control table
+    // signals, stuck-claim reclaim, dead-worker detection, cron polling
+    // (Phase 2.2+). Starts before workers so it can see them register.
+    startOrchestrator({
+        onShutdownDrained: () => {
+            stopSenderWorker();
+            stopOrchestrator();
+            closeDb();
+        },
+    });
     // Sender worker drains outbound queue → channel adapters. Started
     // before the socket so it's ready when handleReply enqueues rows.
     startSenderWorker();
@@ -30,17 +41,17 @@ async function main() {
         await handleReply(job, result, {});
     }).catch((err) => logger.error({ err }, 'replay failed'));
 }
+// Graceful shutdown: signal handler writes a 'shutdown' row to the
+// control table; orchestrator picks it up, drains in-flight work,
+// then runs onShutdownDrained (stops workers, closes DB) and exits.
+// A 30s timer inside the orchestrator force-exits if drain hangs.
 process.on('SIGINT', () => {
-    logger.info('SIGINT received, shutting down');
-    stopSenderWorker();
-    closeDb();
-    process.exit(0);
+    logger.info('SIGINT received, requesting graceful shutdown');
+    requestShutdown('SIGINT');
 });
 process.on('SIGTERM', () => {
-    logger.info('SIGTERM received, shutting down');
-    stopSenderWorker();
-    closeDb();
-    process.exit(0);
+    logger.info('SIGTERM received, requesting graceful shutdown');
+    requestShutdown('SIGTERM');
 });
 main().catch((err) => {
     logger.error({ err }, 'fatal error during boot');

package/dist/queue/control.js

@@ -0,0 +1,40 @@
+// Helpers for the control table — the bot's runtime signalling
+// channel. SIGTERM, /shutdown chat command, or external trigger all
+// insert a control row; the orchestrator picks it up on its next tick
+// and acts.
+//
+// Single-row-per-key: PK on `key` gives natural upsert semantics.
+import { eq } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { control } from '../db/schema.js';
+export function requestControl(key, value = null, requestedBy = null) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    db.insert(control)
+        .values({ key, value, requestedBy, requestedAt: now })
+        .onConflictDoUpdate({
+        target: control.key,
+        set: { value, requestedBy, requestedAt: now },
+    })
+        .run();
+}
+export function readControl(key) {
+    const db = getDb();
+    const row = db.select().from(control).where(eq(control.key, key)).get();
+    if (!row)
+        return null;
+    return {
+        value: row.value,
+        requestedBy: row.requestedBy,
+        requestedAt: row.requestedAt,
+    };
+}
+export function clearControl(key) {
+    const db = getDb();
+    const result = db
+        .delete(control)
+        .where(eq(control.key, key))
+        .returning({ key: control.key })
+        .all();
+    return result.length > 0;
+}

package/dist/queue/cron-dispatch.js

@@ -0,0 +1,50 @@
+// Maps a fired cron row's payload into the right target queue.
+// Called by the orchestrator each tick for due rows.
+//
+// Currently supports: outbound. inbound, async, memory_writes ride
+// 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 { enqueueOutbound } from './outbound.js';
+export function dispatchCron(row) {
+    let payload;
+    try {
+        payload = JSON.parse(row.payload);
+    }
+    catch (err) {
+        logger.error({ err, id: row.id, name: row.name }, 'cron payload not JSON');
+        return;
+    }
+    switch (row.enqueueInto) {
+        case 'outbound':
+            dispatchOutbound(row, payload);
+            return;
+        case 'inbound':
+        case 'async':
+        case 'memory_writes':
+            logger.warn({ name: row.name, target: row.enqueueInto }, 'cron target queue not yet wired (phase pending)');
+            return;
+        default:
+            logger.error({ name: row.name, target: row.enqueueInto }, 'cron has unknown target queue');
+    }
+}
+function dispatchOutbound(row, payload) {
+    if (!isOutboundPayload(payload)) {
+        logger.error({ id: row.id, payload }, 'cron outbound payload malformed');
+        return;
+    }
+    enqueueOutbound({
+        ...payload,
+        // Recurring crons MUST NOT collide with prior firings; embed the
+        // current tick in the idempotency key. One-shots can supply their
+        // own.
+        idempotencyKey: payload.idempotencyKey ??
+            `cron-${row.name}-${Math.floor(Date.now() / 1000)}`,
+    });
+}
+function isOutboundPayload(p) {
+    if (!p || typeof p !== 'object')
+        return false;
+    const o = p;
+    return typeof o.address === 'string' && typeof o.kind === 'string';
+}

package/dist/queue/crons.js

@@ -0,0 +1,205 @@
+// Cron table helpers. Orchestrator polls `listDueCrons()` each tick;
+// each due row gets its `payload` enqueued into its target queue,
+// then `markCronFired()` updates `lastRunAt` and recomputes
+// `nextRunAt` (or deletes if one-shot).
+//
+// Recurrence formats supported:
+//   '@every <n><unit>'        n>0 integer; unit s|m|h|d
+//   '@daily HH:MM'            owner-tz local
+//   '@weekly DOW HH:MM'       owner-tz local; DOW = mon..sun
+//
+// No general cron expression parser — every existing setInterval in
+// the bot maps to one of the three forms above. Adding cron parsing
+// is straightforward later if we need it.
+import { and, asc, eq, lte } from 'drizzle-orm';
+import { config } from '../config.js';
+import { getDb } from '../db/index.js';
+import { logger } from '../logger.js';
+import { crons } from '../db/schema.js';
+// Idempotent for named recurring crons: re-inserting the same name
+// updates the recurrence/payload but leaves nextRunAt alone (so we
+// don't reset the firing schedule on every boot).
+export function enqueueCron(input) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const enabled = (input.enabled ?? true) ? 1 : 0;
+    if (input.recurrence) {
+        const existing = db
+            .select()
+            .from(crons)
+            .where(eq(crons.name, input.name))
+            .get();
+        if (existing) {
+            const updated = db
+                .update(crons)
+                .set({
+                enqueueInto: input.enqueueInto,
+                payload: JSON.stringify(input.payload),
+                recurrence: input.recurrence,
+                enabled,
+            })
+                .where(eq(crons.name, input.name))
+                .returning()
+                .get();
+            return updated;
+        }
+    }
+    const firstRunAt = input.firstRunAt ?? computeNextRun(input.recurrence, now);
+    if (firstRunAt === null) {
+        throw new Error(`enqueueCron(${input.name}): one-shot requires firstRunAt`);
+    }
+    return db
+        .insert(crons)
+        .values({
+        name: input.name,
+        enqueueInto: input.enqueueInto,
+        payload: JSON.stringify(input.payload),
+        recurrence: input.recurrence,
+        nextRunAt: firstRunAt,
+        lastRunAt: null,
+        enabled,
+        createdAt: now,
+    })
+        .returning()
+        .get();
+}
+export function listDueCrons(asOf = Math.floor(Date.now() / 1000)) {
+    const db = getDb();
+    return db
+        .select()
+        .from(crons)
+        .where(and(eq(crons.enabled, 1), lte(crons.nextRunAt, asOf)))
+        .orderBy(asc(crons.nextRunAt))
+        .all();
+}
+// Called by orchestrator after the cron's payload has been enqueued
+// into its target queue. Recurring crons get nextRunAt advanced;
+// one-shots get deleted.
+export function markCronFired(row) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    if (row.recurrence === null) {
+        db.delete(crons).where(eq(crons.id, row.id)).run();
+        return;
+    }
+    const next = computeNextRun(row.recurrence, now);
+    if (next === null) {
+        logger.error({ id: row.id, name: row.name, recurrence: row.recurrence }, 'cron has unparseable recurrence after firing; disabling');
+        db.update(crons)
+            .set({ enabled: 0, lastRunAt: now })
+            .where(eq(crons.id, row.id))
+            .run();
+        return;
+    }
+    db.update(crons)
+        .set({ lastRunAt: now, nextRunAt: next })
+        .where(eq(crons.id, row.id))
+        .run();
+}
+export function deleteCron(name) {
+    const db = getDb();
+    const result = db
+        .delete(crons)
+        .where(eq(crons.name, name))
+        .returning({ id: crons.id })
+        .all();
+    return result.length > 0;
+}
+export function setCronEnabled(name, enabled) {
+    const db = getDb();
+    const result = db
+        .update(crons)
+        .set({ enabled: enabled ? 1 : 0 })
+        .where(eq(crons.name, name))
+        .returning({ id: crons.id })
+        .all();
+    return result.length > 0;
+}
+// ──────────────────────────────────────────────────────────────────
+// Recurrence parser
+// ──────────────────────────────────────────────────────────────────
+const EVERY_RE = /^@every\s+(\d+)\s*([smhd])$/;
+const DAILY_RE = /^@daily\s+(\d{1,2}):(\d{2})$/;
+const WEEKLY_RE = /^@weekly\s+(mon|tue|wed|thu|fri|sat|sun)\s+(\d{1,2}):(\d{2})$/i;
+const UNIT_SECONDS = {
+    s: 1, m: 60, h: 3600, d: 86400,
+};
+const DOW_INDEX = {
+    sun: 0, mon: 1, tue: 2, wed: 3, thu: 4, fri: 5, sat: 6,
+};
+// Returns the next-run timestamp (unix seconds) for a recurrence, or
+// null for an unparseable format.
+export function computeNextRun(recurrence, nowSec) {
+    if (!recurrence)
+        return null;
+    const everyMatch = EVERY_RE.exec(recurrence);
+    if (everyMatch) {
+        const n = parseInt(everyMatch[1], 10);
+        const unit = everyMatch[2];
+        if (n <= 0)
+            return null;
+        return nowSec + n * (UNIT_SECONDS[unit] ?? 0);
+    }
+    const dailyMatch = DAILY_RE.exec(recurrence);
+    if (dailyMatch) {
+        return nextLocalHourMinute(nowSec, parseInt(dailyMatch[1], 10), parseInt(dailyMatch[2], 10), null);
+    }
+    const weeklyMatch = WEEKLY_RE.exec(recurrence);
+    if (weeklyMatch) {
+        const dow = DOW_INDEX[weeklyMatch[1].toLowerCase()];
+        return nextLocalHourMinute(nowSec, parseInt(weeklyMatch[2], 10), parseInt(weeklyMatch[3], 10), dow);
+    }
+    return null;
+}
+// Compute the next unix-seconds at HH:MM in the owner timezone,
+// optionally constrained to a day-of-week. Always returns a moment
+// strictly in the future (> nowSec).
+function nextLocalHourMinute(nowSec, hour, minute, dayOfWeek) {
+    const tz = config.owner.timezone;
+    const fmt = new Intl.DateTimeFormat('en-CA', {
+        timeZone: tz,
+        year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit',
+        weekday: 'short', hour12: false,
+    });
+    // Walk forward in 1-hour steps from now until we land on the right
+    // (day, dow) and the candidate moment is in the future. Cheaper than
+    // it sounds — at most 7*24 = 168 iterations.
+    for (let step = 0; step < 24 * 8; step++) {
+        const candidate = new Date((nowSec + step * 3600) * 1000);
+        const parts = fmt.formatToParts(candidate);
+        const get = (type) => parts.find((p) => p.type === type)?.value ?? '';
+        const cYear = parseInt(get('year'), 10);
+        const cMonth = parseInt(get('month'), 10) - 1;
+        const cDay = parseInt(get('day'), 10);
+        const wdName = get('weekday').toLowerCase();
+        const cDow = DOW_INDEX[wdName] ?? -1;
+        if (dayOfWeek !== null && cDow !== dayOfWeek)
+            continue;
+        // Build a UTC instant for HH:MM on (cYear,cMonth,cDay) in the tz.
+        // Easier path: format candidate at hour/minute and re-parse via
+        // the timezone-offset trick.
+        const candidateLocal = makeDateInTz(cYear, cMonth, cDay, hour, minute, tz);
+        if (candidateLocal > nowSec)
+            return candidateLocal;
+    }
+    // Fallback (shouldn't be reachable): an hour from now.
+    return nowSec + 3600;
+}
+// Build a unix-seconds for a given Y/M/D HH:MM in a named timezone.
+// Done by guess-and-correct: assume the input is UTC, see how the tz
+// renders that instant, take the delta, apply it.
+function makeDateInTz(year, month, day, hour, minute, tz) {
+    const guessUtcMs = Date.UTC(year, month, day, hour, minute, 0);
+    const fmt = new Intl.DateTimeFormat('en-US', {
+        timeZone: tz,
+        year: 'numeric', month: '2-digit', day: '2-digit',
+        hour: '2-digit', minute: '2-digit', second: '2-digit',
+        hour12: false,
+    });
+    const parts = fmt.formatToParts(new Date(guessUtcMs));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? '0';
+    const renderedUtcMs = Date.UTC(parseInt(get('year'), 10), parseInt(get('month'), 10) - 1, parseInt(get('day'), 10), parseInt(get('hour'), 10), parseInt(get('minute'), 10), parseInt(get('second'), 10));
+    const offsetMs = guessUtcMs - renderedUtcMs;
+    return Math.floor((guessUtcMs + offsetMs) / 1000);
+}

package/dist/queue/orchestrator.js

@@ -0,0 +1,175 @@
+// Bot-wide orchestrator. One process-wide instance. Polls every
+// ~500ms and does the cross-cutting work no single worker should
+// own:
+//   - Read control table → apply shutdown/pause/reload signals.
+//   - Reclaim stuck claims on outbound (and later: async, browser,
+//     memory_writes).
+//   - Mark dead workers (last_seen past threshold).
+//   - Poll the cron table → enqueue due jobs (Phase 2.2; not yet).
+//   - Log queue depths to a metrics buffer (Phase 7; not yet).
+//
+// Distinct from the sender worker: sender pulls from outbound and
+// sends. Orchestrator pulls signals and metadata; it dispatches but
+// doesn't do per-row work itself.
+import { hostname } from 'os';
+import { and, eq, lt, ne } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { workers } from '../db/schema.js';
+import { logger } from '../logger.js';
+import { reclaimStuckOutbound } from './outbound.js';
+import { clearControl, readControl, requestControl } from './control.js';
+import { listDueCrons, markCronFired } from './crons.js';
+import { dispatchCron } from './cron-dispatch.js';
+const TICK_INTERVAL_MS = 500;
+const HEARTBEAT_INTERVAL_MS = 5_000;
+const WORKER_DEAD_AFTER_SECONDS = 30;
+const SHUTDOWN_GRACE_MS = 30_000; // total drain window before force-exit
+let workerId = null;
+let stopping = false;
+let draining = false;
+let tickTimer = null;
+let heartbeatTimer = null;
+let exitHook = null;
+function newOrchestratorId() {
+    return `${hostname()}-${process.pid}-orchestrator-0`;
+}
+function registerSelf(id) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    db.insert(workers)
+        .values({
+        id,
+        kind: 'orchestrator',
+        status: 'idle',
+        currentJob: null,
+        lastSeen: now,
+        startedAt: now,
+    })
+        .onConflictDoUpdate({
+        target: workers.id,
+        set: { status: 'idle', currentJob: null, lastSeen: now, startedAt: now },
+    })
+        .run();
+}
+function heartbeat(id) {
+    const db = getDb();
+    db.update(workers)
+        .set({ lastSeen: Math.floor(Date.now() / 1000) })
+        .where(eq(workers.id, id))
+        .run();
+}
+// Mark workers as dead when their last_seen has aged past the
+// threshold. Used as a liveness signal in observability queries and
+// (eventually) to reclaim their claimed jobs across all queues.
+function markDeadWorkers() {
+    const db = getDb();
+    const cutoff = Math.floor(Date.now() / 1000) - WORKER_DEAD_AFTER_SECONDS;
+    const result = db
+        .update(workers)
+        .set({ status: 'dead' })
+        .where(and(lt(workers.lastSeen, cutoff), ne(workers.status, 'dead')))
+        .returning({ id: workers.id, kind: workers.kind })
+        .all();
+    for (const w of result) {
+        logger.warn({ id: w.id, kind: w.kind }, 'worker marked dead (no heartbeat)');
+    }
+    return result.length;
+}
+function busyWorkerCount() {
+    const db = getDb();
+    const row = db
+        .select({ id: workers.id })
+        .from(workers)
+        .where(eq(workers.status, 'busy'))
+        .all();
+    return row.length;
+}
+async function tick(id) {
+    try {
+        const ctl = readControl('shutdown');
+        if (ctl && !draining) {
+            logger.info({ requestedBy: ctl.requestedBy }, 'shutdown requested via control table');
+            draining = true;
+            // Mark ourselves draining so observability shows it.
+            const db = getDb();
+            db.update(workers)
+                .set({ status: 'draining' })
+                .where(eq(workers.id, id))
+                .run();
+        }
+        // Cross-queue housekeeping. More queues land in later phases.
+        const reclaimed = reclaimStuckOutbound();
+        if (reclaimed > 0) {
+            logger.info({ reclaimed }, 'reclaimed stuck outbound rows');
+        }
+        // Fire any due crons. Order: dispatch each in turn; if dispatch
+        // throws (it shouldn't — dispatch swallows), the cron is NOT
+        // marked fired and we'll retry on the next tick.
+        if (!draining) {
+            const due = listDueCrons();
+            for (const row of due) {
+                try {
+                    dispatchCron(row);
+                    markCronFired(row);
+                }
+                catch (err) {
+                    logger.error({ err, name: row.name }, 'cron dispatch crashed');
+                }
+            }
+        }
+        markDeadWorkers();
+        if (draining) {
+            const busy = busyWorkerCount();
+            if (busy === 0) {
+                logger.info('all workers idle, exiting cleanly');
+                clearControl('shutdown');
+                if (exitHook) {
+                    await exitHook();
+                }
+                process.exit(0);
+            }
+        }
+    }
+    catch (err) {
+        logger.error({ err }, 'orchestrator tick error');
+    }
+}
+export function startOrchestrator(opts = {}) {
+    if (workerId) {
+        logger.warn('orchestrator already started; ignoring');
+        return;
+    }
+    workerId = newOrchestratorId();
+    exitHook = opts.onShutdownDrained ?? null;
+    registerSelf(workerId);
+    heartbeatTimer = setInterval(() => workerId && heartbeat(workerId), HEARTBEAT_INTERVAL_MS);
+    const id = workerId;
+    tickTimer = setInterval(() => {
+        void tick(id);
+    }, TICK_INTERVAL_MS);
+    logger.info({ workerId }, 'orchestrator started');
+}
+export function stopOrchestrator() {
+    stopping = true;
+    if (tickTimer)
+        clearInterval(tickTimer);
+    if (heartbeatTimer)
+        clearInterval(heartbeatTimer);
+}
+// Public entry point for "begin graceful shutdown." Inserts the
+// control row + sets a force-exit timer so we don't hang forever if
+// some worker refuses to drain.
+export function requestShutdown(by) {
+    if (draining)
+        return;
+    requestControl('shutdown', 'requested', by);
+    setTimeout(() => {
+        if (!stopping) {
+            logger.warn({ graceMs: SHUTDOWN_GRACE_MS }, 'graceful shutdown timed out, forcing exit');
+            process.exit(1);
+        }
+    }, SHUTDOWN_GRACE_MS).unref();
+}
+export function isDraining() {
+    return draining;
+}

package/migrations/0002_phase2_crons.sql

@@ -0,0 +1,14 @@
+CREATE TABLE `crons` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`name` text NOT NULL,
+	`enqueue_into` text NOT NULL,
+	`payload` text NOT NULL,
+	`recurrence` text,
+	`next_run_at` integer NOT NULL,
+	`last_run_at` integer,
+	`enabled` integer DEFAULT 1 NOT NULL,
+	`created_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `crons_by_due` ON `crons` (`enabled`,`next_run_at`);--> statement-breakpoint
+CREATE UNIQUE INDEX `crons_name_uq` ON `crons` (`name`) WHERE "crons"."recurrence" IS NOT NULL;

package/migrations/meta/0002_snapshot.json

@@ -0,0 +1,468 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "417b2708-624e-416f-af59-bee5d5e38556",
+  "prevId": "56b9231e-919c-4b8d-9a77-68735c33cbb0",
+  "tables": {
+    "control": {
+      "name": "control",
+      "columns": {
+        "key": {
+          "name": "key",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "value": {
+          "name": "value",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "requested_by": {
+          "name": "requested_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "requested_at": {
+          "name": "requested_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "crons": {
+      "name": "crons",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "name": {
+          "name": "name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "enqueue_into": {
+          "name": "enqueue_into",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "payload": {
+          "name": "payload",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "recurrence": {
+          "name": "recurrence",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "next_run_at": {
+          "name": "next_run_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_run_at": {
+          "name": "last_run_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "enabled": {
+          "name": "enabled",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 1
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "crons_by_due": {
+          "name": "crons_by_due",
+          "columns": [
+            "enabled",
+            "next_run_at"
+          ],
+          "isUnique": false
+        },
+        "crons_name_uq": {
+          "name": "crons_name_uq",
+          "columns": [
+            "name"
+          ],
+          "isUnique": true,
+          "where": "\"crons\".\"recurrence\" IS NOT NULL"
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "identities": {
+      "name": "identities",
+      "columns": {
+        "person_id": {
+          "name": "person_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "address": {
+          "name": "address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "added_at": {
+          "name": "added_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "identities_address_unique": {
+          "name": "identities_address_unique",
+          "columns": [
+            "address"
+          ],
+          "isUnique": true
+        }
+      },
+      "foreignKeys": {
+        "identities_person_id_persons_id_fk": {
+          "name": "identities_person_id_persons_id_fk",
+          "tableFrom": "identities",
+          "tableTo": "persons",
+          "columnsFrom": [
+            "person_id"
+          ],
+          "columnsTo": [
+            "id"
+          ],
+          "onDelete": "no action",
+          "onUpdate": "no action"
+        }
+      },
+      "compositePrimaryKeys": {
+        "identities_person_id_address_pk": {
+          "columns": [
+            "person_id",
+            "address"
+          ],
+          "name": "identities_person_id_address_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "outbound": {
+      "name": "outbound",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "address": {
+          "name": "address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "media_path": {
+          "name": "media_path",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "media_mime": {
+          "name": "media_mime",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "media_bytes": {
+          "name": "media_bytes",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "quote_msg_id": {
+          "name": "quote_msg_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "idempotency_key": {
+          "name": "idempotency_key",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "attempts": {
+          "name": "attempts",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        },
+        "next_attempt_at": {
+          "name": "next_attempt_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_error": {
+          "name": "last_error",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "claimed_by": {
+          "name": "claimed_by",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "claimed_at": {
+          "name": "claimed_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "updated_at": {
+          "name": "updated_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "outbound_by_status_next": {
+          "name": "outbound_by_status_next",
+          "columns": [
+            "status",
+            "next_attempt_at"
+          ],
+          "isUnique": false
+        },
+        "outbound_by_address": {
+          "name": "outbound_by_address",
+          "columns": [
+            "address"
+          ],
+          "isUnique": false
+        },
+        "outbound_idempotency_key_uq": {
+          "name": "outbound_idempotency_key_uq",
+          "columns": [
+            "idempotency_key"
+          ],
+          "isUnique": true,
+          "where": "\"outbound\".\"idempotency_key\" IS NOT NULL"
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "persons": {
+      "name": "persons",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "display_name": {
+          "name": "display_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "timezone": {
+          "name": "timezone",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "created_at": {
+          "name": "created_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "workers": {
+      "name": "workers",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "kind": {
+          "name": "kind",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "status": {
+          "name": "status",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "current_job": {
+          "name": "current_job",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "workers_by_kind_status": {
+          "name": "workers_by_kind_status",
+          "columns": [
+            "kind",
+            "status"
+          ],
+          "isUnique": false
+        },
+        "workers_by_last_seen": {
+          "name": "workers_by_last_seen",
+          "columns": [
+            "last_seen"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/migrations/meta/_journal.json

@@ -15,6 +15,13 @@
       "when": 1779669712372,
       "tag": "0001_phase1_outbound",
       "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1779671387894,
+      "tag": "0002_phase2_crons",
+      "breakpoints": true
     }
   ]
 }

package/package.json

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