@poncho-ai/harness 0.37.2 → 0.39.0

package/src/reminder-tools.ts

@@ -1,16 +1,18 @@
 import { defineTool, type ToolDefinition } from "@poncho-ai/sdk";
-import type { ReminderStore, ReminderStatus } from "./reminder-store.js";
+import type { ReminderStore, ReminderStatus, Recurrence, RecurrenceType } from "./reminder-store.js";
 
 const VALID_STATUSES: ReminderStatus[] = ["pending", "cancelled"];
+const VALID_RECURRENCE_TYPES: RecurrenceType[] = ["daily", "weekly", "monthly", "cron"];
 
 export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
   defineTool({
     name: "set_reminder",
     description:
-      "Set a one-time reminder that will fire at the specified date and time. " +
+      "Set a reminder that will fire at the specified date and time. " +
       "Use this when the user asks to be reminded about something. " +
       "The datetime must be an ISO 8601 string in the future. " +
-      "When the reminder fires, the task message will be delivered to the user.",
+      "When the reminder fires, the task message will be delivered to the user. " +
+      "Supports optional recurrence for recurring reminders (daily, weekly, monthly, or cron).",
     inputSchema: {
       type: "object",
       properties: {
@@ -21,13 +23,54 @@ export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
         datetime: {
           type: "string",
           description:
-            "ISO 8601 datetime for when the reminder should fire (e.g. '2026-03-23T09:00:00Z')",
+            "ISO 8601 datetime for when the reminder should first fire (e.g. '2026-03-23T09:00:00Z')",
         },
         timezone: {
           type: "string",
           description:
             "IANA timezone for interpreting the datetime if it lacks an offset (e.g. 'America/New_York'). Defaults to UTC.",
         },
+        recurrence: {
+          type: "object",
+          description:
+            "Optional. Set this to make the reminder repeat. Omit for a one-time reminder.",
+          properties: {
+            type: {
+              type: "string",
+              enum: VALID_RECURRENCE_TYPES,
+              description:
+                "How often to repeat: 'daily', 'weekly', 'monthly', or 'cron'.",
+            },
+            interval: {
+              type: "number",
+              description:
+                "Repeat every N units (e.g. 2 = every 2 days/weeks/months). Defaults to 1.",
+            },
+            daysOfWeek: {
+              type: "array",
+              items: { type: "number" },
+              description:
+                "For weekly: which days to fire (0=Sunday, 1=Monday, ..., 6=Saturday).",
+            },
+            expression: {
+              type: "string",
+              description:
+                "For type 'cron': a 5-field cron expression (e.g. '0 9 * * 1-5' for weekdays at 9am).",
+            },
+            endsAt: {
+              type: "string",
+              description:
+                "ISO 8601 datetime after which the recurrence should stop.",
+            },
+            maxOccurrences: {
+              type: "number",
+              description:
+                "Maximum number of times the reminder should fire before stopping.",
+            },
+          },
+          required: ["type"],
+          additionalProperties: false,
+        },
       },
       required: ["task", "datetime"],
       additionalProperties: false,
@@ -78,6 +121,50 @@ export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
         throw new Error("Reminder datetime must be in the future");
       }
 
+      // Parse recurrence if provided
+      let recurrence: Recurrence | null = null;
+      if (input.recurrence && typeof input.recurrence === "object") {
+        const rec = input.recurrence as Record<string, unknown>;
+        const recType = rec.type as string;
+        if (!VALID_RECURRENCE_TYPES.includes(recType as RecurrenceType)) {
+          throw new Error(`Invalid recurrence type: "${recType}". Must be one of: ${VALID_RECURRENCE_TYPES.join(", ")}`);
+        }
+        recurrence = { type: recType as RecurrenceType };
+        if (rec.interval !== undefined) {
+          const interval = Number(rec.interval);
+          if (!Number.isInteger(interval) || interval < 1) {
+            throw new Error("recurrence.interval must be a positive integer");
+          }
+          recurrence.interval = interval;
+        }
+        if (rec.daysOfWeek !== undefined) {
+          if (!Array.isArray(rec.daysOfWeek)) throw new Error("recurrence.daysOfWeek must be an array");
+          const days = (rec.daysOfWeek as unknown[]).map(Number);
+          if (days.some((d) => !Number.isInteger(d) || d < 0 || d > 6)) {
+            throw new Error("recurrence.daysOfWeek values must be integers 0-6");
+          }
+          recurrence.daysOfWeek = days;
+        }
+        if (rec.expression !== undefined) {
+          if (typeof rec.expression !== "string") throw new Error("recurrence.expression must be a string");
+          recurrence.expression = rec.expression;
+        }
+        if (rec.endsAt !== undefined) {
+          const endsAtDate = new Date(rec.endsAt as string);
+          if (isNaN(endsAtDate.getTime())) {
+            throw new Error(`Invalid recurrence.endsAt: "${rec.endsAt}"`);
+          }
+          recurrence.endsAt = endsAtDate.getTime();
+        }
+        if (rec.maxOccurrences !== undefined) {
+          const max = Number(rec.maxOccurrences);
+          if (!Number.isInteger(max) || max < 1) {
+            throw new Error("recurrence.maxOccurrences must be a positive integer");
+          }
+          recurrence.maxOccurrences = max;
+        }
+      }
+
       const conversationId = context.conversationId || context.runId;
       const reminder = await store.create({
         task,
@@ -85,6 +172,7 @@ export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
         timezone,
         conversationId,
         tenantId: context.tenantId,
+        recurrence,
       });
 
       return {
@@ -95,6 +183,8 @@ export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
           scheduledAt: new Date(reminder.scheduledAt).toISOString(),
           timezone: reminder.timezone ?? "UTC",
           status: reminder.status,
+          recurrence: reminder.recurrence ?? undefined,
+          occurrenceCount: reminder.occurrenceCount ?? 0,
         },
       };
     },
