@openparachute/agent 0.1.1 → 0.2.0

package/src/modules/scheduling/actions.ts

@@ -1,113 +0,0 @@
-/**
- * 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

@@ -1,282 +0,0 @@
-/**
- * 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

@@ -1,148 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-/**
- * 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

@@ -1,98 +0,0 @@
-/**
- * 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);
-  });
-});