@poncho-ai/harness 0.37.2 → 0.39.0

package/src/vfs/bash-manager.ts

@@ -6,6 +6,7 @@ import { Bash } from "just-bash";
 import type {
   BashOptions,
   CommandName,
+  IFileSystem,
   NetworkConfig as JustBashNetworkConfig,
 } from "just-bash";
 import type { StorageEngine } from "../storage/engine.js";
@@ -65,6 +66,7 @@ function toBashOptions(
 
 export class BashEnvironmentManager {
   private environments = new Map<string, Bash>();
+  private filesystems = new Map<string, IFileSystem>();
   private readonly workingDir: string | null;
   private readonly bashOptions: Partial<BashOptions>;
 
@@ -79,11 +81,21 @@ export class BashEnvironmentManager {
     this.bashOptions = toBashOptions(bashConfig, network);
   }
 
+  /** Return the combined IFileSystem (VFS + optional /project mount) for a tenant. */
+  getFs(tenantId: string): IFileSystem {
+    let fs = this.filesystems.get(tenantId);
+    if (!fs) {
+      const adapter = new PonchoFsAdapter(this.engine, tenantId, this.limits);
+      fs = createBashFs(adapter, this.workingDir);
+      this.filesystems.set(tenantId, fs);
+    }
+    return fs;
+  }
+
   getOrCreate(tenantId: string): Bash {
     let bash = this.environments.get(tenantId);
     if (!bash) {
-      const adapter = new PonchoFsAdapter(this.engine, tenantId, this.limits);
-      const fs = createBashFs(adapter, this.workingDir);
+      const fs = this.getFs(tenantId);
       bash = new Bash({
         fs,
         cwd: "/",
@@ -112,9 +124,11 @@ export class BashEnvironmentManager {
 
   destroy(tenantId: string): void {
     this.environments.delete(tenantId);
+    this.filesystems.delete(tenantId);
   }
 
   destroyAll(): void {
     this.environments.clear();
+    this.filesystems.clear();
   }
 }

package/src/vfs/edit-file-tool.ts

@@ -3,10 +3,10 @@
 // ---------------------------------------------------------------------------
 
 import { defineTool, type ToolDefinition } from "@poncho-ai/sdk";
-import type { StorageEngine } from "../storage/engine.js";
+import type { IFileSystem } from "just-bash";
 
 export const createEditFileTool = (
-  engine: StorageEngine,
+  getFs: (tenantId: string) => IFileSystem,
 ): ToolDefinition => defineTool({
   name: "edit_file",
   description:
@@ -44,12 +44,13 @@ export const createEditFileTool = (
     if (!oldStr) throw new Error("old_str must not be empty");
 
     const tenantId = context.tenantId ?? "__default__";
-    const stat = await engine.vfs.stat(tenantId, filePath);
-    if (!stat) throw new Error(`File not found: ${filePath}`);
-    if (stat.type === "directory") throw new Error(`${filePath} is a directory`);
+    const fs = getFs(tenantId);
 
-    const buf = await engine.vfs.readFile(tenantId, filePath);
-    const content = Buffer.from(buf).toString("utf8");
+    if (!(await fs.exists(filePath))) throw new Error(`File not found: ${filePath}`);
+    const stat = await fs.stat(filePath);
+    if (stat.isDirectory) throw new Error(`${filePath} is a directory`);
+
+    const content = await fs.readFile(filePath);
 
     const first = content.indexOf(oldStr);
     if (first === -1) {
@@ -65,7 +66,7 @@ export const createEditFileTool = (
     }
 
     const updated = content.slice(0, first) + newStr + content.slice(first + oldStr.length);
-    await engine.vfs.writeFile(tenantId, filePath, new TextEncoder().encode(updated));
+    await fs.writeFile(filePath, updated);
 
     return { ok: true, path: filePath };
   },

package/src/vfs/read-file-tool.ts

@@ -1,12 +1,10 @@
 // ---------------------------------------------------------------------------
-// read_file tool – read files from the VFS, returning binary files (images,
-// PDFs) as FileContentPart references that the harness resolves lazily at
-// model-request time via the vfs:// scheme.
+// read_file tool – read files from the filesystem, returning binary files
+// (images, PDFs) as inline base64 media parts.
 // ---------------------------------------------------------------------------
 
 import { defineTool, type ToolDefinition } from "@poncho-ai/sdk";
-import type { StorageEngine } from "../storage/engine.js";
-import { VFS_SCHEME } from "../upload-store.js";
+import type { IFileSystem } from "just-bash";
 
 const MIME_MAP: Record<string, string> = {
   ".txt": "text/plain",
@@ -48,7 +46,7 @@ const isTextMime = (mime: string): boolean =>
   mime === "application/x-sh";
 
 export const createReadFileTool = (
-  engine: StorageEngine,
+  getFs: (tenantId: string) => IFileSystem,
 ): ToolDefinition => defineTool({
   name: "read_file",
   description:
@@ -73,29 +71,30 @@ export const createReadFileTool = (
     }
 
     const tenantId = context.tenantId ?? "__default__";
-    const stat = await engine.vfs.stat(tenantId, filePath);
-    if (!stat) {
+    const fs = getFs(tenantId);
+
+    if (!(await fs.exists(filePath))) {
       throw new Error(`File not found: ${filePath}`);
     }
-    if (stat.type === "directory") {
+    const stat = await fs.stat(filePath);
+    if (stat.isDirectory) {
       throw new Error(`${filePath} is a directory, not a file`);
     }
 
-    const mediaType = stat.mimeType ?? mimeFromPath(filePath) ?? "application/octet-stream";
+    const mediaType = mimeFromPath(filePath) ?? "application/octet-stream";
     const filename = filePath.split("/").pop() ?? filePath;
 
     // Text files: read and return inline
     if (isTextMime(mediaType)) {
-      const buf = await engine.vfs.readFile(tenantId, filePath);
-      const text = Buffer.from(buf).toString("utf8");
+      const text = await fs.readFile(filePath);
       return { filename, mediaType, content: text };
     }
 
-    // Images and PDFs: return a vfs:// reference that the harness resolves
-    // lazily at model-request time — the actual bytes never sit in context.
+    // Binary files (images, PDFs): read bytes and return as base64
+    const buf = await fs.readFileBuffer(filePath);
     return {
       type: "file",
-      data: `${VFS_SCHEME}${filePath}`,
+      data: Buffer.from(buf).toString("base64"),
       mediaType,
       filename,
     };

package/src/vfs/write-file-tool.ts

@@ -1,12 +1,12 @@
 // ---------------------------------------------------------------------------
-// write_file tool – create or overwrite a file in the VFS.
+// write_file tool – create or overwrite a file in the filesystem.
 // ---------------------------------------------------------------------------
 
 import { defineTool, type ToolDefinition } from "@poncho-ai/sdk";
-import type { StorageEngine } from "../storage/engine.js";
+import type { IFileSystem } from "just-bash";
 
 export const createWriteFileTool = (
-  engine: StorageEngine,
+  getFs: (tenantId: string) => IFileSystem,
 ): ToolDefinition => defineTool({
   name: "write_file",
   description:
@@ -35,14 +35,15 @@ export const createWriteFileTool = (
     if (!filePath) throw new Error("path is required");
 
     const tenantId = context.tenantId ?? "__default__";
+    const fs = getFs(tenantId);
 
     // Create parent directories
     const dir = filePath.slice(0, filePath.lastIndexOf("/"));
     if (dir) {
-      await engine.vfs.mkdir(tenantId, dir, true);
+      await fs.mkdir(dir, { recursive: true });
     }
 
-    await engine.vfs.writeFile(tenantId, filePath, new TextEncoder().encode(content));
+    await fs.writeFile(filePath, content);
 
     return { ok: true, path: filePath };
   },

package/test/orchestrator.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, it } from "vitest";
+import type { AgentEvent, Message } from "@poncho-ai/sdk";
+import {
+  loadRunHistory,
+  normalizeApprovalCheckpoint,
+  buildApprovalCheckpoints,
+  resolveRunRequest,
+  createTurnDraftState,
+  recordStandardTurnEvent,
+  executeConversationTurn,
+} from "../src/orchestrator/index.js";
+import type { Conversation } from "../src/state.js";
+
+const baseMessages: Message[] = [{ role: "user", content: "hello" }];
+
+const makeConversation = (overrides: Partial<Conversation> & Pick<Conversation, "messages">): Conversation => ({
+  conversationId: "conv_test",
+  title: "test",
+  ownerId: "local-owner",
+  tenantId: null,
+  createdAt: Date.now(),
+  updatedAt: Date.now(),
+  ...overrides,
+});
+
+describe("orchestrator helpers", () => {
+  it("falls back to user messages when harness history is unavailable", () => {
+    const conversation = makeConversation({
+      messages: baseMessages,
+      _harnessMessages: "invalid" as unknown as Message[],
+    });
+    const resolved = loadRunHistory(conversation);
+    expect(resolved.source).toBe("messages");
+    expect(resolved.shouldRebuildCanonical).toBe(true);
+    expect(resolved.messages).toEqual(baseMessages);
+  });
+
+  it("prefers continuation history when requested", () => {
+    const continuation: Message[] = [{ role: "assistant", content: "next" }];
+    const conversation = makeConversation({
+      messages: baseMessages,
+      _harnessMessages: baseMessages,
+      _continuationMessages: continuation,
+    });
+    const resolved = loadRunHistory(conversation, { preferContinuation: true });
+    expect(resolved.source).toBe("continuation");
+    expect(resolved.messages).toEqual(continuation);
+  });
+
+  it("normalizes legacy approval checkpoint payloads", () => {
+    const normalized = normalizeApprovalCheckpoint(
+      {
+        approvalId: "approval_1",
+        runId: "run_1",
+        tool: "read_file",
+        toolCallId: "tool_1",
+        input: {},
+        checkpointMessages: undefined as unknown as Message[],
+        baseMessageCount: -1,
+        pendingToolCalls: [
+          { id: "t2", name: "list_directory", input: {} },
+          { foo: "bar" } as unknown as { id: string; name: string; input: Record<string, unknown> },
+        ],
+      },
+      baseMessages,
+    );
+    expect(normalized.checkpointMessages).toEqual(baseMessages);
+    expect(normalized.baseMessageCount).toBe(0);
+    expect(normalized.pendingToolCalls).toEqual([{ id: "t2", name: "list_directory", input: {} }]);
+  });
+
+  it("builds checkpoint approvals with a canonical shape", () => {
+    const checkpoints = buildApprovalCheckpoints({
+      approvals: [
+        {
+          approvalId: "approval_1",
+          tool: "read_file",
+          toolCallId: "tool_1",
+          input: { path: "README.md" },
+        },
+      ],
+      runId: "run_1",
+      checkpointMessages: baseMessages,
+      baseMessageCount: 2,
+      pendingToolCalls: [{ id: "tool_2", name: "list_directory", input: {} }],
+    });
+    expect(checkpoints).toEqual([
+      {
+        approvalId: "approval_1",
+        runId: "run_1",
+        tool: "read_file",
+        toolCallId: "tool_1",
+        input: { path: "README.md" },
+        checkpointMessages: baseMessages,
+        baseMessageCount: 2,
+        pendingToolCalls: [{ id: "tool_2", name: "list_directory", input: {} }],
+      },
+    ]);
+  });
+
+  it("resolves run request by preferring continuation and preserves rebuild signal", () => {
+    const continuation: Message[] = [{ role: "assistant", content: "continuation" }];
+    const conversation = makeConversation({
+      messages: baseMessages,
+      _harnessMessages: "invalid" as unknown as Message[],
+      _continuationMessages: continuation,
+    });
+    const resolved = resolveRunRequest(conversation, {
+      conversationId: "conv_1",
+      messages: baseMessages,
+      preferContinuation: true,
+    });
+    expect(resolved.source).toBe("continuation");
+    expect(resolved.messages).toEqual(continuation);
+    expect(resolved.shouldRebuildCanonical).toBe(true);
+  });
+
+  it("records standard draft events for tool timeline and text", () => {
+    const draft = createTurnDraftState();
+    recordStandardTurnEvent(
+      draft,
+      { type: "tool:started", tool: "read_file", input: {} } as AgentEvent,
+    );
+    recordStandardTurnEvent(
+      draft,
+      { type: "tool:completed", tool: "read_file", duration: 42, output: {} } as AgentEvent,
+    );
+    recordStandardTurnEvent(
+      draft,
+      { type: "model:chunk", content: "done" } as AgentEvent,
+    );
+    expect(draft.toolTimeline).toEqual(["- start `read_file`", "- done `read_file` (42ms)"]);
+    expect(draft.assistantResponse).toBe("done");
+  });
+
+  it("executes a conversation turn through the shared executor", async () => {
+    const events: AgentEvent[] = [
+      { type: "run:started", runId: "run_1", agentId: "test" } as AgentEvent,
+      { type: "tool:started", tool: "list_directory", input: {} } as AgentEvent,
+      { type: "model:chunk", content: "hello" } as AgentEvent,
+      {
+        type: "run:completed",
+        runId: "run_1",
+        result: {
+          status: "completed" as const,
+          response: "hello",
+          steps: 2,
+          duration: 10,
+          tokens: { input: 1, output: 1, cached: 0 },
+          continuation: false,
+          continuationMessages: baseMessages,
+          contextTokens: 321,
+          contextWindow: 1000,
+        },
+      } as AgentEvent,
+    ];
+    const fakeHarness = {
+      async *runWithTelemetry() {
+        for (const event of events) yield event;
+      },
+    };
+    const seenTypes: string[] = [];
+    const result = await executeConversationTurn({
+      harness: fakeHarness as never,
+      runInput: { task: "test", messages: baseMessages, conversationId: "conv_1" } as never,
+      onEvent: (event) => {
+        seenTypes.push(event.type);
+      },
+    });
+    expect(result.latestRunId).toBe("run_1");
+    expect(result.runSteps).toBe(2);
+    expect(result.runContextTokens).toBe(321);
+    expect(result.draft.assistantResponse).toBe("hello");
+    expect(seenTypes).toEqual(["run:started", "tool:started", "model:chunk", "run:completed"]);
+  });
+});

package/test/reminder-store.test.ts

@@ -1,7 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { createReminderStore } from "../src/reminder-store.js";
+import { createReminderStore, computeNextOccurrence } from "../src/reminder-store.js";
 import { createReminderTools } from "../src/reminder-tools.js";
 import type { ToolContext } from "@poncho-ai/sdk";
+import type { Reminder, Recurrence } from "../src/reminder-store.js";
 
 describe("reminder store", () => {
   it("creates with memory provider by default", () => {
@@ -66,6 +67,128 @@ describe("reminder store", () => {
     const store = createReminderStore("agent-noexist", { provider: "memory" });
     await expect(store.cancel("does-not-exist")).rejects.toThrow("not found");
   });
+
+  it("creates a recurring reminder with recurrence config", async () => {
+    const store = createReminderStore("agent-recur", { provider: "memory" });
+    const reminder = await store.create({
+      task: "Daily standup",
+      scheduledAt: Date.now() + 60_000,
+      conversationId: "conv-5",
+      recurrence: { type: "daily", interval: 1 },
+    });
+    expect(reminder.recurrence).toEqual({ type: "daily", interval: 1 });
+    expect(reminder.occurrenceCount).toBe(0);
+  });
+
+  it("updates scheduledAt and occurrenceCount", async () => {
+    const store = createReminderStore("agent-update", { provider: "memory" });
+    const reminder = await store.create({
+      task: "Weekly report",
+      scheduledAt: Date.now() + 60_000,
+      conversationId: "conv-6",
+      recurrence: { type: "weekly" },
+    });
+    const newTime = Date.now() + 7 * 24 * 60 * 60 * 1000;
+    const updated = await store.update(reminder.id, {
+      scheduledAt: newTime,
+      occurrenceCount: 1,
+    });
+    expect(updated.scheduledAt).toBe(newTime);
+    expect(updated.occurrenceCount).toBe(1);
+    expect(updated.status).toBe("pending");
+  });
+
+  it("throws when updating a nonexistent reminder", async () => {
+    const store = createReminderStore("agent-update-err", { provider: "memory" });
+    await expect(store.update("nope", { scheduledAt: 123 })).rejects.toThrow("not found");
+  });
+});
+
+describe("computeNextOccurrence", () => {
+  const baseReminder = (recurrence: Recurrence, overrides?: Partial<Reminder>): Reminder => ({
+    id: "r1",
+    task: "test",
+    scheduledAt: new Date("2026-04-14T09:00:00Z").getTime(),
+    status: "pending",
+    createdAt: Date.now(),
+    conversationId: "c1",
+    recurrence,
+    occurrenceCount: 0,
+    ...overrides,
+  });
+
+  it("returns null for non-recurring reminder", () => {
+    const r = baseReminder(null as unknown as Recurrence, { recurrence: null });
+    expect(computeNextOccurrence(r)).toBeNull();
+  });
+
+  it("computes daily recurrence", () => {
+    const r = baseReminder({ type: "daily" });
+    const next = computeNextOccurrence(r)!;
+    expect(next).toBe(r.scheduledAt + 24 * 60 * 60 * 1000);
+  });
+
+  it("computes daily recurrence with interval", () => {
+    const r = baseReminder({ type: "daily", interval: 3 });
+    const next = computeNextOccurrence(r)!;
+    expect(next).toBe(r.scheduledAt + 3 * 24 * 60 * 60 * 1000);
+  });
+
+  it("computes weekly recurrence", () => {
+    const r = baseReminder({ type: "weekly" });
+    const next = computeNextOccurrence(r)!;
+    expect(next).toBe(r.scheduledAt + 7 * 24 * 60 * 60 * 1000);
+  });
+
+  it("computes weekly recurrence with daysOfWeek", () => {
+    // 2026-04-14 is a Tuesday (day 2)
+    const r = baseReminder({ type: "weekly", daysOfWeek: [2, 4] }); // Tue, Thu
+    const next = computeNextOccurrence(r)!;
+    // Next match after Tuesday should be Thursday (2 days later)
+    expect(next).toBe(r.scheduledAt + 2 * 24 * 60 * 60 * 1000);
+  });
+
+  it("wraps weekly daysOfWeek to next week", () => {
+    // 2026-04-14 is a Tuesday (day 2). Only Monday (1) in list → next week.
+    const r = baseReminder({ type: "weekly", daysOfWeek: [1] });
+    const next = computeNextOccurrence(r)!;
+    // Next Monday is 6 days later
+    expect(next).toBe(r.scheduledAt + 6 * 24 * 60 * 60 * 1000);
+  });
+
+  it("computes monthly recurrence", () => {
+    const r = baseReminder({ type: "monthly" });
+    const next = computeNextOccurrence(r)!;
+    const nextDate = new Date(next);
+    expect(nextDate.getUTCMonth()).toBe(4); // May (0-indexed)
+    expect(nextDate.getUTCDate()).toBe(14);
+  });
+
+  it("computes cron recurrence", () => {
+    // Every day at 10:00 UTC
+    const r = baseReminder({ type: "cron", expression: "0 10 * * *" });
+    const next = computeNextOccurrence(r)!;
+    const nextDate = new Date(next);
+    expect(nextDate.getUTCHours()).toBe(10);
+    expect(nextDate.getUTCMinutes()).toBe(0);
+  });
+
+  it("respects maxOccurrences", () => {
+    const r = baseReminder({ type: "daily", maxOccurrences: 3 }, { occurrenceCount: 2 });
+    expect(computeNextOccurrence(r)).toBeNull();
+  });
+
+  it("respects endsAt", () => {
+    const endsAt = new Date("2026-04-14T10:00:00Z").getTime();
+    // Daily would go to April 15, which is after endsAt
+    const r = baseReminder({ type: "daily", endsAt });
+    expect(computeNextOccurrence(r)).toBeNull();
+  });
+
+  it("returns null for cron with no expression", () => {
+    const r = baseReminder({ type: "cron" });
+    expect(computeNextOccurrence(r)).toBeNull();
+  });
 });
 
 describe("reminder tools", () => {
@@ -105,6 +228,44 @@ describe("reminder tools", () => {
     expect(all).toHaveLength(1);
   });
 
+  it("set_reminder creates a recurring reminder", async () => {
+    const store = createReminderStore("agent-tool-recur", { provider: "memory" });
+    const tools = createReminderTools(store);
+    const setTool = tools.find((t) => t.name === "set_reminder")!;
+    const future = new Date(Date.now() + 3600_000).toISOString();
+    const result = (await setTool.handler(
+      {
+        task: "Daily standup",
+        datetime: future,
+        recurrence: { type: "daily", interval: 1 },
+      },
+      makeContext(),
+    )) as {
+      ok: boolean;
+      reminder: { id: string; status: string; recurrence: { type: string }; occurrenceCount: number };
+    };
+    expect(result.ok).toBe(true);
+    expect(result.reminder.recurrence.type).toBe("daily");
+    expect(result.reminder.occurrenceCount).toBe(0);
+
+    const all = await store.list();
+    expect(all).toHaveLength(1);
+    expect(all[0].recurrence).toEqual({ type: "daily", interval: 1 });
+  });
+
+  it("set_reminder rejects invalid recurrence type", async () => {
+    const store = createReminderStore("agent-tool-bad-recur", { provider: "memory" });
+    const tools = createReminderTools(store);
+    const setTool = tools.find((t) => t.name === "set_reminder")!;
+    const future = new Date(Date.now() + 3600_000).toISOString();
+    await expect(
+      setTool.handler(
+        { task: "Bad", datetime: future, recurrence: { type: "hourly" } },
+        makeContext(),
+      ),
+    ).rejects.toThrow("Invalid recurrence type");
+  });
+
   it("set_reminder rejects past datetimes", async () => {
     const store = createReminderStore("agent-tool-past", { provider: "memory" });
     const tools = createReminderTools(store);
@@ -113,18 +274,24 @@ describe("reminder tools", () => {
     await expect(setTool.handler({ task: "Too late", datetime: past }, makeContext())).rejects.toThrow("future");
   });
 
-  it("list_reminders returns all reminders", async () => {
+  it("list_reminders returns all reminders with recurrence info", async () => {
     const store = createReminderStore("agent-tool-list", { provider: "memory" });
     await store.create({ task: "A", scheduledAt: Date.now() + 60_000, conversationId: "c1" });
-    await store.create({ task: "B", scheduledAt: Date.now() + 120_000, conversationId: "c2" });
+    await store.create({
+      task: "B",
+      scheduledAt: Date.now() + 120_000,
+      conversationId: "c2",
+      recurrence: { type: "weekly", daysOfWeek: [1, 3, 5] },
+    });
 
     const tools = createReminderTools(store);
     const listTool = tools.find((t) => t.name === "list_reminders")!;
     const result = (await listTool.handler({}, makeContext())) as {
-      reminders: Array<{ task: string }>;
+      reminders: Array<{ task: string; recurrence?: { type: string } }>;
       count: number;
     };
     expect(result.count).toBe(2);
+    expect(result.reminders[1].recurrence?.type).toBe("weekly");
   });
 
   it("list_reminders filters by status", async () => {
@@ -156,4 +323,26 @@ describe("reminder tools", () => {
     expect(result.ok).toBe(true);
     expect(result.reminder.status).toBe("cancelled");
   });
+
+  it("cancel_reminder stops recurring reminders", async () => {
+    const store = createReminderStore("agent-tool-cancel-recur", { provider: "memory" });
+    const r = await store.create({
+      task: "Stop repeating",
+      scheduledAt: Date.now() + 60_000,
+      conversationId: "c1",
+      recurrence: { type: "daily" },
+    });
+
+    const tools = createReminderTools(store);
+    const cancelTool = tools.find((t) => t.name === "cancel_reminder")!;
+    const result = (await cancelTool.handler({ id: r.id }, makeContext())) as {
+      ok: boolean;
+      reminder: { status: string };
+    };
+    expect(result.ok).toBe(true);
+    expect(result.reminder.status).toBe("cancelled");
+
+    const all = await store.list();
+    expect(all[0].status).toBe("cancelled");
+  });
 });

package/test/state.test.ts

@@ -47,4 +47,25 @@ describe("conversation store factory", () => {
     const found = await store.get(created.conversationId);
     expect(found?.title).toBe("layout");
   });
+
+  it("listThreads filters to children with parentMessageId set", async () => {
+    const store = createConversationStore();
+    const parent = await store.create("o", "Parent");
+    // Subagent — parentConversationId set, no parentMessageId
+    await store.create("o", "Subagent", null, {
+      parentConversationId: parent.conversationId,
+      subagentMeta: { task: "x", status: "running" },
+    });
+    // Thread — both set
+    const thread = await store.create("o", "Thread", null, {
+      parentConversationId: parent.conversationId,
+      parentMessageId: "anchor",
+      threadMeta: { snapshotLength: 1 },
+    });
+
+    const threads = await store.listThreads(parent.conversationId);
+    expect(threads).toHaveLength(1);
+    expect(threads[0].conversationId).toBe(thread.conversationId);
+    expect(threads[0].parentMessageId).toBe("anchor");
+  });
 });