@c4t4/heyamigo 0.9.3 → 0.9.5

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/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

@@ -0,0 +1,82 @@
+// 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 { getInternalCronHandler } from './cron-handlers.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 'internal':
+            dispatchInternal(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 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');
+        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/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/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

@@ -18,6 +18,8 @@ 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;
@@ -100,6 +102,21 @@ async function tick(id) {
         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();

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.3",
+  "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",