@openparachute/agent 0.1.0

package/src/modules/scheduling/actions.ts

@@ -0,0 +1,113 @@
+/**
+ * Delivery action handlers for scheduling.
+ *
+ * The container can't write to inbound.db (host-owned). When the agent calls
+ * schedule_task / cancel_task / etc. via MCP, the container writes a
+ * `kind='system'` outbound message with an `action` field. The delivery path
+ * reaches into this module via the delivery-action registry and we apply the
+ * change to inbound.db here.
+ */
+import type { Database } from '../../db/connection.js';
+
+import { wakeContainer } from '../../container-runner.js';
+import { getSession } from '../../db/sessions.js';
+import { log } from '../../log.js';
+import { writeSessionMessage } from '../../session-manager.js';
+import type { Session } from '../../types.js';
+import { cancelTask, insertTask, pauseTask, resumeTask, updateTask, type TaskUpdate } from './db.js';
+
+export async function handleScheduleTask(
+  content: Record<string, unknown>,
+  _session: Session,
+  inDb: Database,
+): Promise<void> {
+  const taskId = content.taskId as string;
+  const prompt = content.prompt as string;
+  const script = content.script as string | null;
+  const processAfter = content.processAfter as string;
+  const recurrence = (content.recurrence as string) || null;
+
+  insertTask(inDb, {
+    id: taskId,
+    processAfter,
+    recurrence,
+    platformId: (content.platformId as string) ?? null,
+    channelType: (content.channelType as string) ?? null,
+    threadId: (content.threadId as string) ?? null,
+    content: JSON.stringify({ prompt, script }),
+  });
+  log.info('Scheduled task created', { taskId, processAfter, recurrence });
+}
+
+export async function handleCancelTask(
+  content: Record<string, unknown>,
+  _session: Session,
+  inDb: Database,
+): Promise<void> {
+  const taskId = content.taskId as string;
+  cancelTask(inDb, taskId);
+  log.info('Task cancelled', { taskId });
+}
+
+export async function handlePauseTask(
+  content: Record<string, unknown>,
+  _session: Session,
+  inDb: Database,
+): Promise<void> {
+  const taskId = content.taskId as string;
+  pauseTask(inDb, taskId);
+  log.info('Task paused', { taskId });
+}
+
+export async function handleResumeTask(
+  content: Record<string, unknown>,
+  _session: Session,
+  inDb: Database,
+): Promise<void> {
+  const taskId = content.taskId as string;
+  resumeTask(inDb, taskId);
+  log.info('Task resumed', { taskId });
+}
+
+export async function handleUpdateTask(
+  content: Record<string, unknown>,
+  session: Session,
+  inDb: Database,
+): Promise<void> {
+  const taskId = content.taskId as string;
+  const update: TaskUpdate = {};
+  if (typeof content.prompt === 'string') update.prompt = content.prompt;
+  if (typeof content.processAfter === 'string') update.processAfter = content.processAfter;
+  if (content.recurrence === null || typeof content.recurrence === 'string') {
+    update.recurrence = content.recurrence as string | null;
+  }
+  if (content.script === null || typeof content.script === 'string') {
+    update.script = content.script as string | null;
+  }
+  const touched = updateTask(inDb, taskId, update);
+  log.info('Task updated', { taskId, touched, fields: Object.keys(update) });
+  if (touched === 0) {
+    // Notify the agent that update_task matched nothing. Replicates the
+    // old notifyAgent helper that used to live in delivery.ts — inlined
+    // here so scheduling doesn't depend on delivery's private helpers.
+    writeSessionMessage(session.agent_group_id, session.id, {
+      id: `sys-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      kind: 'chat',
+      timestamp: new Date().toISOString(),
+      platformId: session.agent_group_id,
+      channelType: 'agent',
+      threadId: null,
+      content: JSON.stringify({
+        text: `update_task: no live task matched id "${taskId}".`,
+        sender: 'system',
+        senderId: 'system',
+      }),
+    });
+    const fresh = getSession(session.id);
+    if (fresh) {
+      wakeContainer(fresh).catch((err) =>
+        log.error('Failed to wake container after update_task notification', { err }),
+      );
+    }
+  }
+}

package/src/modules/scheduling/db.test.ts

@@ -0,0 +1,282 @@
+/**
+ * Tests for the scheduling module's task DB helpers — focused on the
+ * series_id invariant that lets cancel/pause/resume/update reach the live
+ * next occurrence of a recurring task, even after the row the agent
+ * remembers has completed and been replaced by a follow-up.
+ */
+import fs from 'fs';
+import path from 'path';
+import { describe, it, expect, afterEach } from 'vitest';
+
+import { ensureSchema, openInboundDb } from '../../db/session-db.js';
+import {
+  insertTask,
+  insertRecurrence,
+  cancelTask,
+  pauseTask,
+  resumeTask,
+  updateTask,
+  getCompletedRecurring,
+  type RecurringMessage,
+} from './db.js';
+
+const TEST_DIR = '/tmp/paraclaw-scheduling-db-test';
+const DB_PATH = path.join(TEST_DIR, 'inbound.db');
+
+function freshDb() {
+  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+  fs.mkdirSync(TEST_DIR, { recursive: true });
+  ensureSchema(DB_PATH, 'inbound');
+  return openInboundDb(DB_PATH);
+}
+
+function insertBasicTask(db: ReturnType<typeof openInboundDb>, id: string, recurrence: string | null) {
+  insertTask(db, {
+    id,
+    processAfter: new Date().toISOString(),
+    recurrence,
+    platformId: null,
+    channelType: null,
+    threadId: null,
+    content: JSON.stringify({ prompt: 'noop' }),
+  });
+}
+
+afterEach(() => {
+  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+});
+
+describe('insertTask', () => {
+  it('stamps series_id = id on insert', () => {
+    const db = freshDb();
+    insertBasicTask(db, 'task-1', null);
+    const row = db.prepare('SELECT series_id FROM messages_in WHERE id = ?').get('task-1') as { series_id: string };
+    expect(row.series_id).toBe('task-1');
+    db.close();
+  });
+});
+
+describe('cancelTask / pauseTask / resumeTask series matching', () => {
+  // Simulates the recurrence chain that used to survive cancellation:
+  // the original task completes → handleRecurrence spawns a follow-up
+  // row → agent calls cancel_task(originalId) → historically only hit
+  // the completed row, leaving the live one running.
+  function seedRecurringChain(db: ReturnType<typeof openInboundDb>) {
+    insertBasicTask(db, 'task-orig', '0 9 * * *');
+    // Mark the original as completed (as syncProcessingAcks would do).
+    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-orig'").run();
+
+    const msg: RecurringMessage = {
+      id: 'task-orig',
+      kind: 'task',
+      content: JSON.stringify({ prompt: 'noop' }),
+      recurrence: '0 9 * * *',
+      process_after: null,
+      platform_id: null,
+      channel_type: null,
+      thread_id: null,
+      series_id: 'task-orig',
+    };
+    insertRecurrence(db, msg, 'task-next', new Date(Date.now() + 86400000).toISOString());
+  }
+
+  it('cancel by original id reaches the live follow-up via series_id', () => {
+    const db = freshDb();
+    seedRecurringChain(db);
+
+    cancelTask(db, 'task-orig');
+
+    const live = db.prepare("SELECT id, status, recurrence FROM messages_in WHERE status = 'pending'").all();
+    expect(live).toHaveLength(0);
+
+    const followUp = db.prepare("SELECT status, recurrence FROM messages_in WHERE id = 'task-next'").get() as {
+      status: string;
+      recurrence: string | null;
+    };
+    expect(followUp.status).toBe('completed');
+    // Recurrence cleared so the sweep doesn't spawn another clone.
+    expect(followUp.recurrence).toBeNull();
+    db.close();
+  });
+
+  it('cancelled task is not picked up by getCompletedRecurring', () => {
+    const db = freshDb();
+    insertBasicTask(db, 'task-1', '0 9 * * *');
+    cancelTask(db, 'task-1');
+
+    const recurring = getCompletedRecurring(db);
+    expect(recurring).toHaveLength(0);
+    db.close();
+  });
+
+  it('pause by original id pauses the live follow-up', () => {
+    const db = freshDb();
+    seedRecurringChain(db);
+
+    pauseTask(db, 'task-orig');
+
+    const followUp = db.prepare("SELECT status FROM messages_in WHERE id = 'task-next'").get() as { status: string };
+    expect(followUp.status).toBe('paused');
+    db.close();
+  });
+
+  it('resume by original id resumes the live follow-up', () => {
+    const db = freshDb();
+    seedRecurringChain(db);
+
+    db.prepare("UPDATE messages_in SET status = 'paused' WHERE id = 'task-next'").run();
+    resumeTask(db, 'task-orig');
+
+    const followUp = db.prepare("SELECT status FROM messages_in WHERE id = 'task-next'").get() as { status: string };
+    expect(followUp.status).toBe('pending');
+    db.close();
+  });
+});
+
+describe('updateTask', () => {
+  it('merges supplied fields into content JSON without clobbering others', () => {
+    const db = freshDb();
+    insertTask(db, {
+      id: 'task-1',
+      processAfter: new Date().toISOString(),
+      recurrence: null,
+      platformId: null,
+      channelType: null,
+      threadId: null,
+      content: JSON.stringify({ prompt: 'old', script: 'echo old', extra: 'keep me' }),
+    });
+
+    const touched = updateTask(db, 'task-1', { prompt: 'new' });
+    expect(touched).toBe(1);
+
+    const row = db.prepare('SELECT content FROM messages_in WHERE id = ?').get('task-1') as { content: string };
+    const parsed = JSON.parse(row.content);
+    expect(parsed.prompt).toBe('new');
+    expect(parsed.script).toBe('echo old');
+    expect(parsed.extra).toBe('keep me');
+  });
+
+  it('updates recurrence and process_after when supplied', () => {
+    const db = freshDb();
+    insertTask(db, {
+      id: 'task-1',
+      processAfter: '2026-01-01T00:00:00Z',
+      recurrence: '0 9 * * *',
+      platformId: null,
+      channelType: null,
+      threadId: null,
+      content: JSON.stringify({ prompt: 'p' }),
+    });
+
+    updateTask(db, 'task-1', { recurrence: '0 18 * * *', processAfter: '2026-02-01T00:00:00Z' });
+
+    const row = db.prepare('SELECT recurrence, process_after FROM messages_in WHERE id = ?').get('task-1') as {
+      recurrence: string;
+      process_after: string;
+    };
+    expect(row.recurrence).toBe('0 18 * * *');
+    expect(row.process_after).toBe('2026-02-01T00:00:00Z');
+  });
+
+  it('clears recurrence when null is passed', () => {
+    const db = freshDb();
+    insertTask(db, {
+      id: 'task-1',
+      processAfter: '2026-01-01T00:00:00Z',
+      recurrence: '0 9 * * *',
+      platformId: null,
+      channelType: null,
+      threadId: null,
+      content: JSON.stringify({ prompt: 'p' }),
+    });
+
+    updateTask(db, 'task-1', { recurrence: null });
+
+    const row = db.prepare('SELECT recurrence FROM messages_in WHERE id = ?').get('task-1') as {
+      recurrence: string | null;
+    };
+    expect(row.recurrence).toBeNull();
+  });
+
+  it('reaches the live follow-up via series_id when called with the original id', () => {
+    const db = freshDb();
+    insertTask(db, {
+      id: 'task-orig',
+      processAfter: new Date().toISOString(),
+      recurrence: '0 9 * * *',
+      platformId: null,
+      channelType: null,
+      threadId: null,
+      content: JSON.stringify({ prompt: 'old' }),
+    });
+    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-orig'").run();
+
+    const msg: RecurringMessage = {
+      id: 'task-orig',
+      kind: 'task',
+      content: JSON.stringify({ prompt: 'old' }),
+      recurrence: '0 9 * * *',
+      process_after: null,
+      platform_id: null,
+      channel_type: null,
+      thread_id: null,
+      series_id: 'task-orig',
+    };
+    insertRecurrence(db, msg, 'task-next', new Date(Date.now() + 86400000).toISOString());
+
+    const touched = updateTask(db, 'task-orig', { prompt: 'new' });
+    // Only the live follow-up should be touched — completed rows are excluded.
+    expect(touched).toBe(1);
+
+    const live = db.prepare("SELECT content FROM messages_in WHERE id = 'task-next'").get() as { content: string };
+    expect(JSON.parse(live.content).prompt).toBe('new');
+
+    // Original (completed) row left alone.
+    const orig = db.prepare("SELECT content FROM messages_in WHERE id = 'task-orig'").get() as { content: string };
+    expect(JSON.parse(orig.content).prompt).toBe('old');
+  });
+
+  it('returns 0 when no live task matches', () => {
+    const db = freshDb();
+    insertTask(db, {
+      id: 'task-1',
+      processAfter: new Date().toISOString(),
+      recurrence: null,
+      platformId: null,
+      channelType: null,
+      threadId: null,
+      content: JSON.stringify({ prompt: 'p' }),
+    });
+    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-1'").run();
+
+    const touched = updateTask(db, 'task-1', { prompt: 'new' });
+    expect(touched).toBe(0);
+  });
+});
+
+describe('insertRecurrence', () => {
+  it('copies series_id forward', () => {
+    const db = freshDb();
+    insertBasicTask(db, 'task-orig', '0 9 * * *');
+    db.prepare("UPDATE messages_in SET status = 'completed' WHERE id = 'task-orig'").run();
+
+    const msg: RecurringMessage = {
+      id: 'task-orig',
+      kind: 'task',
+      content: '{}',
+      recurrence: '0 9 * * *',
+      process_after: null,
+      platform_id: null,
+      channel_type: null,
+      thread_id: null,
+      series_id: 'task-orig',
+    };
+    insertRecurrence(db, msg, 'task-next', new Date().toISOString());
+
+    const row = db.prepare('SELECT series_id FROM messages_in WHERE id = ?').get('task-next') as {
+      series_id: string;
+    };
+    expect(row.series_id).toBe('task-orig');
+    db.close();
+  });
+});

package/src/modules/scheduling/db.ts

@@ -0,0 +1,148 @@
+/**
+ * Task DB helpers used by the scheduling module.
+ *
+ * Tasks are `messages_in` rows with `kind='task'`. This module doesn't own
+ * its own table — it piggybacks on the core schema. That's why there's no
+ * `module-scheduling-*.ts` migration file.
+ *
+ * cancel/pause/resume match any live row in the series, not just the exact id.
+ * Recurring tasks get a new row per occurrence (see handleRecurrence), all
+ * sharing series_id. Matching by id alone would only hit the completed row
+ * the agent remembers, missing the live next occurrence.
+ */
+import type { Database } from '../../db/connection.js';
+
+import { nextEvenSeq } from '../../db/session-db.js';
+
+export function insertTask(
+  db: Database,
+  task: {
+    id: string;
+    processAfter: string;
+    recurrence: string | null;
+    platformId: string | null;
+    channelType: string | null;
+    threadId: string | null;
+    content: string;
+  },
+): void {
+  db.prepare(
+    `INSERT INTO messages_in (id, seq, timestamp, status, tries, process_after, recurrence, kind, platform_id, channel_type, thread_id, content, series_id)
+     VALUES (@id, @seq, datetime('now'), 'pending', 0, @processAfter, @recurrence, 'task', @platformId, @channelType, @threadId, @content, @id)`,
+  ).run({
+    ...task,
+    seq: nextEvenSeq(db),
+  });
+}
+
+export function cancelTask(db: Database, taskId: string): void {
+  db.prepare(
+    "UPDATE messages_in SET status = 'completed', recurrence = NULL WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status IN ('pending', 'paused')",
+  ).run(taskId, taskId);
+}
+
+export function pauseTask(db: Database, taskId: string): void {
+  db.prepare(
+    "UPDATE messages_in SET status = 'paused' WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status = 'pending'",
+  ).run(taskId, taskId);
+}
+
+export function resumeTask(db: Database, taskId: string): void {
+  db.prepare(
+    "UPDATE messages_in SET status = 'pending' WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status = 'paused'",
+  ).run(taskId, taskId);
+}
+
+export interface TaskUpdate {
+  prompt?: string;
+  script?: string | null;
+  recurrence?: string | null;
+  processAfter?: string;
+}
+
+// Merges content JSON in-place so callers can update prompt/script without
+// clobbering other fields. Matches by id OR series_id so the live next
+// occurrence of a recurring task is updated, not just the completed row the
+// agent last saw. Returns the number of rows touched.
+export function updateTask(db: Database, taskId: string, update: TaskUpdate): number {
+  const rows = db
+    .prepare(
+      "SELECT id, content FROM messages_in WHERE (id = ? OR series_id = ?) AND kind = 'task' AND status IN ('pending', 'paused')",
+    )
+    .all(taskId, taskId) as Array<{ id: string; content: string }>;
+
+  if (rows.length === 0) return 0;
+
+  const setProcessAfter = update.processAfter !== undefined;
+  const setRecurrence = update.recurrence !== undefined;
+  const mergeContent = update.prompt !== undefined || update.script !== undefined;
+
+  const tx = db.transaction(() => {
+    for (const row of rows) {
+      let content = row.content;
+      if (mergeContent) {
+        const parsed = JSON.parse(row.content) as Record<string, unknown>;
+        if (update.prompt !== undefined) parsed.prompt = update.prompt;
+        if (update.script !== undefined) parsed.script = update.script;
+        content = JSON.stringify(parsed);
+      }
+
+      // Build SET clause dynamically so callers can update fields independently.
+      const sets: string[] = ['content = ?'];
+      const params: unknown[] = [content];
+      if (setProcessAfter) {
+        sets.push('process_after = ?');
+        params.push(update.processAfter);
+      }
+      if (setRecurrence) {
+        sets.push('recurrence = ?');
+        params.push(update.recurrence);
+      }
+      params.push(row.id);
+
+      db.prepare(`UPDATE messages_in SET ${sets.join(', ')} WHERE id = ?`).run(...params);
+    }
+  });
+  tx();
+  return rows.length;
+}
+
+export interface RecurringMessage {
+  id: string;
+  kind: string;
+  content: string;
+  recurrence: string;
+  process_after: string | null;
+  platform_id: string | null;
+  channel_type: string | null;
+  thread_id: string | null;
+  series_id: string;
+}
+
+export function getCompletedRecurring(db: Database): RecurringMessage[] {
+  return db
+    .prepare("SELECT * FROM messages_in WHERE status = 'completed' AND recurrence IS NOT NULL")
+    .all() as RecurringMessage[];
+}
+
+export function insertRecurrence(db: Database, msg: RecurringMessage, newId: string, nextRun: string | null): void {
+  db.prepare(
+    `INSERT INTO messages_in (id, seq, kind, timestamp, status, process_after, recurrence, platform_id, channel_type, thread_id, content, series_id)
+     VALUES (?, ?, ?, datetime('now'), 'pending', ?, ?, ?, ?, ?, ?, ?)`,
+  ).run(
+    newId,
+    nextEvenSeq(db),
+    msg.kind,
+    nextRun,
+    msg.recurrence,
+    msg.platform_id,
+    msg.channel_type,
+    msg.thread_id,
+    msg.content,
+    msg.series_id,
+  );
+}
+
+export function clearRecurrence(db: Database, messageId: string): void {
+  db.prepare('UPDATE messages_in SET recurrence = NULL WHERE id = ?').run(messageId);
+}

package/src/modules/scheduling/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Scheduling module — one-shot and recurring tasks.
+ *
+ * Registers:
+ *   - Five delivery action handlers: schedule_task, cancel_task, pause_task,
+ *     resume_task, update_task. The container's scheduling MCP tools
+ *     (container/agent-runner/src/mcp-tools/scheduling.ts) write system
+ *     messages with these actions; the host applies them to inbound.db.
+ *
+ * Host integration points (filled by MODULE-HOOK markers, validated here
+ * with the scheduling module shipping inline):
+ *   - `src/host-sweep.ts` → MODULE-HOOK:scheduling-recurrence calls
+ *     `handleRecurrence` each sweep tick.
+ *   - `container/agent-runner/src/poll-loop.ts` → MODULE-HOOK:scheduling-pre-task
+ *     runs `applyPreTaskScripts` before the provider call so tasks carrying
+ *     a pre-agent script can gate their own execution.
+ *
+ * No DB migration — tasks are `messages_in` rows with `kind='task'`, so the
+ * module piggybacks on the core schema.
+ */
+import { registerDeliveryAction } from '../../delivery.js';
+import {
+  handleCancelTask,
+  handlePauseTask,
+  handleResumeTask,
+  handleScheduleTask,
+  handleUpdateTask,
+} from './actions.js';
+
+registerDeliveryAction('schedule_task', handleScheduleTask);
+registerDeliveryAction('cancel_task', handleCancelTask);
+registerDeliveryAction('pause_task', handlePauseTask);
+registerDeliveryAction('resume_task', handleResumeTask);
+registerDeliveryAction('update_task', handleUpdateTask);

package/src/modules/scheduling/recurrence.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Tests for `handleRecurrence` — specifically the timezone-aware cron
+ * interpretation ported from v1 (src/v1/task-scheduler.ts).
+ *
+ * Core invariant: cron expressions are interpreted in the user's TIMEZONE,
+ * not UTC. Without this, `"0 9 * * *"` fires at 09:00 UTC instead of 09:00
+ * user-local — a recurring scheduling bug users can't diagnose.
+ */
+import fs from 'fs';
+import path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+
+import { ensureSchema, openInboundDb } from '../../db/session-db.js';
+import { insertTask } from './db.js';
+import { handleRecurrence } from './recurrence.js';
+import type { Session } from '../../types.js';
+
+const TEST_DIR = '/tmp/paraclaw-recurrence-test';
+const DB_PATH = path.join(TEST_DIR, 'inbound.db');
+
+function freshDb() {
+  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+  fs.mkdirSync(TEST_DIR, { recursive: true });
+  ensureSchema(DB_PATH, 'inbound');
+  return openInboundDb(DB_PATH);
+}
+
+function fakeSession(): Session {
+  return {
+    id: 'sess-test',
+    agent_group_id: 'ag-test',
+    messaging_group_id: 'mg-test',
+    thread_id: null,
+    status: 'active',
+    created_at: new Date().toISOString(),
+    last_active: new Date().toISOString(),
+    container_status: 'stopped',
+  } as Session;
+}
+
+afterEach(() => {
+  if (fs.existsSync(TEST_DIR)) fs.rmSync(TEST_DIR, { recursive: true });
+});
+
+describe('handleRecurrence', () => {
+  it('clones a completed recurring task with a next-run in the future', async () => {
+    const db = freshDb();
+    insertTask(db, {
+      id: 'task-1',
+      processAfter: '2020-01-01T00:00:00.000Z',
+      recurrence: '0 9 * * *', // every day at 09:00 (user TZ)
+      platformId: null,
+      channelType: null,
+      threadId: null,
+      content: JSON.stringify({ prompt: 'daily digest' }),
+    });
+    db.prepare(`UPDATE messages_in SET status='completed' WHERE id='task-1'`).run();
+
+    await handleRecurrence(db, fakeSession());
+
+    const rows = db
+      .prepare(`SELECT id, status, process_after, recurrence, series_id FROM messages_in ORDER BY seq`)
+      .all() as Array<{
+      id: string;
+      status: string;
+      process_after: string;
+      recurrence: string | null;
+      series_id: string;
+    }>;
+    expect(rows).toHaveLength(2);
+    const original = rows.find((r) => r.id === 'task-1')!;
+    const follow = rows.find((r) => r.id !== 'task-1')!;
+    expect(original.recurrence).toBeNull();
+    expect(follow.status).toBe('pending');
+    expect(follow.recurrence).toBe('0 9 * * *');
+    expect(follow.series_id).toBe('task-1');
+    expect(new Date(follow.process_after).getTime()).toBeGreaterThan(Date.now());
+  });
+
+  it('does not clone rows whose recurrence is already cleared', async () => {
+    const db = freshDb();
+    insertTask(db, {
+      id: 'task-1',
+      processAfter: '2020-01-01T00:00:00.000Z',
+      recurrence: null,
+      platformId: null,
+      channelType: null,
+      threadId: null,
+      content: JSON.stringify({ prompt: 'one-off' }),
+    });
+    db.prepare(`UPDATE messages_in SET status='completed' WHERE id='task-1'`).run();
+
+    await handleRecurrence(db, fakeSession());
+
+    const count = (db.prepare(`SELECT COUNT(*) AS c FROM messages_in`).get() as { c: number }).c;
+    expect(count).toBe(1);
+  });
+});