@poncho-ai/cli 0.11.1 → 0.12.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/cli@0.11.1 build /home/runner/work/poncho-ai/poncho-ai/packages/cli
+> @poncho-ai/cli@0.12.0 build /home/runner/work/poncho-ai/poncho-ai/packages/cli
 > tsup src/index.ts src/cli.ts --format esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -8,11 +8,11 @@
 CLI Target: es2022
 ESM Build start
 ESM dist/cli.js                          94.00 B
-ESM dist/run-interactive-ink-7FP5PT7Q.js 53.83 KB
-ESM dist/chunk-T2F6ICXI.js               226.37 KB
+ESM dist/run-interactive-ink-64QEOUXL.js 53.83 KB
 ESM dist/index.js                        857.00 B
-ESM ⚡️ Build success in 54ms
+ESM dist/chunk-XIFWXRUB.js               241.46 KB
+ESM ⚡️ Build success in 59ms
 DTS Build start
-DTS ⚡️ Build success in 3582ms
+DTS ⚡️ Build success in 3442ms
 DTS dist/cli.d.ts   20.00 B
-DTS dist/index.d.ts 3.36 KB
+DTS dist/index.d.ts 3.56 KB

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @poncho-ai/cli
 
+## 0.12.0
+
+### Minor Changes
+
+- [#8](https://github.com/cesr/poncho-ai/pull/8) [`658bc54`](https://github.com/cesr/poncho-ai/commit/658bc54d391cb0b58aa678a2b86cd617eebdd8aa) Thanks [@cesr](https://github.com/cesr)! - Add cron job support for scheduled agent tasks. Define recurring jobs in AGENT.md frontmatter with schedule, task, and optional timezone. Includes in-process scheduler for local dev with hot-reload, HTTP endpoint for Vercel/serverless with self-continuation, Vercel scaffold generation with drift detection, and full tool activity tracking in cron conversations.
+
+### Patch Changes
+
+- Updated dependencies [[`658bc54`](https://github.com/cesr/poncho-ai/commit/658bc54d391cb0b58aa678a2b86cd617eebdd8aa)]:
+  - @poncho-ai/harness@0.13.0
+
 ## 0.11.1
 
 ### Patch Changes

package/dist/{chunk-T2F6ICXI.js → chunk-XIFWXRUB.js}

@@ -1,7 +1,7 @@
 // src/index.ts
 import { spawn } from "child_process";
 import { access as access2, cp, mkdir as mkdir3, readFile as readFile3, readdir, rm, stat, writeFile as writeFile3 } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync, watch as fsWatch } from "fs";
 import {
   createServer
 } from "http";
@@ -18,6 +18,7 @@ import {
   ensureAgentIdentity as ensureAgentIdentity2,
   generateAgentId,
   loadPonchoConfig,
+  parseAgentMarkdown,
   resolveStateConfig
 } from "@poncho-ai/harness";
 import { getTextContent } from "@poncho-ai/sdk";
@@ -3736,6 +3737,7 @@ var consumeFirstRunIntro = async (workingDir, input2) => {
     "- **Enable auth**: Add bearer tokens or custom authentication",
     "- **Turn on telemetry**: Track usage with OpenTelemetry/OTLP",
     "- **Add MCP servers**: Connect external tool servers",
+    "- **Schedule cron jobs**: Set up recurring tasks in AGENT.md frontmatter",
     "",
     "Just let me know what you'd like to work on!\n"
   ].join("\n");
@@ -4163,6 +4165,22 @@ ${name}/
             \u2514\u2500\u2500 fetch-page.ts
 \`\`\`
 
+## Cron Jobs
+
+Define scheduled tasks in \`AGENT.md\` frontmatter:
+
+\`\`\`yaml
+cron:
+  daily-report:
+    schedule: "0 9 * * *"
+    task: "Generate the daily sales report"
+\`\`\`
+
+- \`poncho dev\`: jobs run via an in-process scheduler.
+- \`poncho build vercel\`: generates \`vercel.json\` cron entries.
+- Docker/Fly.io: scheduler runs automatically.
+- Trigger manually: \`curl http://localhost:3000/api/cron/daily-report\`
+
 ## Deployment
 
 \`\`\`bash
@@ -4367,6 +4385,55 @@ var ensureRuntimeCliDependency = async (projectDir, cliVersion, config) => {
 `, "utf8");
   return { paths: [relative(projectDir, packageJsonPath)], addedDeps };
 };
