@c4t4/heyamigo 0.9.19 → 0.9.21

package/config/memory-instructions.md

@@ -227,3 +227,64 @@ A shared Chrome runs on the server at `localhost:9222` with the owner's real ses
 **Never call `browser_*` / `mcp__*playwright*` tools inline.** All browser work goes via `[ASYNC-BROWSER:...]`. See the two-track section above.
 
 To send a screenshot back: the browser worker takes it (saving to `storage/outbox/`), then includes `[IMAGE: /absolute/path.png]` in its result message.
+
+## Scheduling: reminders and recurring crons
+
+The bot has a built-in scheduler. When the user asks for any future or recurring action, you MUST emit a marker at the END of your reply — saying "I'll remind you" without a marker creates no schedule and the user gets nothing.
+
+The current local time is shown at the top of every chat preamble in the SENDER's timezone. Use it when interpreting "at 10:30am" / "tomorrow morning" / etc.
+
+### One-shot reminders — `[REMIND: <time> — <text>]`
+
+Time forms (case-insensitive):
+
+| Form | Example | Meaning |
+|---|---|---|
+| `in N<unit>` | `in 30m` / `in 2h` / `in 3d` | Units: `s`, `m`, `h`, `d`. Also accepts the word forms: `in 30 minutes`. |
+| `at HH(:MM)?[am\|pm]` | `at 10:30am` / `at 14:00` | TODAY at the user's local time. If already past, rolls to tomorrow. |
+| `tomorrow at HH:MM` | `tomorrow at 9am` | Tomorrow at the user's local time. |
+| `<weekday> at HH:MM` | `mon at 9am` / `friday at 18:00` | Next occurrence of that weekday. |
+| `YYYY-MM-DD HH:MM` | `2026-12-25 09:00` | Specific date, user's local time. |
+
+The `<text>` is what the user will receive at fire time.
+
+Examples:
+```
+[REMIND: in 30m — take the chicken out of the oven]
+[REMIND: at 10:30am — call mom]
+[REMIND: tomorrow at 9am — gym]
+[REMIND: mon at 9am — weekly planning]
+```
+
+### Recurring crons — `[CRON: <recurrence> — <text>]`
+
+Recurrence forms:
+
+| Form | Example | Meaning |
+|---|---|---|
+| `@every N<unit>` | `@every 1h` / `@every 5m` | Fires repeatedly at that interval. |
+| `@daily HH:MM` | `@daily 09:00` | Every day at that user-local time (24h format). |
+| `@weekly <DOW> HH:MM` | `@weekly mon 09:00` | Every week on that weekday at that time. |
+
+Examples:
+```
+[CRON: @daily 09:00 — morning check-in: what's the focus today?]
+[CRON: @weekly sun 18:00 — weekly review: what worked, what didn't]
+[CRON: @every 2h — hydration reminder]
+```
+
+### Cross-chat send — `[SEND-TEXT: ...]`
+
+Send a text to a DIFFERENT chat than the one you're responding in. Rare; usually owner-only.
+
+```
+[SEND-TEXT: address=wa:dm:5491234567890@s.whatsapp.net body="heads up: just posted"]
+```
+
+### Rules
+
+- Acknowledge the schedule in your CHAT REPLY ("got it, reminding you at 10:30") so the user has immediate feedback. The marker is the side effect; the text is what they see right now.
+- ONE marker per scheduled item. Multiple markers in one reply OK.
+- Times are always in the **sender's timezone**, never the server's. The preamble shows the current local time so you can compute deltas if needed.
+- If parsing fails (malformed marker), the bot logs a warning and the schedule is dropped silently. Stick to the grammars above.
+- To cancel a scheduled item, the user types `/reminders` or `/crons` to see what's pending, then deletes via chat command.

package/dist/db/identity-sync.js

@@ -133,7 +133,7 @@ export function syncIdentitiesFromAccess() {
     logger.info({ personsUpserted, identitiesUpserted, seeded: seeds.length }, 'identity sync from access.json complete');
     return { personsUpserted, identitiesUpserted };
 }
