@poncho-ai/harness 0.31.3 → 0.32.1

package/dist/index.js

@@ -1052,6 +1052,23 @@ The system auto-discovers all Telegram chats the bot has interacted with and sen
 
 The bot must have received at least one message from a user before it can send proactive messages to that chat (Telegram API requirement).
 
+#### One-off reminders
+
+Unlike cron jobs (which are recurring and static), reminders are one-off and dynamic \u2014 created by the agent during conversations. Enable in \`poncho.config.js\`:
+
+\`\`\`javascript
+export default {
+  reminders: {
+    enabled: true,
+    pollSchedule: '*/10 * * * *',
+  },
+};
+\`\`\`
+
+When enabled, the agent gets \`set_reminder\`, \`list_reminders\`, and \`cancel_reminder\` tools. If the original conversation is on a messaging channel, the reminder fires as a reply in that conversation. Otherwise, a new \`[reminder]\` conversation is created.
+
+Reminders are checked on a polling interval (configured by \`pollSchedule\`). Reminders due within the next poll window fire early rather than late.
+
 ### Email (Resend)
 
 #### 1. Set up Resend
@@ -1592,6 +1609,12 @@ export default {
   //   cdpUrl: 'wss://...',     // Or connect via CDP URL (alternative to provider)
   // },
 
+  // One-off reminders (enabled by default in new projects)
+  reminders: {
+    enabled: true,
+    // pollSchedule: '*/10 * * * *', // how often to check for due reminders
+  },
+
   // Headless mode: disable the built-in Web UI (API-only)
   // webUi: false,
 
@@ -2110,9 +2133,9 @@ var ponchoDocsTool = defineTool({
 
 // src/harness.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile9 } from "fs/promises";
-import { resolve as resolve11 } from "path";
-import { defineTool as defineTool7, getTextContent as getTextContent2 } from "@poncho-ai/sdk";
+import { readFile as readFile10 } from "fs/promises";
+import { resolve as resolve12 } from "path";
+import { defineTool as defineTool8, getTextContent as getTextContent2 } from "@poncho-ai/sdk";
 
 // src/upload-store.ts
 import { createHash as createHash2 } from "crypto";
@@ -3178,6 +3201,379 @@ var createTodoTools = (store) => {
   ];
 };
 
+// src/reminder-store.ts
+import { mkdir as mkdir5, readFile as readFile7, rename as rename3, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname4, resolve as resolve8 } from "path";
+var REMINDERS_FILE = "reminders.json";
+var STALE_CANCELLED_MS = 7 * 24 * 60 * 60 * 1e3;
+var writeJsonAtomic3 = async (filePath, payload) => {
+  await mkdir5(dirname4(filePath), { recursive: true });
+  const tmpPath = `${filePath}.tmp`;
+  await writeFile6(tmpPath, JSON.stringify(payload, null, 2), "utf8");
+  await rename3(tmpPath, filePath);
+};
+var isValidReminder = (item) => typeof item === "object" && item !== null && typeof item.id === "string" && typeof item.task === "string" && typeof item.scheduledAt === "number" && typeof item.status === "string";
+var parseReminderList = (raw) => {
+  if (!Array.isArray(raw)) return [];
+  return raw.filter(isValidReminder);
+};
+var pruneStale = (reminders) => {
+  const cutoff = Date.now() - STALE_CANCELLED_MS;
+  return reminders.filter(
+    (r) => r.status === "pending" || r.status === "cancelled" && r.createdAt > cutoff
+  );
+};
+var generateId2 = () => (globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`).slice(0, 8);
+var InMemoryReminderStore = class {
+  reminders = [];
+  async list() {
+    this.reminders = pruneStale(this.reminders);
+    return [...this.reminders];
+  }
+  async create(input) {
+    const reminder = {
+      id: generateId2(),
+      task: input.task,
+      scheduledAt: input.scheduledAt,
+      timezone: input.timezone,
+      status: "pending",
+      createdAt: Date.now(),
+      conversationId: input.conversationId,
+      ownerId: input.ownerId
+    };
+    this.reminders = pruneStale(this.reminders);
+    this.reminders.push(reminder);
+    return reminder;
+  }
+  async cancel(id) {
+    const reminder = this.reminders.find((r) => r.id === id);
+    if (!reminder) throw new Error(`Reminder "${id}" not found`);
+    if (reminder.status !== "pending") {
+      throw new Error(`Reminder "${id}" is already ${reminder.status}`);
+    }
+    reminder.status = "cancelled";
+    return reminder;
+  }
+  async delete(id) {
+    this.reminders = this.reminders.filter((r) => r.id !== id);
+  }
+};
+var FileReminderStore = class {
+  workingDir;
+  filePath = "";
+  constructor(workingDir) {
+    this.workingDir = workingDir;
+  }
+  async ensureFilePath() {
+    if (this.filePath) return this.filePath;
+    const identity = await ensureAgentIdentity(this.workingDir);
+    this.filePath = resolve8(getAgentStoreDirectory(identity), REMINDERS_FILE);
+    return this.filePath;
+  }
+  async readAll() {
+    try {
+      const fp = await this.ensureFilePath();
+      const raw = await readFile7(fp, "utf8");
+      return parseReminderList(JSON.parse(raw));
+    } catch {
+      return [];
+    }
+  }
+  async writeAll(reminders) {
+    const fp = await this.ensureFilePath();
+    await writeJsonAtomic3(fp, reminders);
+  }
+  async list() {
+    const all = await this.readAll();
+    const pruned = pruneStale(all);
+    if (pruned.length !== all.length) await this.writeAll(pruned);
+    return pruned;
+  }
+  async create(input) {
+    const reminder = {
+      id: generateId2(),
+      task: input.task,
+      scheduledAt: input.scheduledAt,
+      timezone: input.timezone,
+      status: "pending",
+      createdAt: Date.now(),
+      conversationId: input.conversationId,
+      ownerId: input.ownerId
+    };
+    let reminders = await this.readAll();
+    reminders = pruneStale(reminders);
+    reminders.push(reminder);
+    await this.writeAll(reminders);
+    return reminder;
+  }
+  async cancel(id) {
+    const reminders = await this.readAll();
+    const reminder = reminders.find((r) => r.id === id);
+    if (!reminder) throw new Error(`Reminder "${id}" not found`);
+    if (reminder.status !== "pending") {
+      throw new Error(`Reminder "${id}" is already ${reminder.status}`);
+    }
+    reminder.status = "cancelled";
+    await this.writeAll(reminders);
+    return reminder;
+  }
+  async delete(id) {
+    const reminders = await this.readAll();
+    await this.writeAll(reminders.filter((r) => r.id !== id));
+  }
+};
+var KVBackedReminderStore = class {
+  kv;
+  key;
+  ttl;
+  memoryFallback = new InMemoryReminderStore();
+  constructor(kv, key, ttl) {
+    this.kv = kv;
+    this.key = key;
+    this.ttl = ttl;
+  }
+  async readAll() {
+    try {
+      const raw = await this.kv.get(this.key);
+      if (!raw) return [];
+      return parseReminderList(JSON.parse(raw));
+    } catch {
+      return this.memoryFallback.list();
+    }
+  }
+  async writeAll(reminders) {
+    try {
+      const serialized = JSON.stringify(reminders);
+      if (typeof this.ttl === "number") {
+        await this.kv.setWithTtl(this.key, serialized, Math.max(1, this.ttl));
+      } else {
+        await this.kv.set(this.key, serialized);
+      }
+    } catch {
+    }
+  }
+  async list() {
+    const all = await this.readAll();
+    const pruned = pruneStale(all);
+    if (pruned.length !== all.length) await this.writeAll(pruned);
+    return pruned;
+  }
+  async create(input) {
+    let reminders;
+    try {
+      reminders = await this.readAll();
+    } catch {
+      return this.memoryFallback.create(input);
+    }
+    const reminder = {
+      id: generateId2(),
+      task: input.task,
+      scheduledAt: input.scheduledAt,
+      timezone: input.timezone,
+      status: "pending",
+      createdAt: Date.now(),
+      conversationId: input.conversationId,
+      ownerId: input.ownerId
+    };
+    reminders = pruneStale(reminders);
+    reminders.push(reminder);
+    await this.writeAll(reminders);
+    return reminder;
+  }
+  async cancel(id) {
+    let reminders;
+    try {
+      reminders = await this.readAll();
+    } catch {
+      return this.memoryFallback.cancel(id);
+    }
+    const reminder = reminders.find((r) => r.id === id);
+    if (!reminder) throw new Error(`Reminder "${id}" not found`);
+    if (reminder.status !== "pending") {
+      throw new Error(`Reminder "${id}" is already ${reminder.status}`);
+    }
+    reminder.status = "cancelled";
+    await this.writeAll(reminders);
+    return reminder;
+  }
+  async delete(id) {
+    let reminders;
+    try {
+      reminders = await this.readAll();
+    } catch {
+      return this.memoryFallback.delete(id);
+    }
+    await this.writeAll(reminders.filter((r) => r.id !== id));
+  }
+};
+var createReminderStore = (agentId, config, options) => {
+  const provider = config?.provider ?? "local";
+  const ttl = config?.ttl;
+  const workingDir = options?.workingDir ?? process.cwd();
+  if (provider === "local") {
+    return new FileReminderStore(workingDir);
+  }
+  if (provider === "memory") {
+    return new InMemoryReminderStore();
+  }
+  const kv = createRawKVStore(config);
+  if (kv) {
+    const key = `poncho:${STORAGE_SCHEMA_VERSION}:${slugifyStorageComponent(agentId)}:reminders`;
+    return new KVBackedReminderStore(kv, key, ttl);
+  }
+  return new InMemoryReminderStore();
+};
+
+// src/reminder-tools.ts
+import { defineTool as defineTool4 } from "@poncho-ai/sdk";
+var VALID_STATUSES2 = ["pending", "cancelled"];
+var createReminderTools = (store) => [
+  defineTool4({
+    name: "set_reminder",
+    description: "Set a one-time 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.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        task: {
+          type: "string",
+          description: "What to remind about"
+        },
+        datetime: {
+          type: "string",
+          description: "ISO 8601 datetime for when the reminder should 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."
+        }
+      },
+      required: ["task", "datetime"],
+      additionalProperties: false
+    },
+    handler: async (input, context) => {
+      const task = typeof input.task === "string" ? input.task.trim() : "";
+      if (!task) throw new Error("task is required");
+      const datetimeStr = typeof input.datetime === "string" ? input.datetime.trim() : "";
+      if (!datetimeStr) throw new Error("datetime is required");
+      const timezone = typeof input.timezone === "string" ? input.timezone.trim() : void 0;
+      let scheduledAt;
+      if (timezone && !datetimeStr.includes("Z") && !/[+-]\d{2}:\d{2}$/.test(datetimeStr)) {
+        try {
+          const formatted = new Intl.DateTimeFormat("en-US", {
+            timeZone: timezone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+            hour12: false
+          }).format(/* @__PURE__ */ new Date());
+          void formatted;
+        } catch {
+          throw new Error(`Invalid timezone: "${timezone}"`);
+        }
+        const baseDate = new Date(datetimeStr);
+        if (isNaN(baseDate.getTime())) {
+          throw new Error(`Invalid datetime: "${datetimeStr}"`);
+        }
+        const utcStr = baseDate.toLocaleString("en-US", { timeZone: "UTC" });
+        const tzStr = baseDate.toLocaleString("en-US", { timeZone: timezone });
+        const offsetMs = new Date(utcStr).getTime() - new Date(tzStr).getTime();
+        scheduledAt = baseDate.getTime() + offsetMs;
+      } else {
+        const parsed = new Date(datetimeStr);
+        if (isNaN(parsed.getTime())) {
+          throw new Error(`Invalid datetime: "${datetimeStr}"`);
+        }
+        scheduledAt = parsed.getTime();
+      }
+      if (scheduledAt <= Date.now()) {
+        throw new Error("Reminder datetime must be in the future");
+      }
+      const conversationId = context.conversationId || context.runId;
+      const reminder = await store.create({
+        task,
+        scheduledAt,
+        timezone,
+        conversationId
+      });
+      return {
+        ok: true,
+        reminder: {
+          id: reminder.id,
+          task: reminder.task,
+          scheduledAt: new Date(reminder.scheduledAt).toISOString(),
+          timezone: reminder.timezone ?? "UTC",
+          status: reminder.status
+        }
+      };
+    }
+  }),
+  defineTool4({
+    name: "list_reminders",
+    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.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: VALID_STATUSES2,
+          description: "Filter by status (omit to list all)"
+        }
+      },
+      additionalProperties: false
+    },
+    handler: async (input) => {
+      let reminders = await store.list();
+      const status = typeof input.status === "string" ? input.status : void 0;
+      if (status && VALID_STATUSES2.includes(status)) {
+        reminders = reminders.filter((r) => r.status === status);
+      }
+      return {
+        reminders: reminders.map((r) => ({
+          id: r.id,
+          task: r.task,
+          scheduledAt: new Date(r.scheduledAt).toISOString(),
+          timezone: r.timezone ?? "UTC",
+          status: r.status,
+          createdAt: new Date(r.createdAt).toISOString()
+        })),
+        count: reminders.length
+      };
+    }
+  }),
+  defineTool4({
+    name: "cancel_reminder",
+    description: "Cancel a pending reminder by its ID.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: {
+          type: "string",
+          description: "ID of the reminder to cancel"
+        }
+      },
+      required: ["id"],
+      additionalProperties: false
+    },
+    handler: async (input) => {
+      const id = typeof input.id === "string" ? input.id.trim() : "";
+      if (!id) throw new Error("id is required");
+      const cancelled = await store.cancel(id);
+      return {
+        ok: true,
+        reminder: {
+          id: cancelled.id,
+          task: cancelled.task,
+          scheduledAt: new Date(cancelled.scheduledAt).toISOString(),
+          status: cancelled.status
+        }
+      };
+    }
+  })
+];
+
 // src/mcp.ts
 var McpHttpError = class extends Error {
   status;
@@ -3621,8 +4017,8 @@ import { createAnthropic } from "@ai-sdk/anthropic";
 
 // src/openai-codex-auth.ts
 import { homedir as homedir3 } from "os";
-import { dirname as dirname4, resolve as resolve8 } from "path";
-import { mkdir as mkdir5, readFile as readFile7, chmod, writeFile as writeFile6, rm as rm3 } from "fs/promises";
+import { dirname as dirname5, resolve as resolve9 } from "path";
+import { mkdir as mkdir6, readFile as readFile8, chmod, writeFile as writeFile7, rm as rm3 } from "fs/promises";
 var OPENAI_CODEX_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
 var OPENAI_AUTH_ISSUER = "https://auth.openai.com";
 var REFRESH_TOKEN_GRACE_MS = 5 * 60 * 1e3;
@@ -3654,14 +4050,14 @@ var getOpenAICodexAuthFilePath = (config) => {
   const env = defaultedConfig(config);
   const fromEnv = process.env[env.authFilePathEnv];
   if (typeof fromEnv === "string" && fromEnv.trim().length > 0) {
-    return resolve8(fromEnv);
+    return resolve9(fromEnv);
   }
-  return resolve8(homedir3(), ".poncho", "auth", "openai-codex.json");
+  return resolve9(homedir3(), ".poncho", "auth", "openai-codex.json");
 };
 var readOpenAICodexSession = async (config) => {
   const filePath = getOpenAICodexAuthFilePath(config);
   try {
-    const content = await readFile7(filePath, "utf8");
+    const content = await readFile8(filePath, "utf8");
     const parsed = JSON.parse(content);
     if (typeof parsed.refreshToken !== "string" || parsed.refreshToken.length === 0) {
       return void 0;
@@ -3678,12 +4074,12 @@ var readOpenAICodexSession = async (config) => {
 };
 var writeOpenAICodexSession = async (session, config) => {
   const filePath = getOpenAICodexAuthFilePath(config);
-  await mkdir5(dirname4(filePath), { recursive: true });
+  await mkdir6(dirname5(filePath), { recursive: true });
   const payload = {
     ...session,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile6(filePath, `${JSON.stringify(payload, null, 2)}
+  await writeFile7(filePath, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   await chmod(filePath, 384);
 };
@@ -3996,8 +4392,8 @@ var createModelProvider = (provider, config) => {
 };
 
 // src/skill-context.ts
-import { readFile as readFile8, readdir as readdir2, stat } from "fs/promises";
-import { dirname as dirname5, resolve as resolve9, normalize } from "path";
+import { readFile as readFile9, readdir as readdir2, stat } from "fs/promises";
+import { dirname as dirname6, resolve as resolve10, normalize } from "path";
 import YAML3 from "yaml";
 var DEFAULT_SKILL_DIRS = ["skills"];
 var resolveSkillDirs = (workingDir, extraPaths) => {
@@ -4009,7 +4405,7 @@ var resolveSkillDirs = (workingDir, extraPaths) => {
       }
     }
   }
-  return dirs.map((d) => resolve9(workingDir, d));
+  return dirs.map((d) => resolve10(workingDir, d));
 };
 var FRONTMATTER_PATTERN3 = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
 var asRecord2 = (value) => typeof value === "object" && value !== null ? value : {};
@@ -4078,7 +4474,7 @@ var collectSkillManifests = async (directory) => {
   const entries = await readdir2(directory, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const fullPath = resolve9(directory, entry.name);
+    const fullPath = resolve10(directory, entry.name);
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     if (entry.isSymbolicLink()) {
@@ -4113,13 +4509,13 @@ var loadSkillMetadata = async (workingDir, extraSkillPaths) => {
   const seen = /* @__PURE__ */ new Set();
   for (const manifest of allManifests) {
     try {
-      const content = await readFile8(manifest, "utf8");
+      const content = await readFile9(manifest, "utf8");
       const parsed = parseSkillFrontmatter(content);
       if (parsed && !seen.has(parsed.name)) {
         seen.add(parsed.name);
         skills.push({
           ...parsed,
-          skillDir: dirname5(manifest),
+          skillDir: dirname6(manifest),
           skillPath: manifest
         });
       }
@@ -4158,7 +4554,7 @@ ${xmlSkills}
 };
 var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 var loadSkillInstructions = async (skill) => {
-  const content = await readFile8(skill.skillPath, "utf8");
+  const content = await readFile9(skill.skillPath, "utf8");
   const match = content.match(FRONTMATTER_PATTERN3);
   return match ? match[2].trim() : content.trim();
 };
@@ -4167,11 +4563,11 @@ var readSkillResource = async (skill, relativePath) => {
   if (normalized.startsWith("..") || normalized.startsWith("/")) {
     throw new Error("Path must be relative and within the skill directory");
   }
-  const fullPath = resolve9(skill.skillDir, normalized);
+  const fullPath = resolve10(skill.skillDir, normalized);
   if (!fullPath.startsWith(skill.skillDir)) {
     throw new Error("Path escapes the skill directory");
   }
-  return await readFile8(fullPath, "utf8");
+  return await readFile9(fullPath, "utf8");
 };
 var MAX_INSTRUCTIONS_PER_SKILL = 1200;
 var loadSkillContext = async (workingDir) => {
@@ -4288,16 +4684,16 @@ function convertSchema(schema) {
 }
 
 // src/skill-tools.ts
-import { defineTool as defineTool4 } from "@poncho-ai/sdk";
+import { defineTool as defineTool5 } from "@poncho-ai/sdk";
 import { access as access2, readdir as readdir3, stat as stat2 } from "fs/promises";
-import { extname, normalize as normalize2, resolve as resolve10, sep as sep2 } from "path";
+import { extname, normalize as normalize2, resolve as resolve11, sep as sep2 } from "path";
 import { pathToFileURL } from "url";
 import { createJiti as createJiti2 } from "jiti";
 var createSkillTools = (skills, options) => {
   const skillsByName = new Map(skills.map((skill) => [skill.name, skill]));
   const knownNames = skills.length > 0 ? skills.map((skill) => skill.name).join(", ") : "(none)";
   return [
-    defineTool4({
+    defineTool5({
       name: "activate_skill",
       description: `Load the full instructions for an available skill. Use this when a user's request matches a skill's description. Available skills: ${knownNames}`,
       inputSchema: {
@@ -4334,7 +4730,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool4({
+    defineTool5({
       name: "deactivate_skill",
       description: "Deactivate a previously activated skill and update scoped tool availability.",
       inputSchema: {
@@ -4363,7 +4759,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool4({
+    defineTool5({
       name: "list_active_skills",
       description: "List currently active skills with scoped MCP tools.",
       inputSchema: {
@@ -4375,7 +4771,7 @@ var createSkillTools = (skills, options) => {
         activeSkills: options?.onListActiveSkills ? options.onListActiveSkills() : []
       })
     }),
-    defineTool4({
+    defineTool5({
       name: "read_skill_resource",
       description: `Read a file from a skill's directory (references, scripts, assets). Use relative paths from the skill root. Available skills: ${knownNames}`,
       inputSchema: {
@@ -4415,7 +4811,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool4({
+    defineTool5({
       name: "list_skill_scripts",
       description: `List JavaScript/TypeScript script files available under a skill directory (recursive). Available skills: ${knownNames}`,
       inputSchema: {
@@ -4450,7 +4846,7 @@ var createSkillTools = (skills, options) => {
         }
       }
     }),
-    defineTool4({
+    defineTool5({
       name: "run_skill_script",
       description: `Run a JavaScript/TypeScript module in a skill or project directory. Uses default export function or named run/main/handler function. Available skills: ${knownNames}`,
       inputSchema: {
@@ -4548,7 +4944,7 @@ var collectScriptFiles = async (directory) => {
     if (entry.name === "node_modules") {
       continue;
     }
-    const fullPath = resolve10(directory, entry.name);
+    const fullPath = resolve11(directory, entry.name);
     let isDir = entry.isDirectory();
     let isFile = entry.isFile();
     if (entry.isSymbolicLink()) {
@@ -4587,8 +4983,8 @@ var normalizeScriptPolicyPath = (relativePath) => {
 };
 var resolveScriptPath = (baseDir, relativePath, containmentDir) => {
   const normalized = normalizeScriptPolicyPath(relativePath);
-  const fullPath = resolve10(baseDir, normalized);
-  const boundary = resolve10(containmentDir ?? baseDir);
+  const fullPath = resolve11(baseDir, normalized);
+  const boundary = resolve11(containmentDir ?? baseDir);
   if (!fullPath.startsWith(`${boundary}${sep2}`) && fullPath !== boundary) {
     throw new Error("Script path must stay inside the allowed directory");
   }
@@ -4665,7 +5061,7 @@ var extractRunnableFunction = (value) => {
 
 // src/search-tools.ts
 import { load as cheerioLoad } from "cheerio";
-import { defineTool as defineTool5 } from "@poncho-ai/sdk";
+import { defineTool as defineTool6 } from "@poncho-ai/sdk";
 var SEARCH_UA = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36";
 var FETCH_TIMEOUT_MS = 15e3;
 var SEARCH_MAX_RETRIES = 4;
@@ -4694,8 +5090,8 @@ function applyRateLimitCooldown(retryAfterHeader) {
 async function runWithSearchThrottle(fn) {
   const previous = searchQueue;
   let release;
-  searchQueue = new Promise((resolve13) => {
-    release = resolve13;
+  searchQueue = new Promise((resolve14) => {
+    release = resolve14;
   });
   await previous.catch(() => {
   });
@@ -4787,7 +5183,7 @@ function extractReadableText($, maxLength) {
   return { title, content };
 }
 var createSearchTools = () => [
-  defineTool5({
+  defineTool6({
     name: "web_search",
     description: "Search the web and return a list of results (title, URL, snippet). Use this instead of opening a browser when you need to find information online.",
     inputSchema: {
@@ -4826,7 +5222,7 @@ var createSearchTools = () => [
       }
     }
   }),
-  defineTool5({
+  defineTool6({
     name: "web_fetch",
     description: "Fetch a web page and return its text content (HTML tags stripped). Useful for reading articles, documentation, or any web page without opening a browser.",
     inputSchema: {
@@ -4872,9 +5268,9 @@ var createSearchTools = () => [
 ];
 
 // src/subagent-tools.ts
-import { defineTool as defineTool6 } from "@poncho-ai/sdk";
+import { defineTool as defineTool7 } from "@poncho-ai/sdk";
 var createSubagentTools = (manager) => [
-  defineTool6({
+  defineTool7({
     name: "spawn_subagent",
     description: "Spawn a subagent to work on a task in the background. Returns immediately with a subagent ID. The subagent runs independently and its result will be delivered to you as a message in the conversation when it completes.\n\nGuidelines:\n- Spawn all needed subagents in a SINGLE response (they run concurrently), then end your turn with a brief message to the user.\n- Do NOT spawn more subagents in follow-up steps. Wait for results to be delivered before deciding if more work is needed.\n- Prefer doing work yourself for simple or quick tasks. Spawn subagents for substantial, self-contained work.\n- The subagent has no memory of your conversation -- write thorough, self-contained instructions in the task.",
     inputSchema: {
@@ -4906,7 +5302,7 @@ var createSubagentTools = (manager) => [
       return { subagentId, status: "running" };
     }
   }),
-  defineTool6({
+  defineTool7({
     name: "message_subagent",
     description: "Send a follow-up message to a completed or stopped subagent. The subagent restarts in the background and its result will be delivered to you as a message when it completes. Only works when the subagent is not currently running.",
     inputSchema: {
@@ -4934,7 +5330,7 @@ var createSubagentTools = (manager) => [
       return { subagentId: id, status: "running" };
     }
   }),
-  defineTool6({
+  defineTool7({
     name: "stop_subagent",
     description: "Stop a running subagent. The subagent's conversation is preserved but it will stop processing. Use this to cancel work that is no longer needed.",
     inputSchema: {
@@ -4957,7 +5353,7 @@ var createSubagentTools = (manager) => [
       return { message: `Subagent "${subagentId}" has been stopped.` };
     }
   }),
-  defineTool6({
+  defineTool7({
     name: "list_subagents",
     description: "List all subagents that have been spawned in this conversation. Returns each subagent's ID, original task, current status, and message count. Use this to look up subagent IDs before calling message_subagent or stop_subagent.",
     inputSchema: {
@@ -5632,6 +6028,7 @@ var AgentHarness = class _AgentHarness {
   skillContextWindow = "";
   memoryStore;
   todoStore;
+  reminderStore;
   loadedConfig;
   loadedSkills = [];
   skillFingerprint = "";
@@ -5726,7 +6123,7 @@ var AgentHarness = class _AgentHarness {
     }
   }
   createGetToolResultByIdTool() {
-    return defineTool7({
+    return defineTool8({
       name: "get_tool_result_by_id",
       description: "Retrieve a previously archived full tool result by id for the current conversation. Use this when older tool outputs were truncated in prompt history.",
       inputSchema: {
@@ -6118,8 +6515,8 @@ var AgentHarness = class _AgentHarness {
       return false;
     }
     try {
-      const agentFilePath = resolve11(this.workingDir, "AGENT.md");
-      const rawContent = await readFile9(agentFilePath, "utf8");
+      const agentFilePath = resolve12(this.workingDir, "AGENT.md");
+      const rawContent = await readFile10(agentFilePath, "utf8");
       if (rawContent === this.agentFileFingerprint) {
         return false;
       }
@@ -6188,8 +6585,8 @@ var AgentHarness = class _AgentHarness {
     }
   }
   async initialize() {
-    const agentFilePath = resolve11(this.workingDir, "AGENT.md");
-    const agentRawContent = await readFile9(agentFilePath, "utf8");
+    const agentFilePath = resolve12(this.workingDir, "AGENT.md");
+    const agentRawContent = await readFile10(agentFilePath, "utf8");
     this.parsedAgent = parseAgentMarkdown(agentRawContent);
     this.agentFileFingerprint = agentRawContent;
     const identity = await ensureAgentIdentity(this.workingDir);
@@ -6232,6 +6629,14 @@ var AgentHarness = class _AgentHarness {
         this.registerIfMissing(tool);
       }
     }
+    if (config?.reminders?.enabled) {
+      this.reminderStore = createReminderStore(agentId, stateConfig, { workingDir: this.workingDir });
+      for (const tool of createReminderTools(this.reminderStore)) {
+        if (this.isToolEnabled(tool.name)) {
+          this.registerIfMissing(tool);
+        }
+      }
+    }
     if (config?.browser) {
       await this.initBrowserTools(config).catch((e) => {
         console.warn(
@@ -6296,14 +6701,14 @@ var AgentHarness = class _AgentHarness {
       const filePath = pathResolve(stateDir, `${sessionId}.json`);
       return {
         async save(json) {
-          const { mkdir: mkdir7, writeFile: writeFile8 } = await import("fs/promises");
-          await mkdir7(stateDir, { recursive: true });
-          await writeFile8(filePath, json, "utf8");
+          const { mkdir: mkdir8, writeFile: writeFile9 } = await import("fs/promises");
+          await mkdir8(stateDir, { recursive: true });
+          await writeFile9(filePath, json, "utf8");
         },
         async load() {
-          const { readFile: readFile11 } = await import("fs/promises");
+          const { readFile: readFile12 } = await import("fs/promises");
           try {
-            return await readFile11(filePath, "utf8");
+            return await readFile12(filePath, "utf8");
           } catch {
             return void 0;
           }
@@ -6369,7 +6774,7 @@ var AgentHarness = class _AgentHarness {
     let browserMod;
     try {
       const { existsSync } = await import("fs");
-      const { join, dirname: dirname7 } = await import("path");
+      const { join, dirname: dirname8 } = await import("path");
       const { pathToFileURL: pathToFileURL2 } = await import("url");
       let searchDir = this.workingDir;
       let entryPath;
@@ -6379,7 +6784,7 @@ var AgentHarness = class _AgentHarness {
           entryPath = candidate;
           break;
         }
-        const parent = dirname7(searchDir);
+        const parent = dirname8(searchDir);
         if (parent === searchDir) break;
         searchDir = parent;
       }
@@ -6484,9 +6889,9 @@ var AgentHarness = class _AgentHarness {
           for await (const event of this.run(input)) {
             eventQueue.push(event);
             if (queueResolve) {
-              const resolve13 = queueResolve;
+              const resolve14 = queueResolve;
               queueResolve = null;
-              resolve13();
+              resolve14();
             }
           }
         } catch (error) {
@@ -6505,8 +6910,8 @@ var AgentHarness = class _AgentHarness {
           if (eventQueue.length > 0) {
             yield eventQueue.shift();
           } else if (!generatorDone) {
-            await new Promise((resolve13) => {
-              queueResolve = resolve13;
+            await new Promise((resolve14) => {
+              queueResolve = resolve14;
             });
           }
         }
@@ -6653,7 +7058,10 @@ ${boundedMainMemory.trim()}` : "";
       const promptWithSkills = this.skillContextWindow ? `${agentPrompt}${developmentContext}
 
 ${this.skillContextWindow}${browserContext}` : `${agentPrompt}${developmentContext}${browserContext}`;
-      return `${promptWithSkills}${memoryContext}
+      const timeContext = this.reminderStore ? `
+
+Current UTC time: ${(/* @__PURE__ */ new Date()).toISOString()}` : "";
+      return `${promptWithSkills}${memoryContext}${timeContext}
 
 ## Execution Integrity
 
@@ -7126,8 +7534,8 @@ ${textContent}` };
               let timer;
               nextPart = await Promise.race([
                 fullStreamIterator.next(),
-                new Promise((resolve13) => {
-                  timer = setTimeout(() => resolve13(null), effectiveTimeout);
+                new Promise((resolve14) => {
+                  timer = setTimeout(() => resolve14(null), effectiveTimeout);
                 })
               ]);
               clearTimeout(timer);
@@ -7462,7 +7870,7 @@ ${textContent}` };
           const raced = await Promise.race([
             this.dispatcher.executeBatch(approvedCalls, toolContext),
             new Promise(
-              (resolve13) => setTimeout(() => resolve13(TOOL_DEADLINE_SENTINEL), toolDeadlineRemainingMs)
+              (resolve14) => setTimeout(() => resolve14(TOOL_DEADLINE_SENTINEL), toolDeadlineRemainingMs)
             )
           ]);
           if (raced === TOOL_DEADLINE_SENTINEL) {
@@ -7853,8 +8261,8 @@ var LatitudeCapture = class {
 
 // src/state.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { mkdir as mkdir6, readFile as readFile10, readdir as readdir4, rename as rename3, rm as rm4, writeFile as writeFile7 } from "fs/promises";
-import { dirname as dirname6, resolve as resolve12 } from "path";
+import { mkdir as mkdir7, readFile as readFile11, readdir as readdir4, rename as rename4, rm as rm4, writeFile as writeFile8 } from "fs/promises";
+import { dirname as dirname7, resolve as resolve13 } from "path";
 var DEFAULT_OWNER = "local-owner";
 var LOCAL_STATE_FILE = "state.json";
 var CONVERSATIONS_DIRECTORY = "conversations";
@@ -7869,11 +8277,11 @@ var toStoreIdentity = async ({
   }
   return { name: ensured.name, id: agentId };
 };
-var writeJsonAtomic3 = async (filePath, payload) => {
-  await mkdir6(dirname6(filePath), { recursive: true });
+var writeJsonAtomic4 = async (filePath, payload) => {
+  await mkdir7(dirname7(filePath), { recursive: true });
   const tmpPath = `${filePath}.tmp`;
-  await writeFile7(tmpPath, JSON.stringify(payload, null, 2), "utf8");
-  await rename3(tmpPath, filePath);
+  await writeFile8(tmpPath, JSON.stringify(payload, null, 2), "utf8");
+  await rename4(tmpPath, filePath);
 };
 var formatUtcTimestamp = (value) => new Date(value).toISOString().replace(/[-:]/g, "").replace(/\.\d{3}Z$/, "Z");
 var normalizeTitle = (title) => {
@@ -8061,8 +8469,8 @@ var FileConversationStore = class {
       agentId: this.agentId
     });
     const agentDir = getAgentStoreDirectory(identity);
-    const conversationsDir = resolve12(agentDir, CONVERSATIONS_DIRECTORY);
-    const indexPath = resolve12(conversationsDir, LOCAL_CONVERSATION_INDEX_FILE);
+    const conversationsDir = resolve13(agentDir, CONVERSATIONS_DIRECTORY);
+    const indexPath = resolve13(conversationsDir, LOCAL_CONVERSATION_INDEX_FILE);
     this.paths = { conversationsDir, indexPath };
     return this.paths;
   }
@@ -8072,13 +8480,13 @@ var FileConversationStore = class {
       schemaVersion: STORAGE_SCHEMA_VERSION,
       conversations: Array.from(this.conversations.values()).sort((a, b) => b.updatedAt - a.updatedAt)
     };
-    await writeJsonAtomic3(indexPath, payload);
+    await writeJsonAtomic4(indexPath, payload);
   }
   async readConversationFile(fileName) {
     const { conversationsDir } = await this.resolvePaths();
-    const filePath = resolve12(conversationsDir, fileName);
+    const filePath = resolve13(conversationsDir, fileName);
     try {
-      const raw = await readFile10(filePath, "utf8");
+      const raw = await readFile11(filePath, "utf8");
       return JSON.parse(raw);
     } catch {
       return void 0;
@@ -8124,7 +8532,7 @@ var FileConversationStore = class {
     this.loaded = true;
     const { indexPath } = await this.resolvePaths();
     try {
-      const raw = await readFile10(indexPath, "utf8");
+      const raw = await readFile11(indexPath, "utf8");
       const parsed = JSON.parse(raw);
       for (const conversation of parsed.conversations ?? []) {
         this.conversations.set(conversation.conversationId, conversation);
@@ -8147,9 +8555,9 @@ var FileConversationStore = class {
     const { conversationsDir } = await this.resolvePaths();
     const existing = this.conversations.get(conversation.conversationId);
     const fileName = existing?.fileName ?? this.resolveConversationFileName(conversation);
-    const filePath = resolve12(conversationsDir, fileName);
+    const filePath = resolve13(conversationsDir, fileName);
     this.writing = this.writing.then(async () => {
-      await writeJsonAtomic3(filePath, conversation);
+      await writeJsonAtomic4(filePath, conversation);
       this.conversations.set(conversation.conversationId, {
         conversationId: conversation.conversationId,
         title: conversation.title,
@@ -8245,7 +8653,7 @@ var FileConversationStore = class {
     if (removed) {
       this.writing = this.writing.then(async () => {
         if (existing) {
-          await rm4(resolve12(conversationsDir, existing.fileName), { force: true });
+          await rm4(resolve13(conversationsDir, existing.fileName), { force: true });
         }
         await this.writeIndex();
       });
@@ -8267,14 +8675,14 @@ var FileConversationStore = class {
     const summary = this.conversations.get(conversationId);
     if (!summary) return void 0;
     const { conversationsDir } = await this.resolvePaths();
-    const filePath = resolve12(conversationsDir, summary.fileName);
+    const filePath = resolve13(conversationsDir, summary.fileName);
     let result;
     this.writing = this.writing.then(async () => {
       const conv = await this.readConversationFile(summary.fileName);
       if (!conv) return;
       conv.runningCallbackSince = void 0;
       conv.updatedAt = Date.now();
-      await writeJsonAtomic3(filePath, conv);
+      await writeJsonAtomic4(filePath, conv);
       this.conversations.set(conversationId, {
         ...summary,
         updatedAt: conv.updatedAt
@@ -8306,7 +8714,7 @@ var FileStateStore = class {
       workingDir: this.workingDir,
       agentId: this.agentId
     });
-    this.filePath = resolve12(getAgentStoreDirectory(identity), LOCAL_STATE_FILE);
+    this.filePath = resolve13(getAgentStoreDirectory(identity), LOCAL_STATE_FILE);
   }
   isExpired(state) {
     return typeof this.ttlMs === "number" && Date.now() - state.updatedAt > this.ttlMs;
@@ -8318,7 +8726,7 @@ var FileStateStore = class {
     }
     this.loaded = true;
     try {
-      const raw = await readFile10(this.filePath, "utf8");
+      const raw = await readFile11(this.filePath, "utf8");
       const parsed = JSON.parse(raw);
       for (const state of parsed.states ?? []) {
         this.states.set(state.runId, state);
@@ -8331,7 +8739,7 @@ var FileStateStore = class {
       states: Array.from(this.states.values())
     };
     this.writing = this.writing.then(async () => {
-      await writeJsonAtomic3(this.filePath, payload);
+      await writeJsonAtomic4(this.filePath, payload);
     });
     await this.writing;
   }
@@ -9019,7 +9427,7 @@ var createConversationStore = (config, options) => {
 };
 
 // src/index.ts
-import { defineTool as defineTool8 } from "@poncho-ai/sdk";
+import { defineTool as defineTool9 } from "@poncho-ai/sdk";
 export {
   AgentHarness,
   InMemoryConversationStore,
@@ -9046,13 +9454,15 @@ export {
   createMemoryStore,
   createMemoryTools,
   createModelProvider,
+  createReminderStore,
+  createReminderTools,
   createSearchTools,
   createSkillTools,
   createStateStore,
   createSubagentTools,
   createUploadStore,
   createWriteTool,
-  defineTool8 as defineTool,
+  defineTool9 as defineTool,
   deleteOpenAICodexSession,
   deriveUploadKey,
   ensureAgentIdentity,