@@ -105,7 +195,8 @@ export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
     description:
       "List reminders for this agent. Returns all reminders by default; " +
       "use the status filter to show only pending or cancelled ones. " +
-      "Fired reminders are automatically deleted after delivery.",
+      "Fired one-time reminders are automatically deleted after delivery. " +
+      "Recurring reminders stay active and show their recurrence config and fire count.",
     inputSchema: {
       type: "object",
       properties: {
@@ -135,6 +226,8 @@ export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
           timezone: r.timezone ?? "UTC",
           status: r.status,
           createdAt: new Date(r.createdAt).toISOString(),
+          recurrence: r.recurrence ?? undefined,
+          occurrenceCount: r.occurrenceCount ?? 0,
         })),
         count: reminders.length,
       };
@@ -143,7 +236,10 @@ export const createReminderTools = (store: ReminderStore): ToolDefinition[] => [
 
   defineTool({
     name: "cancel_reminder",
-    description: "Cancel a pending reminder by its ID.",
+    description:
+      "Cancel a pending reminder by its ID. " +
+      "This works for both one-time and recurring reminders — " +
+      "cancelling a recurring reminder stops all future occurrences.",
     inputSchema: {
       type: "object",
       properties: {

package/src/state.ts

@@ -54,6 +54,13 @@ export interface Conversation {
   contextTokens?: number;
   contextWindow?: number;
   parentConversationId?: string;
+  parentMessageId?: string;
+  threadMeta?: {
+    /** First ~200 chars of the anchor message text, cached for cheap rendering. */
+    parentMessageSummary?: string;
+    /** Length of the snapshot at fork time. messages[snapshotLength-1] is the anchor. */
+    snapshotLength: number;
+  };
   subagentMeta?: {
     task: string;
     status: "running" | "completed" | "error" | "stopped";
@@ -77,16 +84,48 @@ export interface Conversation {
   updatedAt: number;
 }
 
+export interface ConversationCreateInit {
+  parentConversationId?: string;
+  parentMessageId?: string;
+  threadMeta?: Conversation["threadMeta"];
+  subagentMeta?: Conversation["subagentMeta"];
+  messages?: Message[];
+  channelMeta?: Conversation["channelMeta"];
+}
+
 export interface ConversationStore {
   list(ownerId?: string, tenantId?: string | null): Promise<Conversation[]>;
   listSummaries(ownerId?: string, tenantId?: string | null): Promise<ConversationSummary[]>;
+  /**
+   * Cheap column-level fetch — returns summary fields only, no data blob.
+   * Use this on hot polling paths where the caller just needs to know
+   * whether the conversation has changed since last fetch.
+   */
+  getStatusSnapshot(conversationId: string): Promise<ConversationStatusSnapshot | undefined>;
+  /**
+   * Load a conversation WITHOUT the tool_result_archive blob. Default for
+   * read paths — archive can grow unboundedly and most callers don't need it.
+   */
   get(conversationId: string): Promise<Conversation | undefined>;
-  create(ownerId?: string, title?: string, tenantId?: string | null): Promise<Conversation>;
+  /**
+   * Load a conversation WITH the tool_result_archive. Use this only on
+   * run-entry paths that reseed the harness (via withToolResultArchiveParam
+   * or by passing the archive to runCronAgent).
+   */
+  getWithArchive(conversationId: string): Promise<Conversation | undefined>;
+  create(
+    ownerId?: string,
+    title?: string,
+    tenantId?: string | null,
+    init?: ConversationCreateInit,
+  ): Promise<Conversation>;
   update(conversation: Conversation): Promise<void>;
   rename(conversationId: string, title: string): Promise<Conversation | undefined>;
   delete(conversationId: string): Promise<boolean>;
   appendSubagentResult(conversationId: string, result: PendingSubagentResult): Promise<void>;
   clearCallbackLock(conversationId: string): Promise<Conversation | undefined>;
+  /** List thread conversations anchored under `parentConversationId`. */
+  listThreads(parentConversationId: string): Promise<ConversationSummary[]>;
 }
 
 export type StateProviderName =
@@ -186,6 +225,7 @@ export class InMemoryConversationStore implements ConversationStore {
         ownerId: c.ownerId,
         tenantId: c.tenantId,
         parentConversationId: c.parentConversationId,
+        parentMessageId: c.parentMessageId,
         messageCount: c.messages.length,
         hasPendingApprovals: Array.isArray(c.pendingApprovals) && c.pendingApprovals.length > 0,
         channelMeta: c.channelMeta,
@@ -197,16 +237,58 @@ export class InMemoryConversationStore implements ConversationStore {
     return this.conversations.get(conversationId);
   }
 
-  async create(ownerId = DEFAULT_OWNER, title?: string, tenantId: string | null = null): Promise<Conversation> {
+  // In-memory stores already hold the full conversation object, so there's
+  // no separate archive blob to load. Both variants return the same data.
+  async getWithArchive(conversationId: string): Promise<Conversation | undefined> {
+    return this.get(conversationId);
+  }
+
+  async getStatusSnapshot(conversationId: string): Promise<ConversationStatusSnapshot | undefined> {
+    const c = await this.get(conversationId);
+    if (!c) return undefined;
+    return {
+      conversationId: c.conversationId,
+      updatedAt: c.updatedAt,
+      messageCount: c.messages.length,
+      hasPendingApprovals: Array.isArray(c.pendingApprovals) && c.pendingApprovals.length > 0,
+      hasContinuationMessages: Array.isArray(c._continuationMessages) && c._continuationMessages.length > 0,
+      parentConversationId: c.parentConversationId ?? null,
+      ownerId: c.ownerId,
+      tenantId: c.tenantId,
+      runStatus: c.runStatus ?? null,
+    };
+  }
+
+  async create(
+    ownerId = DEFAULT_OWNER,
+    title?: string,
+    tenantId: string | null = null,
+    init?: ConversationCreateInit,
+  ): Promise<Conversation> {
     const now = Date.now();
     const conversation: Conversation = {
       conversationId: globalThis.crypto?.randomUUID?.() ?? `${now}-${Math.random()}`,
       title: normalizeTitle(title),
-      messages: [],
+      messages: init?.messages ?? [],
       ownerId,
       tenantId,
       createdAt: now,
       updatedAt: now,
+      ...(init?.parentConversationId !== undefined
+        ? { parentConversationId: init.parentConversationId }
+        : {}),
+      ...(init?.parentMessageId !== undefined
+        ? { parentMessageId: init.parentMessageId }
+        : {}),
+      ...(init?.threadMeta !== undefined
+        ? { threadMeta: init.threadMeta }
+        : {}),
+      ...(init?.subagentMeta !== undefined
+        ? { subagentMeta: init.subagentMeta }
+        : {}),
+      ...(init?.channelMeta !== undefined
+        ? { channelMeta: init.channelMeta }
+        : {}),
     };
     this.conversations.set(conversation.conversationId, conversation);
     return conversation;
@@ -250,6 +332,30 @@ export class InMemoryConversationStore implements ConversationStore {
     conversation.updatedAt = Date.now();
     return conversation;
   }
+
+  async listThreads(parentConversationId: string): Promise<ConversationSummary[]> {
+    this.purgeExpired();
+    return Array.from(this.conversations.values())
+      .filter(
+        (c) =>
+          c.parentConversationId === parentConversationId &&
+          typeof c.parentMessageId === "string",
+      )
+      .sort((a, b) => b.updatedAt - a.updatedAt)
+      .map((c) => ({
+        conversationId: c.conversationId,
+        title: c.title,
+        updatedAt: c.updatedAt,
+        createdAt: c.createdAt,
+        ownerId: c.ownerId,
+        tenantId: c.tenantId,
+        parentConversationId: c.parentConversationId,
+        parentMessageId: c.parentMessageId,
+        messageCount: c.messages.length,
+        hasPendingApprovals: Array.isArray(c.pendingApprovals) && c.pendingApprovals.length > 0,
+        channelMeta: c.channelMeta,
+      }));
+  }
 }
 
 export type ConversationSummary = {
@@ -260,6 +366,7 @@ export type ConversationSummary = {
   ownerId: string;
   tenantId?: string | null;
   parentConversationId?: string;
+  parentMessageId?: string;
   messageCount?: number;
   hasPendingApprovals?: boolean;
   channelMeta?: {
@@ -269,6 +376,23 @@ export type ConversationSummary = {
   };
 };
 
+/**
+ * Lightweight status snapshot — column-level reads only, no data blob.
+ * Used by cheap polling endpoints that just need to know "has anything
+ * changed?" without paying to deserialize the full conversation.
+ */
+export type ConversationStatusSnapshot = {
+  conversationId: string;
+  updatedAt: number;
+  messageCount: number;
+  hasPendingApprovals: boolean;
+  hasContinuationMessages: boolean;
+  parentConversationId: string | null;
+  ownerId: string;
+  tenantId: string | null;
+  runStatus: "running" | "idle" | null;
+};
+
 // ---------------------------------------------------------------------------
 // Legacy factories — return InMemory stores. The harness now uses
 // engine-backed stores via storage/store-adapters.ts. These factories

package/src/storage/engine.ts

@@ -1,11 +1,13 @@
 import type {
   Conversation,
+  ConversationCreateInit,
+  ConversationStatusSnapshot,
   ConversationSummary,
   PendingSubagentResult,
 } from "../state.js";
 import type { MainMemory } from "../memory.js";
 import type { TodoItem } from "../todo-tools.js";
-import type { Reminder } from "../reminder-store.js";
+import type { Reminder, ReminderCreateInput, ReminderStatus } from "../reminder-store.js";
 
 // ---------------------------------------------------------------------------
 // VFS types
@@ -39,8 +41,29 @@ export interface StorageEngine {
   // --- Conversations (replaces ConversationStore) ---
   conversations: {
     list(ownerId?: string, tenantId?: string | null): Promise<ConversationSummary[]>;
+    /**
+     * Load a conversation WITHOUT the tool_result_archive blob. Use this on
+     * read paths (UI loads, existence checks, etc.) — the archive can grow
+     * unboundedly as tool calls accumulate, and most callers never touch it.
+     */
     get(conversationId: string): Promise<Conversation | undefined>;
-    create(ownerId?: string, title?: string, tenantId?: string | null): Promise<Conversation>;
+    /**
+     * Load a conversation WITH the tool_result_archive. Only use this when
+     * starting/resuming a harness run — the archive needs to be reseeded so
+     * the agent can retrieve previously-archived tool results by id.
+     */
+    getWithArchive(conversationId: string): Promise<Conversation | undefined>;
+    /**
+     * Cheap column-level snapshot — no data blob, no heavy columns. For hot
+     * polling paths. Returns undefined if the conversation doesn't exist.
+     */
+    getStatusSnapshot(conversationId: string): Promise<ConversationStatusSnapshot | undefined>;
+    create(
+      ownerId?: string,
+      title?: string,
+      tenantId?: string | null,
+      init?: ConversationCreateInit,
+    ): Promise<Conversation>;
     update(conversation: Conversation): Promise<void>;
     rename(conversationId: string, title: string): Promise<Conversation | undefined>;
     delete(conversationId: string): Promise<boolean>;
@@ -50,6 +73,8 @@ export interface StorageEngine {
       result: PendingSubagentResult,
     ): Promise<void>;
     clearCallbackLock(conversationId: string): Promise<Conversation | undefined>;
+    /** List thread conversations anchored under `parentConversationId`. */
+    listThreads(parentConversationId: string): Promise<ConversationSummary[]>;
   };
 
   // --- Memory (replaces MemoryStore) ---
@@ -67,14 +92,8 @@ export interface StorageEngine {
   // --- Reminders (replaces ReminderStore) ---
   reminders: {
     list(tenantId?: string | null): Promise<Reminder[]>;
-    create(input: {
-      task: string;
-      scheduledAt: number;
-      timezone?: string;
-      conversationId: string;
-      ownerId?: string;
-      tenantId?: string | null;
-    }): Promise<Reminder>;
+    create(input: ReminderCreateInput): Promise<Reminder>;
+    update(id: string, fields: { scheduledAt?: number; occurrenceCount?: number; status?: ReminderStatus }): Promise<Reminder>;
     cancel(id: string): Promise<Reminder>;
     delete(id: string): Promise<void>;
   };

package/src/storage/memory-engine.ts

@@ -5,12 +5,14 @@
 import { randomUUID } from "node:crypto";
 import type {
   Conversation,
+  ConversationCreateInit,
+  ConversationStatusSnapshot,
   ConversationSummary,
   PendingSubagentResult,
 } from "../state.js";
 import type { MainMemory } from "../memory.js";
 import type { TodoItem } from "../todo-tools.js";
-import type { Reminder } from "../reminder-store.js";
+import type { Reminder, ReminderCreateInput, ReminderStatus } from "../reminder-store.js";
 import type { StorageEngine, VfsDirEntry, VfsStat } from "./engine.js";
 
 // ---------------------------------------------------------------------------
@@ -101,20 +103,61 @@ export class InMemoryEngine implements StorageEngine {
       return this.convs.get(conversationId);
     },
 
+    // In-memory storage has no separate archive blob, so both variants
+    // return the same conversation object.
+    getWithArchive: async (conversationId: string): Promise<Conversation | undefined> => {
+      return this.convs.get(conversationId);
+    },
+
+    getStatusSnapshot: async (
+      conversationId: string,
+    ): Promise<ConversationStatusSnapshot | undefined> => {
+      const c = this.convs.get(conversationId);
+      if (!c) return undefined;
+      return {
+        conversationId: c.conversationId,
+        updatedAt: c.updatedAt,
+        messageCount: c.messages.length,
+        hasPendingApprovals: Array.isArray(c.pendingApprovals) && c.pendingApprovals.length > 0,
+        hasContinuationMessages:
+          Array.isArray(c._continuationMessages) && c._continuationMessages.length > 0,
+        parentConversationId: c.parentConversationId ?? null,
+        ownerId: c.ownerId,
+        tenantId: c.tenantId,
+        runStatus: c.runStatus ?? null,
+      };
+    },
+
     create: async (
       ownerId?: string,
       title?: string,
       tenantId?: string | null,
+      init?: ConversationCreateInit,
     ): Promise<Conversation> => {
       const now = Date.now();
       const conv: Conversation = {
         conversationId: randomUUID(),
         title: normalizeTitle(title),
-        messages: [],
+        messages: init?.messages ?? [],
         ownerId: ownerId ?? DEFAULT_OWNER,
         tenantId: tenantId === undefined ? null : tenantId,
         createdAt: now,
         updatedAt: now,
+        ...(init?.parentConversationId !== undefined
+          ? { parentConversationId: init.parentConversationId }
+          : {}),
+        ...(init?.parentMessageId !== undefined
+          ? { parentMessageId: init.parentMessageId }
+          : {}),
+        ...(init?.threadMeta !== undefined
+          ? { threadMeta: init.threadMeta }
+          : {}),
+        ...(init?.subagentMeta !== undefined
+          ? { subagentMeta: init.subagentMeta }
+          : {}),
+        ...(init?.channelMeta !== undefined
+          ? { channelMeta: init.channelMeta }
+          : {}),
       };
       this.convs.set(conv.conversationId, conv);
       return conv;
@@ -180,6 +223,22 @@ export class InMemoryEngine implements StorageEngine {
       conv.runningCallbackSince = undefined;
       return conv;
     },
+
+    listThreads: async (
+      parentConversationId: string,
+    ): Promise<ConversationSummary[]> => {
+      const results: ConversationSummary[] = [];
+      for (const c of this.convs.values()) {
+        if (
+          c.parentConversationId === parentConversationId &&
+          typeof c.parentMessageId === "string"
+        ) {
+          results.push(this.toSummary(c));
+        }
+      }
+      results.sort((a, b) => b.updatedAt - a.updatedAt);
+      return results;
+    },
   };
 
   // -----------------------------------------------------------------------
@@ -237,14 +296,7 @@ export class InMemoryEngine implements StorageEngine {
       return results;
     },
 
-    create: async (input: {
-      task: string;
-      scheduledAt: number;
-      timezone?: string;
-      conversationId: string;
-      ownerId?: string;
-      tenantId?: string | null;
-    }): Promise<Reminder> => {
+    create: async (input: ReminderCreateInput): Promise<Reminder> => {
       const r: Reminder = {
         id: randomUUID(),
         task: input.task,
@@ -255,11 +307,22 @@ export class InMemoryEngine implements StorageEngine {
         conversationId: input.conversationId,
         ownerId: input.ownerId,
         tenantId: input.tenantId,
+        recurrence: input.recurrence ?? null,
+        occurrenceCount: 0,
       };
       this.reminderData.set(r.id, r);
       return r;
     },
 
+    update: async (id: string, fields: { scheduledAt?: number; occurrenceCount?: number; status?: ReminderStatus }): Promise<Reminder> => {
+      const r = this.reminderData.get(id);
+      if (!r) throw new Error(`Reminder ${id} not found`);
+      if (fields.scheduledAt !== undefined) r.scheduledAt = fields.scheduledAt;
+      if (fields.occurrenceCount !== undefined) r.occurrenceCount = fields.occurrenceCount;
+      if (fields.status !== undefined) r.status = fields.status;
+      return r;
+    },
+
     cancel: async (id: string): Promise<Reminder> => {
       const r = this.reminderData.get(id);
       if (!r) throw new Error(`Reminder ${id} not found`);
@@ -544,6 +607,7 @@ export class InMemoryEngine implements StorageEngine {
       messageCount: c.messages.length,
       hasPendingApprovals: (c.pendingApprovals?.length ?? 0) > 0,
       parentConversationId: c.parentConversationId,
+      parentMessageId: c.parentMessageId,
       channelMeta: c.channelMeta,
     };
   }

package/src/storage/postgres-engine.ts

@@ -66,6 +66,7 @@ export class PostgresEngine extends SqlStorageEngine {
   }
 
   async close(): Promise<void> {
+    this.flushEgressStats();
     await this.sql?.end();
   }
 

package/src/storage/schema.ts

@@ -174,4 +174,25 @@ export const migrations: Migration[] = [
       ];
     },
   },
+  {
+    version: 5,
+    name: "add_reminder_recurrence",
+    up: (d) => {
+      const jsonType = d === "sqlite" ? "TEXT" : "JSONB";
+      return [
+        `ALTER TABLE reminders ADD COLUMN recurrence ${jsonType}`,
+        `ALTER TABLE reminders ADD COLUMN occurrence_count INTEGER NOT NULL DEFAULT 0`,
+      ];
+    },
+  },
+  {
+    version: 6,
+    name: "add_thread_anchor",
+    up: () => [
+      `ALTER TABLE conversations ADD COLUMN parent_message_id TEXT`,
+      `CREATE INDEX IF NOT EXISTS idx_conversations_thread_anchor
+         ON conversations (parent_conversation_id, parent_message_id)
+         WHERE parent_message_id IS NOT NULL`,
+    ],
+  },
 ];