@poncho-ai/harness 0.37.2 → 0.38.0

package/src/storage/sql-dialect.ts

@@ -10,12 +10,13 @@
 import { randomUUID } from "node:crypto";
 import type {
   Conversation,
+  ConversationCreateInit,
   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";
 import { type DialectTag, migrations } from "./schema.js";
 
@@ -244,19 +245,30 @@ export abstract class SqlStorageEngine implements StorageEngine {
       ownerId?: string,
       title?: string,
       tenantId?: string | null,
+      init?: ConversationCreateInit,
     ): Promise<Conversation> => {
       const id = randomUUID();
       const now = Date.now();
       const conv: Conversation = {
         conversationId: id,
         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?.subagentMeta !== undefined
+          ? { subagentMeta: init.subagentMeta }
+          : {}),
+        ...(init?.channelMeta !== undefined
+          ? { channelMeta: init.channelMeta }
+          : {}),
       };
       const data = JSON.stringify(conv);
+      const channelMetaJson = conv.channelMeta ? JSON.stringify(conv.channelMeta) : null;
       await this.executor.run(
         rewrite(
           `INSERT INTO conversations (id, agent_id, tenant_id, owner_id, title, data, message_count, created_at, updated_at,
@@ -271,12 +283,12 @@ export abstract class SqlStorageEngine implements StorageEngine {
           conv.ownerId,
           conv.title,
           data,
-          0,
+          conv.messages.length,
           new Date(now).toISOString(),
           new Date(now).toISOString(),
-          null,
+          conv.parentConversationId ?? null,
           0,
-          null,
+          channelMetaJson,
         ],
       );
       return conv;
@@ -497,21 +509,15 @@ export abstract class SqlStorageEngine implements StorageEngine {
       return rows.map((r) => this.rowToReminder(r));
     },
 
-    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 id = randomUUID();
       const now = Date.now();
       const tid = normalizeTenant(input.tenantId);
+      const recurrenceJson = input.recurrence ? JSON.stringify(input.recurrence) : null;
       await this.executor.run(
         rewrite(
-          `INSERT INTO reminders (id, agent_id, tenant_id, owner_id, conversation_id, task, status, scheduled_at, timezone, created_at)
-           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+          `INSERT INTO reminders (id, agent_id, tenant_id, owner_id, conversation_id, task, status, scheduled_at, timezone, created_at, recurrence, occurrence_count)
+           VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`,
           this.dialect,
         ),
         [
@@ -525,6 +531,8 @@ export abstract class SqlStorageEngine implements StorageEngine {
           input.scheduledAt,
           input.timezone ?? null,
           new Date(now).toISOString(),
+          recurrenceJson,
+          0,
         ],
       );
       return {
@@ -537,9 +545,54 @@ export abstract class SqlStorageEngine implements StorageEngine {
         conversationId: input.conversationId,
         ownerId: input.ownerId,
         tenantId: input.tenantId,
+        recurrence: input.recurrence ?? null,
+        occurrenceCount: 0,
       };
     },
 
+    update: async (id: string, fields: { scheduledAt?: number; occurrenceCount?: number; status?: ReminderStatus }): Promise<Reminder> => {
+      const setClauses: string[] = [];
+      const params: unknown[] = [];
+      let idx = 1;
+      if (fields.scheduledAt !== undefined) {
+        setClauses.push(`scheduled_at = $${idx++}`);
+        params.push(fields.scheduledAt);
+      }
+      if (fields.occurrenceCount !== undefined) {
+        setClauses.push(`occurrence_count = $${idx++}`);
+        params.push(fields.occurrenceCount);
+      }
+      if (fields.status !== undefined) {
+        setClauses.push(`status = $${idx++}`);
+        params.push(fields.status);
+      }
+      if (setClauses.length === 0) {
+        // Nothing to update — just fetch
+        const row = await this.executor.get(
+          rewrite("SELECT * FROM reminders WHERE id = $1 AND agent_id = $2", this.dialect),
+          [id, this.agentId],
+        );
+        if (!row) throw new Error(`Reminder ${id} not found`);
+        return this.rowToReminder(row);
+      }
+      params.push(id, this.agentId);
+      const idIdx = idx++;
+      const agentIdx = idx++;
+      await this.executor.run(
+        rewrite(
+          `UPDATE reminders SET ${setClauses.join(", ")} WHERE id = $${idIdx} AND agent_id = $${agentIdx}`,
+          this.dialect,
+        ),
+        params,
+      );
+      const row = await this.executor.get(
+        rewrite("SELECT * FROM reminders WHERE id = $1 AND agent_id = $2", this.dialect),
+        [id, this.agentId],
+      );
+      if (!row) throw new Error(`Reminder ${id} not found`);
+      return this.rowToReminder(row);
+    },
+
     cancel: async (id: string): Promise<Reminder> => {
       await this.executor.run(
         rewrite(
@@ -918,6 +971,16 @@ export abstract class SqlStorageEngine implements StorageEngine {
 
   private rowToReminder(row: QueryRow): Reminder {
     const tid = row.tenant_id as string;
+    let recurrence: Reminder["recurrence"] = null;
+    if (row.recurrence) {
+      try {
+        recurrence = typeof row.recurrence === "string"
+          ? JSON.parse(row.recurrence)
+          : row.recurrence;
+      } catch {
+        recurrence = null;
+      }
+    }
     return {
       id: row.id as string,
       task: row.task as string,
@@ -928,6 +991,8 @@ export abstract class SqlStorageEngine implements StorageEngine {
       conversationId: row.conversation_id as string,
       ownerId: (row.owner_id as string) ?? undefined,
       tenantId: tid === DEFAULT_TENANT ? null : tid,
+      recurrence,
+      occurrenceCount: (row.occurrence_count as number) ?? 0,
     };
   }
 

package/src/storage/store-adapters.ts

@@ -6,13 +6,14 @@
 
 import type {
   Conversation,
+  ConversationCreateInit,
   ConversationStore,
   ConversationSummary,
   PendingSubagentResult,
 } from "../state.js";
 import type { MainMemory, MemoryStore } from "../memory.js";
 import type { TodoItem, TodoStore } from "../todo-tools.js";
-import type { Reminder, ReminderStore } from "../reminder-store.js";
+import type { Reminder, ReminderCreateInput, ReminderStatus, ReminderStore } from "../reminder-store.js";
 import type { StorageEngine } from "./engine.js";
 
 // ---------------------------------------------------------------------------
@@ -35,8 +36,12 @@ export function createConversationStoreFromEngine(
       engine.conversations.list(ownerId, tenantId),
     get: (conversationId: string) =>
       engine.conversations.get(conversationId),
-    create: (ownerId?: string, title?: string, tenantId?: string | null) =>
-      engine.conversations.create(ownerId, title, tenantId),
+    create: (
+      ownerId?: string,
+      title?: string,
+      tenantId?: string | null,
+      init?: ConversationCreateInit,
+    ) => engine.conversations.create(ownerId, title, tenantId, init),
     update: (conversation: Conversation) =>
       engine.conversations.update(conversation),
     rename: (conversationId: string, title: string) =>
@@ -86,14 +91,9 @@ export function createReminderStoreFromEngine(
 ): ReminderStore {
   return {
     list: () => engine.reminders.list(),
-    create: (input: {
-      task: string;
-      scheduledAt: number;
-      timezone?: string;
-      conversationId: string;
-      ownerId?: string;
-      tenantId?: string | null;
-    }) => engine.reminders.create(input),
+    create: (input: ReminderCreateInput) => engine.reminders.create(input),
+    update: (id: string, fields: { scheduledAt?: number; occurrenceCount?: number; status?: ReminderStatus }) =>
+      engine.reminders.update(id, fields),
     cancel: (id: string) => engine.reminders.cancel(id),
     delete: (id: string) => engine.reminders.delete(id),
   };

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/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");
+  });
 });