-// Lookup helper used by the inbound resolution step (in later phases).
+// Lookup helper used by the inbound resolution step.
 // Returns null if the address has no matching person — caller decides
 // whether to auto-create or treat as stranger.
 export function personIdForAddress(address) {
@@ -145,3 +145,35 @@ export function personIdForAddress(address) {
         .get();
     return row?.personId ?? null;
 }
+// Timezone for a person, falling back to owner timezone when unknown.
+// Used by scheduling code (REMIND/CRON) so absolute times like "at
+// 10:30am" land in the SENDER's local time, not the server's.
+export function getTimezoneForPerson(personId) {
+    if (!personId)
+        return config.owner.timezone;
+    const db = getDb();
+    const row = db
+        .select({ tz: persons.timezone })
+        .from(persons)
+        .where(eq(persons.id, personId))
+        .get();
+    return row?.tz ?? config.owner.timezone;
+}
+// Convenience: resolve sender's address → person → timezone.
+// Address can be a WA jid or a wa:dm:... formatted address.
+export function getTimezoneForAddress(address) {
+    const pid = personIdForAddress(address);
+    return getTimezoneForPerson(pid);
+}
+// Sender-number → tz (handles the senderNumber field on Job/inbound
+// rows). Builds the wa:dm: address shape internally so we don't have
+// to duplicate the format-from-number logic at every call site.
+export function getTimezoneForSenderNumber(senderNumber) {
+    if (!senderNumber)
+        return config.owner.timezone;
+    const sanitized = senderNumber.replace(/\D/g, '');
+    if (!sanitized)
+        return config.owner.timezone;
+    const address = formatAddress(jidToAddress(`${sanitized}@s.whatsapp.net`));
+    return getTimezoneForAddress(address);
+}

package/dist/db/schema.js

@@ -115,6 +115,10 @@ export const crons = sqliteTable('crons', {
     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
+    // IANA timezone for resolving @daily HH:MM / @weekly DOW HH:MM
+    // recurrences. Set to the sender's local tz when an agent emits a
+    // [CRON:] tag; nullable for system crons that prefer owner tz.
+    timezone: text('timezone'),
     nextRunAt: integer('next_run_at').notNull(),
     lastRunAt: integer('last_run_at'),
     enabled: integer('enabled').notNull().default(1), // SQLite bool = int

package/dist/estimates/async-task.js

@@ -0,0 +1,29 @@
+// Generic async-task estimator (non-browser background work).
+//
+// The general async lane is still on in-memory fastq (no durable
+// table). Real duration samples aren't queryable yet → the estimate
+// uses defaultMs every time until/unless that lane gets migrated to
+// SQLite. Cards still surface useful "long task incoming" UX.
+import { aggregateMean, humanDur, registerEstimator, } from './registry.js';
+class AsyncTaskEstimator {
+    kind = 'async-task';
+    // 3 min — generic background work tends to be moderate. A deeper
+    // research task might run longer; a quick one shorter. Single
+    // ballpark until we have real samples.
+    defaultMs = 3 * 60 * 1000;
+    matches(ctx) {
+        return ctx.taskKind === 'async';
+    }
+    // No durable samples (general async lane is still in-memory fastq).
+    // Returning [] forces aggregateMean to fall back to defaultMs.
+    querySamples() {
+        return [];
+    }
+    estimate(samples) {
+        return aggregateMean(samples, this.defaultMs);
+    }
+    format(estimate) {
+        return `background task, ~${humanDur(estimate.pointMs)}`;
+    }
+}
+registerEstimator(new AsyncTaskEstimator());

package/dist/estimates/browser-task.js

@@ -0,0 +1,49 @@
+// Generic browser-task estimator. Matches any agent-delegated
+// [ASYNC-BROWSER:] task. Pulls duration samples from the durable
+// browser_tasks table so the average reflects real observed runtimes.
+import { and, desc, eq, isNotNull } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { browserTasks } from '../db/schema.js';
+import { aggregateMean, humanDur, registerEstimator, } from './registry.js';
+class BrowserTaskEstimator {
+    kind = 'browser-task';
+    // 5 min is a reasonable ballpark for IG/TT scrapes. Real samples
+    // dominate after the first 1-2 jobs.
+    defaultMs = 5 * 60 * 1000;
+    matches(ctx) {
+        return ctx.taskKind === 'async-browser';
+    }
+    querySamples(limit = 20) {
+        const db = getDb();
+        // All done browser tasks — single bucket. Could be sliced further
+        // (per-domain) later via more-specific estimators registered ahead
+        // of this catch-all.
+        const rows = db
+            .select({
+            claimedAt: browserTasks.claimedAt,
+            updatedAt: browserTasks.updatedAt,
+        })
+            .from(browserTasks)
+            .where(and(eq(browserTasks.status, 'done'), isNotNull(browserTasks.claimedAt)))
+            .orderBy(desc(browserTasks.id))
+            .limit(limit)
+            .all();
+        return rows
+            .filter((r) => r.claimedAt !== null)
+            .map((r) => ({
+            durationMs: (r.updatedAt - r.claimedAt) * 1000,
+            finishedAt: r.updatedAt,
+        }))
+            .filter((s) => s.durationMs > 0);
+    }
+    estimate(samples) {
+        return aggregateMean(samples, this.defaultMs);
+    }
+    format(estimate) {
+        if (estimate.rangeMs) {
+            return `browser task, ~${humanDur(estimate.rangeMs.lowMs)} to ~${humanDur(estimate.rangeMs.highMs)}`;
+        }
+        return `browser task, ~${humanDur(estimate.pointMs)}`;
+    }
+}
+registerEstimator(new BrowserTaskEstimator());

package/dist/estimates/image-gen.js

@@ -15,6 +15,13 @@ class ImageGenEstimator {
     // observations.
     defaultMs = 30_000;
     matches(ctx) {
+        // Only match direct user input. When taskKind is set, the context
+        // is an agent-delegated task — those go through the browser/async
+        // estimators below, not here. Prevents an agent's
+        // "[ASYNC-BROWSER: generate marketing image of X]" from being
+        // mis-classified as a user-typed image-gen request.
+        if (ctx.taskKind)
+            return false;
         return IMAGE_GEN_RE.test(ctx.description);
     }
     estimate(samples) {

package/dist/estimates/index.js

@@ -6,7 +6,13 @@
 //
 // Adding a new kind = drop a file alongside image-gen.ts and import
 // it below. No other code in the codebase needs to change.
+// Order matters: more-specific estimators register first so they win
+// classify() over the catch-all task estimators. image-gen and other
+// user-input matchers can run first because they explicitly DON'T
+// match when ctx.taskKind is set.
 import './image-gen.js';
-// future: import './browser-ig.js'
+import './browser-task.js'; // catches all [ASYNC-BROWSER:] tasks
+import './async-task.js'; // catches all [ASYNC:] tasks
+// future: import './browser-ig.js'   // more specific than browser-task
 // future: import './voice-gen.js'
 export { classify, estimate, formatEstimateDefault, humanDur, listEstimators, querySamplesForKind, registerEstimator, } from './registry.js';

package/dist/estimates/registry.js

@@ -61,7 +61,10 @@ export function estimate(ctx) {
     const e = classify(ctx);
     if (!e)
         return null;
-    const samples = querySamplesForKind(e.kind);
+    // Estimator's own querySamples (if provided) takes precedence —
+    // browser/async estimators pull from their dedicated tables. Otherwise
+    // fall back to the inbound-by-kind default.
+    const samples = e.querySamples ? e.querySamples() : querySamplesForKind(e.kind);
     const result = e.estimate(samples);
     const text = (e.format ?? formatEstimateDefault)(result);
     return { kind: e.kind, result, text };

package/dist/gateway/commands.js

@@ -68,5 +68,16 @@ export async function tryCommand(ctx) {
         await sendText(ctx.sock, ctx.jid, formatQueuesSnapshot(snap), ctx.quoted);
         return true;
     }
+    if (cmd === 'reminders' || cmd === 'crons') {
+        const { listChatSchedules, formatScheduleList } = await import('../queue/schedule-list.js');
+        const { formatAddress, jidToAddress } = await import('../db/address.js');
+        const { getTimezoneForSenderNumber } = await import('../db/identity-sync.js');
+        const chatAddress = formatAddress(jidToAddress(ctx.jid));
+        const tz = getTimezoneForSenderNumber(ctx.senderNumber);
+        const onlyKind = cmd === 'reminders' ? 'one-shot' : 'recurring';
+        const items = listChatSchedules(chatAddress, onlyKind);
+        await sendText(ctx.sock, ctx.jid, formatScheduleList(items, tz, onlyKind), ctx.quoted);
+        return true;
+    }
     return false;
 }

package/dist/gateway/outgoing.js

@@ -108,7 +108,25 @@ export async function handleReply(job, result, _originalMsg) {
             enqueuePiece({ address, kind: 'text', text: chunkForSend });
         }
     }
-    logger.info({ jid: job.jid, files: files.length, chars: text.length, pieces: pieceIdx }, 'reply enqueued for outbound');
+    // Job cards (ETAs for delegated async/browser tasks) go LAST so
+    // they arrive after the agent's reply chunks in chat. Each card
+    // has its own producer-supplied idempotencyKey; we don't slot them
+    // into the piece-numbered key space.
+    for (const card of result.jobCards ?? []) {
+        enqueueOutbound({
+            address,
+            kind: 'text',
+            text: card.text,
+            idempotencyKey: card.idempotencyKey,
+        });
+    }
+    logger.info({
+        jid: job.jid,
+        files: files.length,
+        chars: text.length,
+        pieces: pieceIdx,
+        cards: result.jobCards?.length ?? 0,
+    }, 'reply enqueued for outbound');
 }
 // Proactive outbound: send a message to a chat without an incoming
 // trigger. Same parsing as handleReply; enqueues outbound rows.

package/dist/memory/digest-flag.js

@@ -8,6 +8,8 @@
 // drops it entirely. That bug leaked two real markers into user-facing
 // replies today (DIGEST ~morning, ASYNC later). This parser closes that
 // whole class of failure.
+import { logger } from '../logger.js';
+import { parseTimeExpression } from '../queue/time-expr.js';
 const KINDS = [
     'DIGEST',
     'JOURNAL',
@@ -115,16 +117,22 @@ export function extractFlags(reply) {
             const parsed = parseSendTextPayload(payload);
             if (parsed)
                 sendTexts.unshift(parsed);
+            else
+                logger.warn({ payload }, 'SEND-TEXT tag dropped: unparseable payload');
         }
         else if (kind === 'CRON') {
             const parsed = parseCronPayload(payload);
             if (parsed)
                 crons.unshift(parsed);
+            else
+                logger.warn({ payload }, 'CRON tag dropped: unparseable payload');
         }
         else if (kind === 'REMIND') {
             const parsed = parseRemindPayload(payload);
             if (parsed)
                 reminds.unshift(parsed);
+            else
+                logger.warn({ payload }, 'REMIND tag dropped: unparseable payload');
         }
     }
     return {
@@ -178,7 +186,10 @@ function parseCronPayload(payload) {
         return null;
     return { recurrence, body };
 }
-// Parse `in <n><unit> — <body>` payload. Supported units: s,m,h,d.
+// Parse `<time-spec> — <body>` payload. Time spec is anything the
+// TimeExpression parser accepts: `in 30m`, `at 10:30am`, `tomorrow
+// at 9am`, `mon at 9am`, `YYYY-MM-DD HH:MM`. Resolution happens
+// later in the worker using the sender's timezone.
 function parseRemindPayload(payload) {
     const sepMatch = payload.match(/\s+[—–-]\s+/);
     if (!sepMatch || sepMatch.index === undefined)
@@ -187,15 +198,10 @@ function parseRemindPayload(payload) {
     const body = payload.slice(sepMatch.index + sepMatch[0].length).trim();
     if (!timeSpec || !body)
         return null;
-    const m = timeSpec.match(/^in\s+(\d+)\s*([smhd])$/i);
-    if (!m)
+    const when = parseTimeExpression(timeSpec);
+    if (!when)
         return null;
-    const n = parseInt(m[1], 10);
-    const unit = m[2].toLowerCase();
-    const mult = unit === 's' ? 1 : unit === 'm' ? 60 : unit === 'h' ? 3600 : 86400;
-    if (n <= 0)
-        return null;
-    return { whenSecondsFromNow: n * mult, body };
+    return { when, body };
 }
 // Parse `address=<addr> body="..."` style key=value payload.
 // Body is delimited by double quotes; everything else by whitespace.

package/dist/memory/preamble.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
 import { config } from '../config.js';
+import { getTimezoneForSenderNumber } from '../db/identity-sync.js';
 import { listAsyncTasks } from '../queue/async-tasks.js';
 import { readCompressed } from './compressed.js';
 import { buildJournalsPreambleBlock, ensureJournalsScaffold, } from './journals.js';
@@ -11,6 +12,36 @@ import { getRoleForContext } from '../wa/whitelist.js';
 const DIGEST_REMINDER = `When something worth remembering happens (new preference, key fact, life event, changed plan), append [DIGEST: <one-line reason>] to the END of your reply. It will be stripped before sending. Flag sparingly.`;
 const JOURNAL_REMINDER = `When a message contains info for one of the journals above, append [JOURNAL:<slug> — <one-line note>] to the END of your reply. Multiple tags OK. Only use slugs listed; never invent. Full rules are in your memory instructions.`;
 const ASYNC_REMINDER = `TWO TRACKS run in parallel: you are the chat track, a separate browser track runs a persistent Claude session dedicated to the shared Chrome at localhost:9222. Never call browser tools (browser_*, mcp__*playwright*) yourself — delegate via [ASYNC-BROWSER: <self-sufficient task description>] at the END of your reply, plus a short ack ("On it, will report back."). For non-browser long work (>30s, multi-step reasoning) use [ASYNC: ...]. Irreversible actions (DM send, post, purchase) split into gather→confirm→act phases — never send on your own judgment.`;
+// Buildable per-turn so the agent always sees the SENDER's current
+// time and timezone — not the server's. Critical for resolving
+// "today at 10:30am" / "tomorrow morning" relative to the user.
+function buildSchedulingReminder(nowLocal, tz) {
+    return [
+        `SCHEDULING (reminders and recurring schedules):`,
+        `Current local time for THIS sender: ${nowLocal} (${tz}).`,
+        `Saying "I'll remind you" is NOT enough — you must emit a tag.`,
+        `Without the tag, NO schedule is created and the user gets nothing.`,
+        ``,
+        `One-shot reminder — append at END of your reply, ONE PER LINE:`,
+        `  [REMIND: in 30m — <text the user will receive>]`,
+        `  [REMIND: in 2h — <text>]`,
+        `  [REMIND: at 10:30am — <text>]`,
+        `  [REMIND: tomorrow at 9am — <text>]`,
+        `  [REMIND: mon at 9am — <text>]   (next occurrence of Monday)`,
+        `  [REMIND: 2026-12-25 09:00 — <text>]`,
+        `Units for "in N": s | m | h | d. Times are in the sender's tz.`,
+        ``,
+        `Recurring schedule:`,
+        `  [CRON: @daily 09:00 — <text>]`,
+        `  [CRON: @every 3h — <text>]`,
+        `  [CRON: @weekly mon 09:00 — <text>]`,
+        ``,
+        `Cross-chat send (rare):`,
+        `  [SEND-TEXT: address=wa:dm:1234567890@s.whatsapp.net body="..."]`,
+        ``,
+        `Acknowledge the schedule in your chat reply ("got it, reminding you at 10:30") and emit the tag at the END. Reply text is what the user sees right now; the tag is the side effect.`,
+    ].join('\n');
+}
 function buildCriticalSection(params) {
     const { senderNumber, roleName, role, userName } = params;
     const who = userName
@@ -131,6 +162,23 @@ export function buildMemoryPreamble(params) {
         sections.push(`[Journals: active]\n${journalsBlock}`);
         instructions.push(JOURNAL_REMINDER);
     }
+    // Scheduling reminder — tells the agent the current local time in
+    // the SENDER's timezone + lists the REMIND/CRON/SEND-TEXT grammar.
+    // Without this the agent never emits the tag and reminders silently
+    // never fire (was the root-cause of the May 2026 reminders-not-
+    // working bug).
+    const senderTz = getTimezoneForSenderNumber(params.senderNumber);
+    const nowLocal = new Intl.DateTimeFormat('en-GB', {
+        timeZone: senderTz,
+        weekday: 'short',
+        year: 'numeric',
+        month: 'short',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        hour12: false,
+    }).format(new Date());
+    instructions.push(buildSchedulingReminder(nowLocal, senderTz));
     // Async tasks in progress for this chat — so Claude doesn't re-promise or
     // contradict work already running in the background.
     const asyncTasks = listAsyncTasks(params.jid);

package/dist/queue/crons.js

@@ -23,6 +23,7 @@ export function enqueueCron(input) {
     const db = getDb();
     const now = Math.floor(Date.now() / 1000);
     const enabled = (input.enabled ?? true) ? 1 : 0;
+    const tz = input.timezone ?? config.owner.timezone;
     if (input.recurrence) {
         const existing = db
             .select()
@@ -36,6 +37,7 @@ export function enqueueCron(input) {
                 enqueueInto: input.enqueueInto,
                 payload: JSON.stringify(input.payload),
                 recurrence: input.recurrence,
+                timezone: tz,
                 enabled,
             })
                 .where(eq(crons.name, input.name))
@@ -44,7 +46,7 @@ export function enqueueCron(input) {
             return updated;
         }
     }
-    const firstRunAt = input.firstRunAt ?? computeNextRun(input.recurrence, now);
+    const firstRunAt = input.firstRunAt ?? computeNextRun(input.recurrence, now, tz);
     if (firstRunAt === null) {
         throw new Error(`enqueueCron(${input.name}): one-shot requires firstRunAt`);
     }
@@ -55,6 +57,7 @@ export function enqueueCron(input) {
         enqueueInto: input.enqueueInto,
         payload: JSON.stringify(input.payload),
         recurrence: input.recurrence,
+        timezone: tz,
         nextRunAt: firstRunAt,
         lastRunAt: null,
         enabled,
@@ -74,7 +77,8 @@ export function listDueCrons(asOf = Math.floor(Date.now() / 1000)) {
 }
 // Called by orchestrator after the cron's payload has been enqueued
 // into its target queue. Recurring crons get nextRunAt advanced;
-// one-shots get deleted.
+// one-shots get deleted. Uses the row's stored timezone for @daily /
+// @weekly resolution; falls back to owner tz for legacy rows.
 export function markCronFired(row) {
     const db = getDb();
     const now = Math.floor(Date.now() / 1000);
@@ -82,7 +86,8 @@ export function markCronFired(row) {
         db.delete(crons).where(eq(crons.id, row.id)).run();
         return;
     }
-    const next = computeNextRun(row.recurrence, now);
+    const tz = row.timezone ?? config.owner.timezone;
+    const next = computeNextRun(row.recurrence, now, tz);
     if (next === null) {
         logger.error({ id: row.id, name: row.name, recurrence: row.recurrence }, 'cron has unparseable recurrence after firing; disabling');
         db.update(crons)
@@ -128,8 +133,10 @@ 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) {
+// null for an unparseable format. tz defaults to owner timezone but
+// per-user crons should pass the sender's local tz so @daily HH:MM
+// fires in the user's wall-clock time, not the server's.
+export function computeNextRun(recurrence, nowSec, tz = config.owner.timezone) {
     if (!recurrence)
         return null;
     const everyMatch = EVERY_RE.exec(recurrence);
@@ -142,20 +149,19 @@ export function computeNextRun(recurrence, nowSec) {
     }
     const dailyMatch = DAILY_RE.exec(recurrence);
     if (dailyMatch) {
-        return nextLocalHourMinute(nowSec, parseInt(dailyMatch[1], 10), parseInt(dailyMatch[2], 10), null);
+        return nextLocalHourMinute(nowSec, parseInt(dailyMatch[1], 10), parseInt(dailyMatch[2], 10), null, tz);
     }
     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 nextLocalHourMinute(nowSec, parseInt(weeklyMatch[2], 10), parseInt(weeklyMatch[3], 10), dow, tz);
     }
     return null;
 }
-// Compute the next unix-seconds at HH:MM in the owner timezone,
+// Compute the next unix-seconds at HH:MM in the given 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;
+function nextLocalHourMinute(nowSec, hour, minute, dayOfWeek, tz) {
     const fmt = new Intl.DateTimeFormat('en-CA', {
         timeZone: tz,
         year: 'numeric', month: '2-digit', day: '2-digit',

package/dist/queue/schedule-list.js

@@ -0,0 +1,61 @@
+// Helpers for the /reminders and /crons chat commands. Lists pending
+// cron rows that target a particular chat address, formatted for
+// reading on a phone.
+import { and, asc, eq, like } from 'drizzle-orm';
+import { getDb } from '../db/index.js';
+import { crons } from '../db/schema.js';
+import { formatLocalTime } from './time-expr.js';
+// Pull crons whose payload targets the given chat address. We tag
+// chat-emitted crons with names prefixed by 'chat-cron-' (recurring)
+// or 'chat-remind-' (one-shot), so a LIKE filter on the JSON address
+// is the simplest way to scope per chat.
+export function listChatSchedules(chatAddress, kind) {
+    const db = getDb();
+    // SQLite has no JSON containment operator that's portable; use a
+    // simple substring search on the serialized payload. Payloads
+    // include `"address":"<addr>"` which is unique enough.
+    const addressNeedle = `%"address":"${chatAddress.replace(/"/g, '\\"')}"%`;
+    const rows = db
+        .select()
+        .from(crons)
+        .where(and(eq(crons.enabled, 1), like(crons.payload, addressNeedle)))
+        .orderBy(asc(crons.nextRunAt))
+        .all();
+    return rows
+        .filter((r) => kind === 'one-shot' ? r.recurrence === null : r.recurrence !== null)
+        .map((r) => ({
+        id: r.id,
+        name: r.name,
+        recurrence: r.recurrence,
+        nextRunAt: r.nextRunAt,
+        bodyPreview: extractBodyPreview(r.payload),
+    }));
+}
+function extractBodyPreview(payload) {
+    try {
+        const obj = JSON.parse(payload);
+        const t = obj.text ?? '';
+        return t.length > 80 ? t.slice(0, 77) + '...' : t;
+    }
+    catch {
+        return '';
+    }
+}
+export function formatScheduleList(items, tz, kind) {
+    if (items.length === 0) {
+        return kind === 'one-shot'
+            ? 'No reminders pending for this chat.'
+            : 'No recurring schedules for this chat.';
+    }
+    const header = kind === 'one-shot' ? '*Pending reminders*' : '*Recurring schedules*';
+    const lines = [header];
+    for (const item of items) {
+        const when = formatLocalTime(item.nextRunAt, tz);
+        const tail = item.recurrence ? ` · ${item.recurrence}` : '';
+        lines.push(`  ${when}${tail}`);
+        if (item.bodyPreview)
+            lines.push(`    "${item.bodyPreview}"`);
+    }
+    lines.push(`Timezone: ${tz}`);
+    return lines.join('\n');
+}