@c4t4/heyamigo 0.9.4 → 0.9.6

package/dist/db/schema.js

@@ -128,3 +128,54 @@ export const crons = sqliteTable('crons', {
         .on(t.name)
         .where(sql `${t.recurrence} IS NOT NULL`),
 }));
+// ──────────────────────────────────────────────────────────────────
+// Inbound queue (Phase 4)
+// ──────────────────────────────────────────────────────────────────
+// Messages received on any channel, waiting to be processed by a
+// chat worker. The chat worker pool claims rows with per-address
+// serialization (one in-flight job per chat preserves reply order),
+// runs the AI provider, and enqueues outbound rows with the reply.
+//
+// `address` is the chat-level address (a group's address, or a DM's
+// address). `actor_address` is the within-chat sender — for DMs it
+// equals `address`; for groups it identifies which member sent the
+// message. `person_id` and `actor_person_id` are the resolved
+// person identities (nullable when resolution fails, e.g. an unknown
+// member of a group).
+//
+// Idempotency: external_msg_id (channel-native message id, e.g.
+// Baileys message key id). The same channel message arriving twice
+// (network retransmit, replay on reconnect) maps to one row.
+export const inbound = sqliteTable('inbound', {
+    id: integer('id').primaryKey({ autoIncrement: true }),
+    address: text('address').notNull(), // chat-level address
+    actorAddress: text('actor_address'), // sender within chat; null = self/system
+    personId: text('person_id'), // resolved chat owner (DM partner / group)
+    actorPersonId: text('actor_person_id'), // resolved sender
+    externalMsgId: text('external_msg_id'), // channel-native msg id (idempotency)
+    text: text('text').notNull(), // body or media tag
+    mediaPath: text('media_path'), // path relative to storage/ when media
+    mediaMime: text('media_mime'),
+    mediaBytes: integer('media_bytes'),
+    pushName: text('push_name'), // sender's display name at send time
+    triggerReason: text('trigger_reason'), // 'alias'|'mention'|'reply'|'owner'|...
+    // 'pending'|'claimed'|'done'|'failed'|'dlq'
+    status: text('status').notNull(),
+    attempts: integer('attempts').notNull().default(0),
+    nextAttemptAt: integer('next_attempt_at'),
+    lastError: text('last_error'),
+    claimedBy: text('claimed_by'),
+    claimedAt: integer('claimed_at'),
+    receivedAt: integer('received_at').notNull(), // unix sec when WA delivered
+    createdAt: integer('created_at').notNull(), // unix sec when row inserted
+    updatedAt: integer('updated_at').notNull(),
+}, t => ({
+    byStatusNext: index('inbound_by_status_next').on(t.status, t.nextAttemptAt),
+    byAddress: index('inbound_by_address').on(t.address),
+    byPerson: index('inbound_by_person').on(t.personId, t.receivedAt),
+    // Sparse unique on external_msg_id: enforced only when set. Same
+    // pattern as outbound's idempotency_key.
+    uniqExtId: uniqueIndex('inbound_external_msg_id_uq')
+        .on(t.externalMsgId)
+        .where(sql `${t.externalMsgId} 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

@@ -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/dist/queue/inbound.js

@@ -0,0 +1,190 @@
+// Inbound queue helpers. Gateway (gateway/incoming.ts) calls
+// enqueueInbound; chat workers (queue/chat-worker.ts) drain via
+// claimNextInbound. Per-address serialization preserves reply order
+// within a chat while different chats run in parallel.
+//
+// Same primitives as outbound (claim/done/retry/dlq) with the added
+// `address NOT IN (claimed)` filter in the claim query.
+import { and, asc, eq, isNull, lte, notInArray, or, sql } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { inbound } from '../db/schema.js';
+// Idempotent on external_msg_id when set. Same channel message
+// arriving twice (Baileys replay, network retransmit) returns the
+// existing row instead of duplicating.
+export function enqueueInbound(input) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    if (input.externalMsgId) {
+        const found = db
+            .select()
+            .from(inbound)
+            .where(eq(inbound.externalMsgId, input.externalMsgId))
+            .get();
+        if (found)
+            return { inserted: false, row: found };
+    }
+    const row = db
+        .insert(inbound)
+        .values({
+        address: input.address,
+        actorAddress: input.actorAddress ?? null,
+        personId: input.personId ?? null,
+        actorPersonId: input.actorPersonId ?? null,
+        externalMsgId: input.externalMsgId ?? null,
+        text: input.text,
+        mediaPath: input.mediaPath ?? null,
+        mediaMime: input.mediaMime ?? null,
+        mediaBytes: input.mediaBytes ?? null,
+        pushName: input.pushName ?? null,
+        triggerReason: input.triggerReason ?? null,
+        status: 'pending',
+        attempts: 0,
+        nextAttemptAt: null,
+        lastError: null,
+        claimedBy: null,
+        claimedAt: null,
+        receivedAt: input.receivedAt ?? now,
+        createdAt: now,
+        updatedAt: now,
+    })
+        .returning()
+        .get();
+    return { inserted: true, row };
+}
+// Atomic claim with per-address serialization. Skips any pending row
+// whose address already has another row in `claimed` state →
+// preserves reply order per chat while letting different chats run
+// in parallel.
+export function claimNextInbound(workerId) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    return db.transaction((tx) => {
+        // Subquery: addresses currently claimed (= one in-flight per chat).
+        const busyAddrs = tx
+            .select({ address: inbound.address })
+            .from(inbound)
+            .where(eq(inbound.status, 'claimed'))
+            .all()
+            .map((r) => r.address);
+        const conds = [
+            eq(inbound.status, 'pending'),
+            or(isNull(inbound.nextAttemptAt), lte(inbound.nextAttemptAt, now)),
+        ];
+        if (busyAddrs.length > 0) {
+            conds.push(notInArray(inbound.address, busyAddrs));
+        }
+        const target = tx
+            .select({ id: inbound.id })
+            .from(inbound)
+            .where(and(...conds))
+            .orderBy(asc(inbound.id))
+            .limit(1)
+            .get();
+        if (!target)
+            return null;
+        const claimed = tx
+            .update(inbound)
+            .set({
+            status: 'claimed',
+            claimedBy: workerId,
+            claimedAt: now,
+            updatedAt: now,
+        })
+            .where(and(eq(inbound.id, target.id), eq(inbound.status, 'pending')))
+            .returning()
+            .get();
+        return claimed ?? null;
+    });
+}
+export function markInboundDone(id, workerId) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const result = db
+        .update(inbound)
+        .set({ status: 'done', updatedAt: now })
+        .where(and(eq(inbound.id, id), eq(inbound.status, 'claimed'), eq(inbound.claimedBy, workerId)))
+        .returning({ id: inbound.id })
+        .all();
+    return result.length > 0;
+}
+// Backoff: 5s, 30s, 2min, 5min, give up. Bigger gaps than outbound
+// because chat replies are expensive (AI call); a faster retry loop
+// would just burn tokens on transient errors.
+const BACKOFF_SECONDS = [5, 30, 120, 300];
+const MAX_ATTEMPTS = BACKOFF_SECONDS.length;
+export function markInboundRetryOrDlq(id, workerId, errorMessage) {
+    const db = getDb();
+    return db.transaction((tx) => {
+        const row = tx.select().from(inbound).where(eq(inbound.id, id)).get();
+        if (!row || row.status !== 'claimed' || row.claimedBy !== workerId) {
+            return { retried: false, deadLettered: false };
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const nextAttempts = row.attempts + 1;
+        if (nextAttempts > MAX_ATTEMPTS) {
+            tx.update(inbound)
+                .set({
+                status: 'dlq',
+                attempts: nextAttempts,
+                lastError: errorMessage,
+                claimedBy: null,
+                claimedAt: null,
+                updatedAt: now,
+            })
+                .where(eq(inbound.id, id))
+                .run();
+            return { retried: false, deadLettered: true };
+        }
+        const backoff = BACKOFF_SECONDS[Math.min(row.attempts, BACKOFF_SECONDS.length - 1)];
+        tx.update(inbound)
+            .set({
+            status: 'pending',
+            attempts: nextAttempts,
+            nextAttemptAt: now + backoff,
+            lastError: errorMessage,
+            claimedBy: null,
+            claimedAt: null,
+            updatedAt: now,
+        })
+            .where(eq(inbound.id, id))
+            .run();
+        return { retried: true, deadLettered: false };
+    });
+}
+export function markInboundFailed(id, workerId, errorMessage) {
+    const db = getDb();
+    const now = Math.floor(Date.now() / 1000);
+    const result = db
+        .update(inbound)
+        .set({
+        status: 'failed',
+        lastError: errorMessage,
+        claimedBy: null,
+        claimedAt: null,
+        updatedAt: now,
+    })
+        .where(and(eq(inbound.id, id), eq(inbound.status, 'claimed'), eq(inbound.claimedBy, workerId)))
+        .returning({ id: inbound.id })
+        .all();
+    return result.length > 0;
+}
+// Orchestrator helper. Chat workers run longer than sender workers
+// (AI calls + memory writes), so the TTL is more generous. 300s
+// matches the typical chat-track timeout (5min).
+const CLAIM_TTL_SECONDS = 360;
+export function reclaimStuckInbound() {
+    const db = getDb();
+    const cutoff = Math.floor(Date.now() / 1000) - CLAIM_TTL_SECONDS;
+    const result = db
+        .update(inbound)
+        .set({
+        status: 'pending',
+        claimedBy: null,
+        claimedAt: null,
+        updatedAt: sql `${inbound.updatedAt}`,
+    })
+        .where(and(eq(inbound.status, 'claimed'), lte(inbound.claimedAt, cutoff)))
+        .returning({ id: inbound.id })
+        .all();
+    return result.length;
+}

package/dist/queue/orchestrator.js

@@ -16,6 +16,7 @@ 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 { reclaimStuckInbound } from './inbound.js';
 import { reclaimStuckOutbound } from './outbound.js';
 import { clearControl, readControl, requestControl } from './control.js';
 import { listDueCrons, markCronFired } from './crons.js';
@@ -98,9 +99,13 @@ async function tick(id) {
                 .run();
         }
         // Cross-queue housekeeping. More queues land in later phases.
-        const reclaimed = reclaimStuckOutbound();
-        if (reclaimed > 0) {
-            logger.info({ reclaimed }, 'reclaimed stuck outbound rows');
+        const reclaimedOutbound = reclaimStuckOutbound();
+        if (reclaimedOutbound > 0) {
+            logger.info({ reclaimed: reclaimedOutbound }, 'reclaimed stuck outbound rows');
+        }
+        const reclaimedInbound = reclaimStuckInbound();
+        if (reclaimedInbound > 0) {
+            logger.info({ reclaimed: reclaimedInbound }, 'reclaimed stuck inbound rows');
         }
         // Fire any due crons. Order: dispatch each in turn; if dispatch
         // throws (it shouldn't — dispatch swallows), the cron is NOT

package/migrations/0003_phase4_inbound.sql

@@ -0,0 +1,28 @@
+CREATE TABLE `inbound` (
+	`id` integer PRIMARY KEY AUTOINCREMENT NOT NULL,
+	`address` text NOT NULL,
+	`actor_address` text,
+	`person_id` text,
+	`actor_person_id` text,
+	`external_msg_id` text,
+	`text` text NOT NULL,
+	`media_path` text,
+	`media_mime` text,
+	`media_bytes` integer,
+	`push_name` text,
+	`trigger_reason` text,
+	`status` text NOT NULL,
+	`attempts` integer DEFAULT 0 NOT NULL,
+	`next_attempt_at` integer,
+	`last_error` text,
+	`claimed_by` text,
+	`claimed_at` integer,
+	`received_at` integer NOT NULL,
+	`created_at` integer NOT NULL,
+	`updated_at` integer NOT NULL
+);
+--> statement-breakpoint
+CREATE INDEX `inbound_by_status_next` ON `inbound` (`status`,`next_attempt_at`);--> statement-breakpoint
+CREATE INDEX `inbound_by_address` ON `inbound` (`address`);--> statement-breakpoint
+CREATE INDEX `inbound_by_person` ON `inbound` (`person_id`,`received_at`);--> statement-breakpoint
+CREATE UNIQUE INDEX `inbound_external_msg_id_uq` ON `inbound` (`external_msg_id`) WHERE "inbound"."external_msg_id" IS NOT NULL;

package/migrations/meta/0003_snapshot.json

@@ -0,0 +1,658 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "155b0aa7-93ec-4d7a-a853-e680b47d162c",
+  "prevId": "417b2708-624e-416f-af59-bee5d5e38556",
+  "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": {}
+    },
+    "inbound": {
+      "name": "inbound",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "address": {
+          "name": "address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor_address": {
+          "name": "actor_address",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "person_id": {
+          "name": "person_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "actor_person_id": {
+          "name": "actor_person_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "external_msg_id": {
+          "name": "external_msg_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "text": {
+          "name": "text",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "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
+        },
+        "push_name": {
+          "name": "push_name",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "trigger_reason": {
+          "name": "trigger_reason",
+          "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
+        },
+        "received_at": {
+          "name": "received_at",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "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": {
+        "inbound_by_status_next": {
+          "name": "inbound_by_status_next",
+          "columns": [
+            "status",
+            "next_attempt_at"
+          ],
+          "isUnique": false
+        },
+        "inbound_by_address": {
+          "name": "inbound_by_address",
+          "columns": [
+            "address"
+          ],
+          "isUnique": false
+        },
+        "inbound_by_person": {
+          "name": "inbound_by_person",
+          "columns": [
+            "person_id",
+            "received_at"
+          ],
+          "isUnique": false
+        },
+        "inbound_external_msg_id_uq": {
+          "name": "inbound_external_msg_id_uq",
+          "columns": [
+            "external_msg_id"
+          ],
+          "isUnique": true,
+          "where": "\"inbound\".\"external_msg_id\" IS NOT NULL"
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "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

@@ -22,6 +22,13 @@
       "when": 1779671387894,
       "tag": "0002_phase2_crons",
       "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1779672156371,
+      "tag": "0003_phase4_inbound",
+      "breakpoints": true
     }
   ]
 }

package/package.json

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