@poncho-ai/cli 0.11.1 → 0.13.0

package/dist/{chunk-T2F6ICXI.js → chunk-CUCEDHME.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,9 +18,14 @@ import {
   ensureAgentIdentity as ensureAgentIdentity2,
   generateAgentId,
   loadPonchoConfig,
+  parseAgentMarkdown,
   resolveStateConfig
 } from "@poncho-ai/harness";
 import { getTextContent } from "@poncho-ai/sdk";
+import {
+  AgentBridge,
+  SlackAdapter
+} from "@poncho-ai/messaging";
 import Busboy from "busboy";
 import { Command } from "commander";
 import dotenv from "dotenv";
@@ -3508,12 +3513,17 @@ var buildConfigFromOnboardingAnswers = (answers) => {
     enabled: telemetryEnabled
   };
   maybeSet(telemetry, "otlp", answers["telemetry.otlp"]);
-  return {
+  const messagingPlatform = String(answers["messaging.platform"] ?? "none");
+  const config = {
     mcp: [],
     auth,
     storage,
     telemetry
   };
+  if (messagingPlatform !== "none") {
+    config.messaging = [{ platform: messagingPlatform }];
+  }
+  return config;
 };
 var collectEnvVars = (answers) => {
   const envVars = /* @__PURE__ */ new Set();
@@ -3657,11 +3667,13 @@ var summarizeConfig = (config) => {
   const memoryEnabled = config?.storage?.memory?.enabled ?? config?.memory?.enabled ?? false;
   const authRequired = config?.auth?.required ?? false;
   const telemetryEnabled = config?.telemetry?.enabled ?? true;
+  const messagingPlatforms = (config?.messaging ?? []).map((m) => m.platform);
   return [
     `storage: ${provider}`,
     `memory tools: ${memoryEnabled ? "enabled" : "disabled"}`,
     `auth: ${authRequired ? "required" : "not required"}`,
-    `telemetry: ${telemetryEnabled ? "enabled" : "disabled"}`
+    `telemetry: ${telemetryEnabled ? "enabled" : "disabled"}`,
+    ...messagingPlatforms.length > 0 ? [`messaging: ${messagingPlatforms.join(", ")}`] : []
   ];
 };
 var getOnboardingMarkerPath = async (workingDir) => {
@@ -3736,6 +3748,8 @@ 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",
+    "- **Connect to Slack**: Set up messaging so users can @mention this agent in Slack",
     "",
     "Just let me know what you'd like to work on!\n"
   ].join("\n");
@@ -4163,6 +4177,40 @@ ${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\`
+
+## Messaging (Slack)
+
+Connect your agent to Slack so it responds to @mentions:
+
+1. Create a Slack App at [api.slack.com/apps](https://api.slack.com/apps)
+2. Add Bot Token Scopes: \`app_mentions:read\`, \`chat:write\`, \`reactions:write\`
+3. Enable Event Subscriptions, set Request URL to \`https://<your-url>/api/messaging/slack\`, subscribe to \`app_mention\`
+4. Install to workspace, copy Bot Token and Signing Secret
+5. Set env vars:
+   \`\`\`
+   SLACK_BOT_TOKEN=xoxb-...
+   SLACK_SIGNING_SECRET=...
+   \`\`\`
+6. Add to \`poncho.config.js\`:
+   \`\`\`javascript
+   messaging: [{ platform: 'slack' }]
+   \`\`\`
+
 ## Deployment
 
 \`\`\`bash
@@ -4367,6 +4415,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 +4498,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 +4569,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 +4803,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 +4818,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();
@@ -4791,6 +4913,90 @@ var createRequestHandler = async (options) => {
     workingDir,
     agentId: identity.id
   });
+  const messagingRoutes = /* @__PURE__ */ new Map();
+  const messagingRouteRegistrar = (method, path, routeHandler) => {
+    let byMethod = messagingRoutes.get(path);
+    if (!byMethod) {
+      byMethod = /* @__PURE__ */ new Map();
+      messagingRoutes.set(path, byMethod);
+    }
+    byMethod.set(method, routeHandler);
+  };
+  const messagingRunner = {
+    async getOrCreateConversation(conversationId, meta) {
+      const existing = await conversationStore.get(conversationId);
+      if (existing) {
+        return { messages: existing.messages };
+      }
+      const now = Date.now();
+      const conversation = {
+        conversationId,
+        title: meta.title ?? `${meta.platform} thread`,
+        messages: [],
+        ownerId: meta.ownerId,
+        tenantId: null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await conversationStore.update(conversation);
+      return { messages: [] };
+    },
+    async run(conversationId, input2) {
+      const output = await harness.runToCompletion({
+        task: input2.task,
+        messages: input2.messages
+      });
+      const response = output.result.response ?? "";
+      const conversation = await conversationStore.get(conversationId);
+      if (conversation) {
+        conversation.messages = [
+          ...input2.messages,
+          { role: "user", content: input2.task },
+          { role: "assistant", content: response }
+        ];
+        await conversationStore.update(conversation);
+      }
+      return { response };
+    }
+  };
+  const messagingBridges = [];
+  if (config?.messaging && config.messaging.length > 0) {
+    let waitUntilHook;
+    if (process.env.VERCEL) {
+      try {
+        const modName = "@vercel/functions";
+        const mod = await import(
+          /* webpackIgnore: true */
+          modName
+        );
+        waitUntilHook = mod.waitUntil;
+      } catch {
+      }
+    }
+    for (const channelConfig of config.messaging) {
+      if (channelConfig.platform === "slack") {
+        const adapter = new SlackAdapter({
+          botTokenEnv: channelConfig.botTokenEnv,
+          signingSecretEnv: channelConfig.signingSecretEnv
+        });
+        const bridge = new AgentBridge({
+          adapter,
+          runner: messagingRunner,
+          waitUntil: waitUntilHook
+        });
+        adapter.registerRoutes(messagingRouteRegistrar);
+        try {
+          await bridge.start();
+          messagingBridges.push(bridge);
+          console.log(`  Slack messaging enabled at /api/messaging/slack`);
+        } catch (err) {
+          console.warn(
+            `  Slack messaging disabled: ${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
+    }
+  }
   const sessionStore = new SessionStore();
   const loginRateLimiter = new LoginRateLimiter();
   const authToken = process.env.PONCHO_AUTH_TOKEN ?? "";
@@ -4811,7 +5017,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;
@@ -4848,6 +5054,14 @@ var createRequestHandler = async (options) => {
       writeJson(response, 200, { status: "ok" });
       return;
     }
+    const messagingByMethod = messagingRoutes.get(pathname ?? "");
+    if (messagingByMethod) {
+      const routeHandler = messagingByMethod.get(request.method ?? "");
+      if (routeHandler) {
+        await routeHandler(request, response);
+        return;
+      }
+    }
     const cookies = parseCookies(request);
     const sessionId = cookies.poncho_session;
     const session = sessionId ? sessionStore.get(sessionId) : void 0;
@@ -5533,10 +5747,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 +5933,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 +6158,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-VZBOYJYS.js");
     await runInteractiveInk({
       harness,
       params,
@@ -5998,6 +6519,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
   });