+var checkVercelCronDrift = async (projectDir) => {
+  const vercelJsonPath = resolve3(projectDir, "vercel.json");
+  try {
+    await access2(vercelJsonPath);
+  } catch {
+    return;
+  }
+  let agentCrons = {};
+  try {
+    const agentMd = await readFile3(resolve3(projectDir, "AGENT.md"), "utf8");
+    const parsed = parseAgentMarkdown(agentMd);
+    agentCrons = parsed.frontmatter.cron ?? {};
+  } catch {
+    return;
+  }
+  let vercelCrons = [];
+  try {
+    const raw = await readFile3(vercelJsonPath, "utf8");
+    const vercelConfig = JSON.parse(raw);
+    vercelCrons = vercelConfig.crons ?? [];
+  } catch {
+    return;
+  }
+  const vercelCronMap = new Map(
+    vercelCrons.filter((c) => c.path.startsWith("/api/cron/")).map((c) => [decodeURIComponent(c.path.replace("/api/cron/", "")), c.schedule])
+  );
+  const diffs = [];
+  for (const [jobName, job] of Object.entries(agentCrons)) {
+    const existing = vercelCronMap.get(jobName);
+    if (!existing) {
+      diffs.push(`  + missing job "${jobName}" (${job.schedule})`);
+    } else if (existing !== job.schedule) {
+      diffs.push(`  ~ "${jobName}" schedule changed: "${existing}" \u2192 "${job.schedule}"`);
+    }
+    vercelCronMap.delete(jobName);
+  }
+  for (const [jobName, schedule] of vercelCronMap) {
+    diffs.push(`  - removed job "${jobName}" (${schedule})`);
+  }
+  if (diffs.length > 0) {
+    process.stderr.write(
+      `\u26A0 vercel.json crons are out of sync with AGENT.md:
+${diffs.join("\n")}
+  Run \`poncho build vercel --force\` to update.
+
+`
+    );
+  }
+};
 var scaffoldDeployTarget = async (projectDir, target, options) => {
   const writtenPaths = [];
   const cliVersion = await readCliVersion();
@@ -4401,21 +4468,35 @@ export default async function handler(req, res) {
       { force: options?.force, writtenPaths, baseDir: projectDir }
     );
     const vercelConfigPath = resolve3(projectDir, "vercel.json");
+    let vercelCrons;
+    try {
+      const agentMd = await readFile3(resolve3(projectDir, "AGENT.md"), "utf8");
+      const parsed = parseAgentMarkdown(agentMd);
+      if (parsed.frontmatter.cron) {
+        vercelCrons = Object.entries(parsed.frontmatter.cron).map(
+          ([jobName, job]) => ({
+            path: `/api/cron/${encodeURIComponent(jobName)}`,
+            schedule: job.schedule
+          })
+        );
+      }
+    } catch {
+    }
+    const vercelConfig = {
+      version: 2,
+      functions: {
+        "api/index.mjs": {
+          includeFiles: "{AGENT.md,poncho.config.js,skills/**,tests/**,node_modules/.pnpm/marked@*/node_modules/marked/lib/marked.umd.js}"
+        }
+      },
+      routes: [{ src: "/(.*)", dest: "/api/index.mjs" }]
+    };
+    if (vercelCrons && vercelCrons.length > 0) {
+      vercelConfig.crons = vercelCrons;
+    }
     await writeScaffoldFile(
       vercelConfigPath,
-      `${JSON.stringify(
-        {
-          version: 2,
-          functions: {
-            "api/index.mjs": {
-              includeFiles: "{AGENT.md,poncho.config.js,skills/**,tests/**,node_modules/.pnpm/marked@*/node_modules/marked/lib/marked.umd.js}"
-            }
-          },
-          routes: [{ src: "/(.*)", dest: "/api/index.mjs" }]
-        },
-        null,
-        2
-      )}
+      `${JSON.stringify(vercelConfig, null, 2)}
 `,
       { force: options?.force, writtenPaths, baseDir: projectDir }
     );
@@ -4458,6 +4539,11 @@ export const handler = async (event = {}) => {
   });
   return { statusCode: 200, headers: { "content-type": "application/json" }, body };
 };
+
+// Cron jobs: use AWS EventBridge (CloudWatch Events) to trigger scheduled invocations.
+// Create a rule for each cron job defined in AGENT.md that sends a GET request to:
+//   /api/cron/<jobName>
+// Include the Authorization header with your PONCHO_AUTH_TOKEN as a Bearer token.
 `,
       { force: options?.force, writtenPaths, baseDir: projectDir }
     );
@@ -4687,6 +4773,7 @@ var createRequestHandler = async (options) => {
   let agentName = "Agent";
   let agentModelProvider = "anthropic";
   let agentModelName = "claude-opus-4-5";
+  let cronJobs = {};
   try {
     const agentMd = await readFile3(resolve3(workingDir, "AGENT.md"), "utf8");
     const nameMatch = agentMd.match(/^name:\s*(.+)$/m);
@@ -4701,6 +4788,11 @@ var createRequestHandler = async (options) => {
     if (modelMatch?.[1]) {
       agentModelName = modelMatch[1].trim().replace(/^["']|["']$/g, "");
     }
+    try {
+      const parsed = parseAgentMarkdown(agentMd);
+      cronJobs = parsed.frontmatter.cron ?? {};
+    } catch {
+    }
   } catch {
   }
   const runOwners = /* @__PURE__ */ new Map();
@@ -4811,7 +4903,7 @@ var createRequestHandler = async (options) => {
     }
     return verifyPassphrase(match[1], authToken);
   };
-  return async (request, response) => {
+  const handler = async (request, response) => {
     if (!request.url || !request.method) {
       writeJson(response, 404, { error: "Not found" });
       return;
@@ -5533,10 +5625,183 @@ var createRequestHandler = async (options) => {
       }
       return;
     }
+    const cronMatch = pathname.match(/^\/api\/cron\/([^/]+)$/);
+    if (cronMatch && (request.method === "GET" || request.method === "POST")) {
+      const jobName = decodeURIComponent(cronMatch[1] ?? "");
+      const cronJob = cronJobs[jobName];
+      if (!cronJob) {
+        writeJson(response, 404, {
+          code: "CRON_JOB_NOT_FOUND",
+          message: `Cron job "${jobName}" is not defined in AGENT.md`
+        });
+        return;
+      }
+      const urlObj = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+      const continueConversationId = urlObj.searchParams.get("continue");
+      const continuationCount = Number(urlObj.searchParams.get("continuation") ?? "0");
+      const maxContinuations = 5;
+      if (continuationCount >= maxContinuations) {
+        writeJson(response, 200, {
+          conversationId: continueConversationId,
+          status: "max_continuations_reached",
+          continuations: continuationCount
+        });
+        return;
+      }
+      const cronOwnerId = ownerId;
+      const start = Date.now();
+      try {
+        let conversation;
+        let historyMessages = [];
+        if (continueConversationId) {
+          conversation = await conversationStore.get(continueConversationId);
+          if (!conversation) {
+            writeJson(response, 404, {
+              code: "CONVERSATION_NOT_FOUND",
+              message: "Continuation conversation not found"
+            });
+            return;
+          }
+          historyMessages = [...conversation.messages];
+        } else {
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          conversation = await conversationStore.create(
+            cronOwnerId,
+            `[cron] ${jobName} ${timestamp}`
+          );
+        }
+        const abortController = new AbortController();
+        let assistantResponse = "";
+        let latestRunId = "";
+        const toolTimeline = [];
+        const sections = [];
+        let currentTools = [];
+        let currentText = "";
+        let runResult = {
+          status: "completed",
+          steps: 0
+        };
+        const platformMaxDurationSec = Number(process.env.PONCHO_MAX_DURATION) || 0;
+        const softDeadlineMs = platformMaxDurationSec > 0 ? platformMaxDurationSec * 800 : 0;
+        for await (const event of harness.runWithTelemetry({
+          task: cronJob.task,
+          parameters: { __activeConversationId: conversation.conversationId },
+          messages: historyMessages,
+          abortSignal: abortController.signal
+        })) {
+          if (event.type === "run:started") {
+            latestRunId = event.runId;
+          }
+          if (event.type === "model:chunk") {
+            if (currentTools.length > 0) {
+              sections.push({ type: "tools", content: currentTools });
+              currentTools = [];
+            }
+            assistantResponse += event.content;
+            currentText += event.content;
+          }
+          if (event.type === "tool:started") {
+            if (currentText.length > 0) {
+              sections.push({ type: "text", content: currentText });
+              currentText = "";
+            }
+            const toolText = `- start \`${event.tool}\``;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+          if (event.type === "tool:completed") {
+            const toolText = `- done \`${event.tool}\` (${event.duration}ms)`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+          if (event.type === "tool:error") {
+            const toolText = `- error \`${event.tool}\`: ${event.error}`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+          if (event.type === "run:completed") {
+            runResult = {
+              status: event.result.status,
+              steps: event.result.steps,
+              continuation: event.result.continuation
+            };
+            if (!assistantResponse && event.result.response) {
+              assistantResponse = event.result.response;
+            }
+          }
+          await telemetry.emit(event);
+        }
+        if (currentTools.length > 0) {
+          sections.push({ type: "tools", content: currentTools });
+        }
+        if (currentText.length > 0) {
+          sections.push({ type: "text", content: currentText });
+          currentText = "";
+        }
+        const hasContent = assistantResponse.length > 0 || toolTimeline.length > 0;
+        const assistantMetadata = toolTimeline.length > 0 || sections.length > 0 ? {
+          toolActivity: [...toolTimeline],
+          sections: sections.length > 0 ? sections : void 0
+        } : void 0;
+        const messages = [
+          ...historyMessages,
+          ...continueConversationId ? [] : [{ role: "user", content: cronJob.task }],
+          ...hasContent ? [{ role: "assistant", content: assistantResponse, metadata: assistantMetadata }] : []
+        ];
+        conversation.messages = messages;
+        conversation.runtimeRunId = latestRunId || conversation.runtimeRunId;
+        conversation.updatedAt = Date.now();
+        await conversationStore.update(conversation);
+        if (runResult.continuation && softDeadlineMs > 0) {
+          const selfUrl = `http://${request.headers.host ?? "localhost"}${pathname}?continue=${encodeURIComponent(conversation.conversationId)}&continuation=${continuationCount + 1}`;
+          try {
+            const selfRes = await fetch(selfUrl, {
+              method: "GET",
+              headers: request.headers.authorization ? { authorization: request.headers.authorization } : {}
+            });
+            const selfBody = await selfRes.json();
+            writeJson(response, 200, {
+              conversationId: conversation.conversationId,
+              status: "continued",
+              continuations: continuationCount + 1,
+              finalResult: selfBody,
+              duration: Date.now() - start
+            });
+          } catch (continueError) {
+            writeJson(response, 200, {
+              conversationId: conversation.conversationId,
+              status: "continuation_failed",
+              error: continueError instanceof Error ? continueError.message : "Unknown error",
+              duration: Date.now() - start,
+              steps: runResult.steps
+            });
+          }
+          return;
+        }
+        writeJson(response, 200, {
+          conversationId: conversation.conversationId,
+          status: runResult.status,
+          response: assistantResponse.slice(0, 500),
+          duration: Date.now() - start,
+          steps: runResult.steps
+        });
+      } catch (error) {
+        writeJson(response, 500, {
+          code: "CRON_RUN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+      return;
+    }
     writeJson(response, 404, { error: "Not found" });
   };
+  handler._harness = harness;
+  handler._cronJobs = cronJobs;
+  handler._conversationStore = conversationStore;
+  return handler;
 };
 var startDevServer = async (port, options) => {
+  const workingDir = options?.workingDir ?? process.cwd();
   const handler = await createRequestHandler(options);
   const server = createServer(handler);
   const actualPort = await listenOnAvailablePort(server, port);
@@ -5546,7 +5811,141 @@ var startDevServer = async (port, options) => {
   }
   process.stdout.write(`Poncho dev server running at http://localhost:${actualPort}
 `);
+  await checkVercelCronDrift(workingDir);
+  const { Cron } = await import("croner");
+  let activeJobs = [];
+  const scheduleCronJobs = (jobs) => {
+    for (const job of activeJobs) {
+      job.stop();
+    }
+    activeJobs = [];
+    const entries = Object.entries(jobs);
+    if (entries.length === 0) return;
+    const harness = handler._harness;
+    const store = handler._conversationStore;
+    if (!harness || !store) return;
+    for (const [jobName, config] of entries) {
+      const job = new Cron(
+        config.schedule,
+        { timezone: config.timezone ?? "UTC" },
+        async () => {
+          const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+          process.stdout.write(`[cron] ${jobName} started at ${timestamp}
+`);
+          const start = Date.now();
+          try {
+            const conversation = await store.create(
+              "local-owner",
+              `[cron] ${jobName} ${timestamp}`
+            );
+            let assistantResponse = "";
+            let steps = 0;
+            const toolTimeline = [];
+            const sections = [];
+            let currentTools = [];
+            let currentText = "";
+            for await (const event of harness.runWithTelemetry({
+              task: config.task,
+              parameters: { __activeConversationId: conversation.conversationId },
+              messages: []
+            })) {
+              if (event.type === "model:chunk") {
+                if (currentTools.length > 0) {
+                  sections.push({ type: "tools", content: currentTools });
+                  currentTools = [];
+                }
+                assistantResponse += event.content;
+                currentText += event.content;
+              }
+              if (event.type === "tool:started") {
+                if (currentText.length > 0) {
+                  sections.push({ type: "text", content: currentText });
+                  currentText = "";
+                }
+                const toolText = `- start \`${event.tool}\``;
+                toolTimeline.push(toolText);
+                currentTools.push(toolText);
+              }
+              if (event.type === "tool:completed") {
+                const toolText = `- done \`${event.tool}\` (${event.duration}ms)`;
+                toolTimeline.push(toolText);
+                currentTools.push(toolText);
+              }
+              if (event.type === "tool:error") {
+                const toolText = `- error \`${event.tool}\`: ${event.error}`;
+                toolTimeline.push(toolText);
+                currentTools.push(toolText);
+              }
+              if (event.type === "run:completed") {
+                steps = event.result.steps;
+                if (!assistantResponse && event.result.response) {
+                  assistantResponse = event.result.response;
+                }
+              }
+            }
+            if (currentTools.length > 0) {
+              sections.push({ type: "tools", content: currentTools });
+            }
+            if (currentText.length > 0) {
+              sections.push({ type: "text", content: currentText });
+            }
+            const hasContent = assistantResponse.length > 0 || toolTimeline.length > 0;
+            const assistantMetadata = toolTimeline.length > 0 || sections.length > 0 ? {
+              toolActivity: [...toolTimeline],
+              sections: sections.length > 0 ? sections : void 0
+            } : void 0;
+            conversation.messages = [
+              { role: "user", content: config.task },
+              ...hasContent ? [{ role: "assistant", content: assistantResponse, metadata: assistantMetadata }] : []
+            ];
+            conversation.updatedAt = Date.now();
+            await store.update(conversation);
+            const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+            process.stdout.write(
+              `[cron] ${jobName} completed in ${elapsed}s (${steps} steps)
+`
+            );
+          } catch (error) {
+            const elapsed = ((Date.now() - start) / 1e3).toFixed(1);
+            const msg = error instanceof Error ? error.message : String(error);
+            process.stderr.write(
+              `[cron] ${jobName} failed after ${elapsed}s: ${msg}
+`
+            );
+          }
+        }
+      );
+      activeJobs.push(job);
+    }
+    process.stdout.write(
+      `[cron] Scheduled ${entries.length} job${entries.length === 1 ? "" : "s"}: ${entries.map(([n]) => n).join(", ")}
+`
+    );
+  };
+  const initialCronJobs = handler._cronJobs ?? {};
+  scheduleCronJobs(initialCronJobs);
+  const agentMdPath = resolve3(workingDir, "AGENT.md");
+  let reloadDebounce = null;
+  const watcher = fsWatch(agentMdPath, () => {
+    if (reloadDebounce) clearTimeout(reloadDebounce);
+    reloadDebounce = setTimeout(async () => {
+      try {
+        const agentMd = await readFile3(agentMdPath, "utf8");
+        const parsed = parseAgentMarkdown(agentMd);
+        const newJobs = parsed.frontmatter.cron ?? {};
+        handler._cronJobs = newJobs;
+        scheduleCronJobs(newJobs);
+        process.stdout.write(`[cron] Reloaded: ${Object.keys(newJobs).length} jobs scheduled
+`);
+      } catch {
+      }
+    }, 500);
+  });
   const shutdown = () => {
+    watcher.close();
+    for (const job of activeJobs) {
+      job.stop();
+    }
     server.close();
     server.closeAllConnections?.();
     process.exit(0);
@@ -5637,7 +6036,7 @@ var runInteractive = async (workingDir, params) => {
   await harness.initialize();
   const identity = await ensureAgentIdentity2(workingDir);
   try {
-    const { runInteractiveInk } = await import("./run-interactive-ink-7FP5PT7Q.js");
+    const { runInteractiveInk } = await import("./run-interactive-ink-64QEOUXL.js");
     await runInteractiveInk({
       harness,
       params,
@@ -5998,6 +6397,9 @@ Test summary: ${passed} passed, ${failed} failed
 };
 var buildTarget = async (workingDir, target, options) => {
   const normalizedTarget = normalizeDeployTarget2(target);
+  if (normalizedTarget === "vercel" && !options?.force) {
+    await checkVercelCronDrift(workingDir);
+  }
   const writtenPaths = await scaffoldDeployTarget(workingDir, normalizedTarget, {
     force: options?.force
   });

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   main
-} from "./chunk-T2F6ICXI.js";
+} from "./chunk-XIFWXRUB.js";
 
 // src/cli.ts
 void main();

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import { IncomingMessage, ServerResponse, Server } from 'node:http';
+import { AgentHarness, CronJobConfig, ConversationStore } from '@poncho-ai/harness';
 import { Command } from 'commander';
 
 type InitOnboardingOptions = {
@@ -17,7 +18,11 @@ declare const initProject: (projectName: string, options?: {
     envExampleOverride?: string;
 }) => Promise<void>;
 declare const updateAgentGuidance: (workingDir: string) => Promise<boolean>;
-type RequestHandler = (request: IncomingMessage, response: ServerResponse) => Promise<void>;
+type RequestHandler = ((request: IncomingMessage, response: ServerResponse) => Promise<void>) & {
+    _harness?: AgentHarness;
+    _cronJobs?: Record<string, CronJobConfig>;
+    _conversationStore?: ConversationStore;
+};
 declare const createRequestHandler: (options?: {
     workingDir?: string;
 }) => Promise<RequestHandler>;

package/dist/index.js

@@ -23,7 +23,7 @@ import {
   runTests,
   startDevServer,
   updateAgentGuidance
-} from "./chunk-T2F6ICXI.js";
+} from "./chunk-XIFWXRUB.js";
 export {
   addSkill,
   buildCli,

package/dist/{run-interactive-ink-7FP5PT7Q.js → run-interactive-ink-64QEOUXL.js}

@@ -2,7 +2,7 @@ import {
   consumeFirstRunIntro,
   inferConversationTitle,
   resolveHarnessEnvironment
-} from "./chunk-T2F6ICXI.js";
+} from "./chunk-XIFWXRUB.js";
 
 // src/run-interactive-ink.ts
 import * as readline from "readline";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/cli",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "CLI for building and deploying AI agents",
   "repository": {
     "type": "git",
@@ -20,13 +20,14 @@
     "@inquirer/prompts": "^8.2.0",
     "busboy": "^1.6.0",
     "commander": "^12.0.0",
+    "croner": "^10.0.1",
     "dotenv": "^16.4.0",
     "ink": "^6.7.0",
     "marked": "^17.0.2",
     "react": "^19.2.4",
     "react-devtools-core": "^6.1.5",
     "yaml": "^2.8.1",
-    "@poncho-ai/harness": "0.12.0",
+    "@poncho-ai/harness": "0.13.0",
     "@poncho-ai/sdk": "1.0.0"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { access, cp, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
+import { existsSync, watch as fsWatch } from "node:fs";
 import {
   createServer,
   type IncomingMessage,
@@ -20,7 +20,9 @@ import {
   ensureAgentIdentity,
   generateAgentId,
   loadPonchoConfig,
+  parseAgentMarkdown,
   resolveStateConfig,
+  type CronJobConfig,
   type PonchoConfig,
   type ConversationStore,
   type UploadStore,
@@ -549,6 +551,22 @@ ${name}/
             └── fetch-page.ts
 \`\`\`
 
+## Cron Jobs
+
+Define scheduled tasks in \`AGENT.md\` frontmatter:
+
+\`\`\`yaml
+cron:
+  daily-report:
+    schedule: "0 9 * * *"
+    task: "Generate the daily sales report"
+\`\`\`
+
+- \`poncho dev\`: jobs run via an in-process scheduler.
+- \`poncho build vercel\`: generates \`vercel.json\` cron entries.
+- Docker/Fly.io: scheduler runs automatically.
+- Trigger manually: \`curl http://localhost:3000/api/cron/daily-report\`
+
 ## Deployment
 
 \`\`\`bash
@@ -796,6 +814,54 @@ const ensureRuntimeCliDependency = async (
   return { paths: [relative(projectDir, packageJsonPath)], addedDeps };
 };
 
+const checkVercelCronDrift = async (projectDir: string): Promise<void> => {
+  const vercelJsonPath = resolve(projectDir, "vercel.json");
+  try {
+    await access(vercelJsonPath);
+  } catch {
+    return;
+  }
+  let agentCrons: Record<string, CronJobConfig> = {};
+  try {
+    const agentMd = await readFile(resolve(projectDir, "AGENT.md"), "utf8");
+    const parsed = parseAgentMarkdown(agentMd);
+    agentCrons = parsed.frontmatter.cron ?? {};
+  } catch {
+    return;
+  }
+  let vercelCrons: Array<{ path: string; schedule: string }> = [];
+  try {
+    const raw = await readFile(vercelJsonPath, "utf8");
+    const vercelConfig = JSON.parse(raw) as { crons?: Array<{ path: string; schedule: string }> };
+    vercelCrons = vercelConfig.crons ?? [];
+  } catch {
+    return;
+  }
+  const vercelCronMap = new Map(
+    vercelCrons
+      .filter((c) => c.path.startsWith("/api/cron/"))
+      .map((c) => [decodeURIComponent(c.path.replace("/api/cron/", "")), c.schedule]),
+  );
+  const diffs: string[] = [];
+  for (const [jobName, job] of Object.entries(agentCrons)) {
+    const existing = vercelCronMap.get(jobName);
+    if (!existing) {
+      diffs.push(`  + missing job "${jobName}" (${job.schedule})`);
+    } else if (existing !== job.schedule) {
+      diffs.push(`  ~ "${jobName}" schedule changed: "${existing}" → "${job.schedule}"`);
+    }
+    vercelCronMap.delete(jobName);
+  }
+  for (const [jobName, schedule] of vercelCronMap) {
+    diffs.push(`  - removed job "${jobName}" (${schedule})`);
+  }
+  if (diffs.length > 0) {
+    process.stderr.write(
+      `\u26A0 vercel.json crons are out of sync with AGENT.md:\n${diffs.join("\n")}\n  Run \`poncho build vercel --force\` to update.\n\n`,
+    );
+  }
+};
+
 const scaffoldDeployTarget = async (
   projectDir: string,
   target: DeployScaffoldTarget,
@@ -835,22 +901,37 @@ export default async function handler(req, res) {
       { force: options?.force, writtenPaths, baseDir: projectDir },
     );
     const vercelConfigPath = resolve(projectDir, "vercel.json");
+    let vercelCrons: Array<{ path: string; schedule: string }> | undefined;
+    try {
+      const agentMd = await readFile(resolve(projectDir, "AGENT.md"), "utf8");
+      const parsed = parseAgentMarkdown(agentMd);
+      if (parsed.frontmatter.cron) {
+        vercelCrons = Object.entries(parsed.frontmatter.cron).map(
+          ([jobName, job]) => ({
+            path: `/api/cron/${encodeURIComponent(jobName)}`,
+            schedule: job.schedule,
+          }),
+        );
+      }
+    } catch {
+      // AGENT.md may not exist yet during init; skip cron generation
+    }
+    const vercelConfig: Record<string, unknown> = {
+      version: 2,
+      functions: {
+        "api/index.mjs": {
+          includeFiles:
+            "{AGENT.md,poncho.config.js,skills/**,tests/**,node_modules/.pnpm/marked@*/node_modules/marked/lib/marked.umd.js}",
+        },
+      },
+      routes: [{ src: "/(.*)", dest: "/api/index.mjs" }],
+    };
+    if (vercelCrons && vercelCrons.length > 0) {
+      vercelConfig.crons = vercelCrons;
+    }
     await writeScaffoldFile(
       vercelConfigPath,
-      `${JSON.stringify(
-        {
-          version: 2,
-          functions: {
-            "api/index.mjs": {
-              includeFiles:
-                "{AGENT.md,poncho.config.js,skills/**,tests/**,node_modules/.pnpm/marked@*/node_modules/marked/lib/marked.umd.js}",
-            },
-          },
-          routes: [{ src: "/(.*)", dest: "/api/index.mjs" }],
-        },
-        null,
-        2,
-      )}\n`,
+      `${JSON.stringify(vercelConfig, null, 2)}\n`,
       { force: options?.force, writtenPaths, baseDir: projectDir },
     );
   } else if (target === "docker") {
@@ -892,6 +973,11 @@ export const handler = async (event = {}) => {
   });
   return { statusCode: 200, headers: { "content-type": "application/json" }, body };
 };
+
+// Cron jobs: use AWS EventBridge (CloudWatch Events) to trigger scheduled invocations.
+// Create a rule for each cron job defined in AGENT.md that sends a GET request to:
+//   /api/cron/<jobName>
+// Include the Authorization header with your PONCHO_AUTH_TOKEN as a Bearer token.
 `,
       { force: options?.force, writtenPaths, baseDir: projectDir },
     );
@@ -1131,10 +1217,14 @@ export const updateAgentGuidance = async (workingDir: string): Promise<boolean>
 const formatSseEvent = (event: AgentEvent): string =>
   `event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`;
 
-export type RequestHandler = (
+export type RequestHandler = ((
   request: IncomingMessage,
   response: ServerResponse,
-) => Promise<void>;
+) => Promise<void>) & {
+  _harness?: AgentHarness;
+  _cronJobs?: Record<string, CronJobConfig>;
+  _conversationStore?: ConversationStore;
+};
 
 export const createRequestHandler = async (options?: {
   workingDir?: string;
@@ -1145,6 +1235,7 @@ export const createRequestHandler = async (options?: {
   let agentName = "Agent";
   let agentModelProvider = "anthropic";
   let agentModelName = "claude-opus-4-5";
+  let cronJobs: Record<string, CronJobConfig> = {};
   try {
     const agentMd = await readFile(resolve(workingDir, "AGENT.md"), "utf8");
     const nameMatch = agentMd.match(/^name:\s*(.+)$/m);
@@ -1159,6 +1250,12 @@ export const createRequestHandler = async (options?: {
     if (modelMatch?.[1]) {
       agentModelName = modelMatch[1].trim().replace(/^["']|["']$/g, "");
     }
+    try {
+      const parsed = parseAgentMarkdown(agentMd);
+      cronJobs = parsed.frontmatter.cron ?? {};
+    } catch {
+      // Cron parsing failure should not block the server
+    }
   } catch {}
   const runOwners = new Map<string, string>();
   const runConversations = new Map<string, string>();
@@ -1300,7 +1397,7 @@ export const createRequestHandler = async (options?: {
     return verifyPassphrase(match[1], authToken);
   };
 
-  return async (request: IncomingMessage, response: ServerResponse) => {
+  const handler: RequestHandler = async (request: IncomingMessage, response: ServerResponse) => {
     if (!request.url || !request.method) {
       writeJson(response, 404, { error: "Not found" });
       return;
@@ -2105,14 +2202,214 @@ export const createRequestHandler = async (options?: {
       return;
     }
 
+    // ── Cron job endpoint ──────────────────────────────────────────
+    const cronMatch = pathname.match(/^\/api\/cron\/([^/]+)$/);
+    if (cronMatch && (request.method === "GET" || request.method === "POST")) {
+      const jobName = decodeURIComponent(cronMatch[1] ?? "");
+      const cronJob = cronJobs[jobName];
+      if (!cronJob) {
+        writeJson(response, 404, {
+          code: "CRON_JOB_NOT_FOUND",
+          message: `Cron job "${jobName}" is not defined in AGENT.md`,
+        });
+        return;
+      }
+
+      const urlObj = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
+      const continueConversationId = urlObj.searchParams.get("continue");
+      const continuationCount = Number(urlObj.searchParams.get("continuation") ?? "0");
+      const maxContinuations = 5;
+
+      if (continuationCount >= maxContinuations) {
+        writeJson(response, 200, {
+          conversationId: continueConversationId,
+          status: "max_continuations_reached",
+          continuations: continuationCount,
+        });
+        return;
+      }
+
+      const cronOwnerId = ownerId;
+      const start = Date.now();
+
+      try {
+        let conversation;
+        let historyMessages: Message[] = [];
+
+        if (continueConversationId) {
+          conversation = await conversationStore.get(continueConversationId);
+          if (!conversation) {
+            writeJson(response, 404, {
+              code: "CONVERSATION_NOT_FOUND",
+              message: "Continuation conversation not found",
+            });
+            return;
+          }
+          historyMessages = [...conversation.messages];
+        } else {
+          const timestamp = new Date().toISOString();
+          conversation = await conversationStore.create(
+            cronOwnerId,
+            `[cron] ${jobName} ${timestamp}`,
+          );
+        }
+
+        const abortController = new AbortController();
+        let assistantResponse = "";
+        let latestRunId = "";
+        const toolTimeline: string[] = [];
+        const sections: Array<{ type: "text" | "tools"; content: string | string[] }> = [];
+        let currentTools: string[] = [];
+        let currentText = "";
+        let runResult: { status: string; steps: number; continuation?: boolean } = {
+          status: "completed",
+          steps: 0,
+        };
+
+        const platformMaxDurationSec = Number(process.env.PONCHO_MAX_DURATION) || 0;
+        const softDeadlineMs = platformMaxDurationSec > 0
+          ? platformMaxDurationSec * 800
+          : 0;
+
+        for await (const event of harness.runWithTelemetry({
+          task: cronJob.task,
+          parameters: { __activeConversationId: conversation.conversationId },
+          messages: historyMessages,
+          abortSignal: abortController.signal,
+        })) {
+          if (event.type === "run:started") {
+            latestRunId = event.runId;
+          }
+          if (event.type === "model:chunk") {
+            if (currentTools.length > 0) {
+              sections.push({ type: "tools", content: currentTools });
+              currentTools = [];
+            }
+            assistantResponse += event.content;
+            currentText += event.content;
+          }
+          if (event.type === "tool:started") {
+            if (currentText.length > 0) {
+              sections.push({ type: "text", content: currentText });
+              currentText = "";
+            }
+            const toolText = `- start \`${event.tool}\``;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+          if (event.type === "tool:completed") {
+            const toolText = `- done \`${event.tool}\` (${event.duration}ms)`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+          if (event.type === "tool:error") {
+            const toolText = `- error \`${event.tool}\`: ${event.error}`;
+            toolTimeline.push(toolText);
+            currentTools.push(toolText);
+          }
+          if (event.type === "run:completed") {
+            runResult = {
+              status: event.result.status,
+              steps: event.result.steps,
+              continuation: event.result.continuation,
+            };
+            if (!assistantResponse && event.result.response) {
+              assistantResponse = event.result.response;
+            }
+          }
+          await telemetry.emit(event);
+        }
+
+        if (currentTools.length > 0) {
+          sections.push({ type: "tools", content: currentTools });
+        }
+        if (currentText.length > 0) {
+          sections.push({ type: "text", content: currentText });
+          currentText = "";
+        }
+
+        // Persist the conversation
+        const hasContent = assistantResponse.length > 0 || toolTimeline.length > 0;
+        const assistantMetadata =
+          toolTimeline.length > 0 || sections.length > 0
+            ? ({
+                toolActivity: [...toolTimeline],
+                sections: sections.length > 0 ? sections : undefined,
+              } as Message["metadata"])
+            : undefined;
+        const messages: Message[] = [
+          ...historyMessages,
+          ...(continueConversationId
+            ? []
+            : [{ role: "user" as const, content: cronJob.task }]),
+          ...(hasContent
+            ? [{ role: "assistant" as const, content: assistantResponse, metadata: assistantMetadata }]
+            : []),
+        ];
+        conversation.messages = messages;
+        conversation.runtimeRunId = latestRunId || conversation.runtimeRunId;
+        conversation.updatedAt = Date.now();
+        await conversationStore.update(conversation);
+
+        // Self-continuation for serverless timeouts
+        if (runResult.continuation && softDeadlineMs > 0) {
+          const selfUrl = `http://${request.headers.host ?? "localhost"}${pathname}?continue=${encodeURIComponent(conversation.conversationId)}&continuation=${continuationCount + 1}`;
+          try {
+            const selfRes = await fetch(selfUrl, {
+              method: "GET",
+              headers: request.headers.authorization
+                ? { authorization: request.headers.authorization }
+                : {},
+            });
+            const selfBody = await selfRes.json() as Record<string, unknown>;
+            writeJson(response, 200, {
+              conversationId: conversation.conversationId,
+              status: "continued",
+              continuations: continuationCount + 1,
+              finalResult: selfBody,
+              duration: Date.now() - start,
+            });
+          } catch (continueError) {
+            writeJson(response, 200, {
+              conversationId: conversation.conversationId,
+              status: "continuation_failed",
+              error: continueError instanceof Error ? continueError.message : "Unknown error",
+              duration: Date.now() - start,
+              steps: runResult.steps,
+            });
+          }
+          return;
+        }
+
+        writeJson(response, 200, {
+          conversationId: conversation.conversationId,
+          status: runResult.status,
+          response: assistantResponse.slice(0, 500),
+          duration: Date.now() - start,
+          steps: runResult.steps,
+        });
+      } catch (error) {
+        writeJson(response, 500, {
+          code: "CRON_RUN_ERROR",
+          message: error instanceof Error ? error.message : "Unknown error",
+        });
+      }
+      return;
+    }
+
     writeJson(response, 404, { error: "Not found" });
   };
+  handler._harness = harness;
+  handler._cronJobs = cronJobs;
+  handler._conversationStore = conversationStore;
+  return handler;
 };
 
 export const startDevServer = async (
   port: number,
   options?: { workingDir?: string },
 ): Promise<Server> => {
+  const workingDir = options?.workingDir ?? process.cwd();
   const handler = await createRequestHandler(options);
   const server = createServer(handler);
   const actualPort = await listenOnAvailablePort(server, port);
@@ -2121,9 +2418,154 @@ export const startDevServer = async (
   }
   process.stdout.write(`Poncho dev server running at http://localhost:${actualPort}\n`);
 
+  await checkVercelCronDrift(workingDir);
+
+  // ── Cron scheduler ─────────────────────────────────────────────
+  const { Cron } = await import("croner");
+  type CronJob = InstanceType<typeof Cron>;
+  let activeJobs: CronJob[] = [];
+
+  const scheduleCronJobs = (jobs: Record<string, CronJobConfig>): void => {
+    for (const job of activeJobs) {
+      job.stop();
+    }
+    activeJobs = [];
+
+    const entries = Object.entries(jobs);
+    if (entries.length === 0) return;
+
+    const harness = handler._harness;
+    const store = handler._conversationStore;
+    if (!harness || !store) return;
+
+    for (const [jobName, config] of entries) {
+      const job = new Cron(
+        config.schedule,
+        { timezone: config.timezone ?? "UTC" },
+        async () => {
+          const timestamp = new Date().toISOString();
+          process.stdout.write(`[cron] ${jobName} started at ${timestamp}\n`);
+          const start = Date.now();
+          try {
+            const conversation = await store.create(
+              "local-owner",
+              `[cron] ${jobName} ${timestamp}`,
+            );
+            let assistantResponse = "";
+            let steps = 0;
+            const toolTimeline: string[] = [];
+            const sections: Array<{ type: "text" | "tools"; content: string | string[] }> = [];
+            let currentTools: string[] = [];
+            let currentText = "";
+            for await (const event of harness.runWithTelemetry({
+              task: config.task,
+              parameters: { __activeConversationId: conversation.conversationId },
+              messages: [],
+            })) {
+              if (event.type === "model:chunk") {
+                if (currentTools.length > 0) {
+                  sections.push({ type: "tools", content: currentTools });
+                  currentTools = [];
+                }
+                assistantResponse += event.content;
+                currentText += event.content;
+              }
+              if (event.type === "tool:started") {
+                if (currentText.length > 0) {
+                  sections.push({ type: "text", content: currentText });
+                  currentText = "";
+                }
+                const toolText = `- start \`${event.tool}\``;
+                toolTimeline.push(toolText);
+                currentTools.push(toolText);
+              }
+              if (event.type === "tool:completed") {
+                const toolText = `- done \`${event.tool}\` (${event.duration}ms)`;
+                toolTimeline.push(toolText);
+                currentTools.push(toolText);
+              }
+              if (event.type === "tool:error") {
+                const toolText = `- error \`${event.tool}\`: ${event.error}`;
+                toolTimeline.push(toolText);
+                currentTools.push(toolText);
+              }
+              if (event.type === "run:completed") {
+                steps = event.result.steps;
+                if (!assistantResponse && event.result.response) {
+                  assistantResponse = event.result.response;
+                }
+              }
+            }
+            if (currentTools.length > 0) {
+              sections.push({ type: "tools", content: currentTools });
+            }
+            if (currentText.length > 0) {
+              sections.push({ type: "text", content: currentText });
+            }
+            const hasContent = assistantResponse.length > 0 || toolTimeline.length > 0;
+            const assistantMetadata =
+              toolTimeline.length > 0 || sections.length > 0
+                ? ({
+                    toolActivity: [...toolTimeline],
+                    sections: sections.length > 0 ? sections : undefined,
+                  } as Message["metadata"])
+                : undefined;
+            conversation.messages = [
+              { role: "user", content: config.task },
+              ...(hasContent
+                ? [{ role: "assistant" as const, content: assistantResponse, metadata: assistantMetadata }]
+                : []),
+            ];
+            conversation.updatedAt = Date.now();
+            await store.update(conversation);
+            const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+            process.stdout.write(
+              `[cron] ${jobName} completed in ${elapsed}s (${steps} steps)\n`,
+            );
+          } catch (error) {
+            const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+            const msg = error instanceof Error ? error.message : String(error);
+            process.stderr.write(
+              `[cron] ${jobName} failed after ${elapsed}s: ${msg}\n`,
+            );
+          }
+        },
+      );
+      activeJobs.push(job);
+    }
+    process.stdout.write(
+      `[cron] Scheduled ${entries.length} job${entries.length === 1 ? "" : "s"}: ${entries.map(([n]) => n).join(", ")}\n`,
+    );
+  };
+
+  const initialCronJobs = handler._cronJobs ?? {};
+  scheduleCronJobs(initialCronJobs);
+
+  // Hot-reload cron config when AGENT.md changes
+  const agentMdPath = resolve(workingDir, "AGENT.md");
+  let reloadDebounce: ReturnType<typeof setTimeout> | null = null;
+  const watcher = fsWatch(agentMdPath, () => {
+    if (reloadDebounce) clearTimeout(reloadDebounce);
+    reloadDebounce = setTimeout(async () => {
+      try {
+        const agentMd = await readFile(agentMdPath, "utf8");
+        const parsed = parseAgentMarkdown(agentMd);
+        const newJobs = parsed.frontmatter.cron ?? {};
+        handler._cronJobs = newJobs;
+        scheduleCronJobs(newJobs);
+        process.stdout.write(`[cron] Reloaded: ${Object.keys(newJobs).length} jobs scheduled\n`);
+      } catch {
+        // Parse errors during editing are expected; ignore
+      }
+    }, 500);
+  });
+
   const shutdown = () => {
+    watcher.close();
+    for (const job of activeJobs) {
+      job.stop();
+    }
     server.close();
-    // Force-close any lingering connections so the port is freed immediately
     server.closeAllConnections?.();
     process.exit(0);
   };
@@ -2746,6 +3188,9 @@ export const buildTarget = async (
   options?: { force?: boolean },
 ): Promise<void> => {
   const normalizedTarget = normalizeDeployTarget(target);
+  if (normalizedTarget === "vercel" && !options?.force) {
+    await checkVercelCronDrift(workingDir);
+  }
   const writtenPaths = await scaffoldDeployTarget(workingDir, normalizedTarget, {
     force: options?.force,
   });

package/src/init-feature-context.ts

@@ -126,6 +126,7 @@ export const consumeFirstRunIntro = async (
     "- **Enable auth**: Add bearer tokens or custom authentication",
     "- **Turn on telemetry**: Track usage with OpenTelemetry/OTLP",
     "- **Add MCP servers**: Connect external tool servers",
+    "- **Schedule cron jobs**: Set up recurring tasks in AGENT.md frontmatter",
     "",
     "Just let me know what you'd like to work on!\n",
   ].join("\n");

package/test/cli.test.ts

@@ -11,7 +11,10 @@ import {
   initializeOnboardingMarker,
 } from "../src/init-feature-context.js";
 
-vi.mock("@poncho-ai/harness", () => ({
+vi.mock("@poncho-ai/harness", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@poncho-ai/harness")>();
+  return {
+  parseAgentMarkdown: actual.parseAgentMarkdown,
   AgentHarness: class MockHarness {
     async initialize(): Promise<void> {}
     listTools(): Array<{ name: string; description: string }> {
@@ -160,7 +163,7 @@ vi.mock("@poncho-ai/harness", () => ({
     get: async () => Buffer.from(""),
     delete: async () => {},
   }),
-}));
+};});
 
 import {
   buildTarget,
@@ -920,6 +923,43 @@ describe("cli", () => {
     expect(result.failed).toBe(0);
   });
 
+  it("includes crons in vercel.json when AGENT.md has cron jobs", async () => {
+    await initProject("cron-agent", { workingDir: tempDir });
+    const projectDir = join(tempDir, "cron-agent");
+    const agentMdPath = join(projectDir, "AGENT.md");
+    const agentMd = await readFile(agentMdPath, "utf8");
+    // Insert cron block before the closing --- of frontmatter
+    const updatedAgentMd = agentMd.replace(
+      /^(---\n[\s\S]*?)(---\n)/m,
+      `$1cron:\n  daily-report:\n    schedule: "0 9 * * *"\n    task: "Generate the daily report"\n  health-check:\n    schedule: "*/30 * * * *"\n    task: "Check all APIs"\n$2`,
+    );
+    await writeFile(agentMdPath, updatedAgentMd, "utf8");
+    await buildTarget(projectDir, "vercel", { force: true });
+    const vercelConfig = JSON.parse(
+      await readFile(join(projectDir, "vercel.json"), "utf8"),
+    ) as { crons?: Array<{ path: string; schedule: string }> };
+    expect(vercelConfig.crons).toBeDefined();
+    expect(vercelConfig.crons).toHaveLength(2);
+    expect(vercelConfig.crons).toContainEqual({
+      path: "/api/cron/daily-report",
+      schedule: "0 9 * * *",
+    });
+    expect(vercelConfig.crons).toContainEqual({
+      path: "/api/cron/health-check",
+      schedule: "*/30 * * * *",
+    });
+  });
+
+  it("omits crons from vercel.json when AGENT.md has no cron jobs", async () => {
+    await initProject("no-cron-agent", { workingDir: tempDir });
+    const projectDir = join(tempDir, "no-cron-agent");
+    await buildTarget(projectDir, "vercel", { force: true });
+    const vercelConfig = JSON.parse(
+      await readFile(join(projectDir, "vercel.json"), "utf8"),
+    ) as { crons?: unknown };
+    expect(vercelConfig.crons).toBeUndefined();
+  });
+
   it("fails on existing deploy files unless force is enabled", async () => {
     await initProject("collision-agent", { workingDir: tempDir });
     const projectDir = join(tempDir, "collision-agent");