@plasm_lang/vercel-agent 0.3.85 → 0.3.87

package/README.md

@@ -95,10 +95,10 @@ cd ../plasm-agent && npm install
 
 ## Storage (`defineState` + archives)
 
-| Concern | Dev (`fs`) | Prod |
-|---------|------------|------|
-| Sessions / symbols | `agent/.plasm/` | `PLASM_STATE_BACKEND=kv` or `postgres` |
-| Run/trace archives | local dirs | `BLOB_READ_WRITE_TOKEN` + `KV_REST_API_*` |
+| Concern | Dev (`fs`) | Prod (Vercel) |
+|---------|------------|----------------|
+| Sessions / symbols | `agent/.plasm/` | Vercel Blob (`PLASM_STATE_BACKEND=blob`, default on Vercel) |
+| Run/trace archives | local dirs | Vercel Blob (`vercel blob create-store` — OIDC, no manual token) |
 
 See **Connect / state / archive env** below.
 
@@ -180,7 +180,7 @@ Hot reload watches `catalogs/`, `skills/`, `channels/`, `schedules/`, `hooks/`,
 |------|--------|-------|
 | `skills/` | markdown or `defineSkill()` | Progressive index + `read_skill` tool (`experimental.skills: "inline"` for full inject) |
 | `channels/` | `defineChannel()` | HTTP ingress; call stubs, not `plasm_context` |
-| `schedules/` | `defineSchedule()` | Dev: `*/N * * * *` timers; prod: `GET /internal/cron/:name` + Vercel Cron manifest in `/plasm/v1/info` |
+| `schedules/` | `defineSchedule()` | Dev: `*/N * * * *` timers; prod: Nitro scheduled tasks + Vercel Cron (zero config) |
 | `hooks/` | `defineHook()` | `agent:start`, `plan:commit`, `run:complete`, … |
 | `subagents/` | `defineAgent()` in `subagents/<name>/agent.ts` | `delegate_subagent` harness tool |
 
@@ -222,11 +222,9 @@ export PLASM_CONNECT_SUBJECT_TYPE=app                  # or user + PLASM_CONNECT
 ### Production state + Workflow
 
 ```bash
-export PLASM_STATE_BACKEND=kv|postgres|fs
-export PLASM_ARCHIVE_BACKEND=vercel|postgres|local
-export BLOB_READ_WRITE_TOKEN=...
-export KV_REST_API_URL=...
-export KV_REST_API_TOKEN=...
+# On Vercel: Blob + Gateway OIDC automatic after `vercel blob create-store` + `plasm-agent link`
+export PLASM_STATE_BACKEND=blob|postgres|fs|kv   # blob default on Vercel
+export PLASM_ARCHIVE_BACKEND=vercel|local
 
 # Workflow (agent.ts experimental.workflow.world.type)
 export PLASM_WORKFLOW_WORLD=postgres

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasm_lang/vercel-agent",
-  "version": "0.3.85",
+  "version": "0.3.87",
   "description": "Catalog-native TypeScript agent framework (Plasm CGS/CML, Vercel AI SDK, Nitro-oriented)",
   "license": "GPL-3.0-or-later",
   "repository": {
@@ -63,7 +63,7 @@
   "dependencies": {
     "@ai-sdk/otel": "^1.0.3",
     "@opentelemetry/api": "^1.9.0",
-    "@plasm_lang/engine": "^0.3.85",
+    "@plasm_lang/engine": "^0.3.87",
     "@vercel/blob": "^0.27.3",
     "@vercel/connect": "^0.2.6",
     "@vercel/kv": "^3.0.0",

package/src/archive/adapters.ts

@@ -9,6 +9,10 @@ export class UnimplementedBlobArchiveAdapter implements BlobArchiveAdapter {
   async get(): Promise<Uint8Array | null> {
     throw new Error("BlobArchiveAdapter not configured — set PLASM_RUN_ARTIFACTS_URL in prod");
   }
+
+  async list(): Promise<string[]> {
+    throw new Error("BlobArchiveAdapter not configured — set PLASM_RUN_ARTIFACTS_URL in prod");
+  }
 }
 
 /** Stub KV index adapter for production archive listings. */

package/src/archive/prod-archive-store.ts

@@ -1,7 +1,6 @@
 import { LocalArchiveStore } from "./index.js";
 import type {
   BlobArchiveAdapter,
-  KvArchiveIndexAdapter,
   PlanArchiveSnapshot,
   RunSnapshot,
   TraceDetail,
@@ -13,18 +12,17 @@ function blobKey(kind: "plan" | "run" | "trace", id: string): string {
   return `plasm/archives/${kind}/${id}.json`;
 }
 
-function indexKey(kind: "plan" | "run" | "trace", id: string): string {
-  return `plasm:index:${kind}:${id}`;
+function archivePrefix(kind: "plan" | "run" | "trace"): string {
+  return `plasm/archives/${kind}/`;
 }
 
-/** Durable archive store: local FS cache + Blob bodies + KV/Postgres index. */
+/** Durable archive store: local FS cache + Blob bodies (Eve-aligned, no KV index). */
 export class ProdArchiveStore {
   readonly local: LocalArchiveStore;
 
   constructor(
     agentRoot: string,
     private readonly blob: BlobArchiveAdapter,
-    private readonly index: KvArchiveIndexAdapter,
   ) {
     this.local = LocalArchiveStore.fromAgentRoot(agentRoot);
   }
@@ -47,6 +45,17 @@ export class ProdArchiveStore {
     return JSON.parse(Buffer.from(bytes).toString("utf8")) as T;
   }
 
+  private async listJson<T>(kind: "plan" | "run" | "trace"): Promise<T[]> {
+    const paths = await this.blob.list(archivePrefix(kind));
+    const items: T[] = [];
+    for (const key of paths) {
+      if (!key.endsWith(".json")) continue;
+      const item = await this.getJson<T>(key);
+      if (item) items.push(item);
+    }
+    return items;
+  }
+
   async recordToolEvent(
     tenantId: string,
     traceId: string,
@@ -59,59 +68,40 @@ export class ProdArchiveStore {
 
   async finalizeTrace(detail: TraceDetail): Promise<void> {
     await this.local.finalizeTrace(detail);
-    const key = blobKey("trace", detail.summary.trace_id);
-    await this.putJson(key, detail);
-    await this.index.set(indexKey("trace", detail.summary.trace_id), key);
+    await this.putJson(blobKey("trace", detail.summary.trace_id), detail);
   }
 
   async writePlanArchive(snapshot: PlanArchiveSnapshot): Promise<void> {
     await this.local.writePlanArchive(snapshot);
-    const key = blobKey("plan", snapshot.plan_commit_ref);
-    await this.putJson(key, snapshot);
-    await this.index.set(indexKey("plan", snapshot.plan_commit_ref), key);
+    await this.putJson(blobKey("plan", snapshot.plan_commit_ref), snapshot);
   }
 
   async writeRunSnapshot(snapshot: RunSnapshot): Promise<void> {
     await this.local.writeRunSnapshot(snapshot);
-    const key = blobKey("run", snapshot.run_id);
-    await this.putJson(key, snapshot);
-    await this.index.set(indexKey("run", snapshot.run_id), key);
+    await this.putJson(blobKey("run", snapshot.run_id), snapshot);
   }
 
   async listTraces(tenantId: string, limit = 50): Promise<TraceSummary[]> {
-    const keys = await this.index.list("plasm:index:trace:");
-    const items: TraceSummary[] = [];
-    for (const idx of keys) {
-      const blobRef = await this.index.get(idx);
-      if (!blobRef) continue;
-      const detail = await this.getJson<TraceDetail>(blobRef);
-      if (detail?.summary) items.push(detail.summary);
-    }
+    const items = await this.listJson<TraceDetail>("trace");
     if (items.length) {
-      items.sort((a, b) => b.started_at_ms - a.started_at_ms);
-      return items.slice(0, limit);
+      const summaries = items
+        .map((detail) => detail.summary)
+        .filter((summary) => summary.tenant_id === tenantId);
+      summaries.sort((a, b) => b.started_at_ms - a.started_at_ms);
+      return summaries.slice(0, limit);
     }
     return this.local.listTraces(tenantId, limit);
   }
 
   async getTrace(tenantId: string, traceId: string): Promise<TraceDetail | null> {
-    const blobRef = await this.index.get(indexKey("trace", traceId));
-    if (blobRef) {
-      const detail = await this.getJson<TraceDetail>(blobRef);
-      if (detail) return detail;
-    }
+    void tenantId;
+    const detail = await this.getJson<TraceDetail>(blobKey("trace", traceId));
+    if (detail) return detail;
     return this.local.getTrace(tenantId, traceId);
   }
 
   async listPlans(limit = 50): Promise<PlanArchiveSnapshot[]> {
-    const keys = await this.index.list("plasm:index:plan:");
-    const items: PlanArchiveSnapshot[] = [];
-    for (const idx of keys) {
-      const blobRef = await this.index.get(idx);
-      if (!blobRef) continue;
-      const plan = await this.getJson<PlanArchiveSnapshot>(blobRef);
-      if (plan) items.push(plan);
-    }
+    const items = await this.listJson<PlanArchiveSnapshot>("plan");
     if (items.length) {
       items.sort((a, b) => b.archived_at.localeCompare(a.archived_at));
       return items.slice(0, limit);
@@ -120,14 +110,7 @@ export class ProdArchiveStore {
   }
 
   async listRuns(limit = 50): Promise<RunSnapshot[]> {
-    const keys = await this.index.list("plasm:index:run:");
-    const items: RunSnapshot[] = [];
-    for (const idx of keys) {
-      const blobRef = await this.index.get(idx);
-      if (!blobRef) continue;
-      const run = await this.getJson<RunSnapshot>(blobRef);
-      if (run) items.push(run);
-    }
+    const items = await this.listJson<RunSnapshot>("run");
     if (items.length) {
       items.sort((a, b) => b.archived_at.localeCompare(a.archived_at));
       return items.slice(0, limit);

package/src/archive/resolve-backend.ts

@@ -1,10 +1,10 @@
 import type { AgentWorkflowWorldDefinition } from "../define-agent.js";
+import { isVercelHosted } from "../gateway-model.js";
+import { hasLinkedBlobStore } from "../storage/vercel-blob.js";
 import { LocalArchiveStore } from "./index.js";
-import { PostgresArchiveIndexAdapter } from "./postgres-kv-adapter.js";
 import { ProdArchiveStore } from "./prod-archive-store.js";
 import { VercelBlobArchiveAdapter } from "./vercel-blob-adapter.js";
-import { VercelKvArchiveIndexAdapter } from "./vercel-kv-adapter.js";
-import type { BlobArchiveAdapter, KvArchiveIndexAdapter } from "./types.js";
+import type { BlobArchiveAdapter } from "./types.js";
 
 export type ArchiveBackend = "local" | "vercel" | "postgres";
 
@@ -15,46 +15,28 @@ export function resolveArchiveBackend(
   if (explicit === "local" || explicit === "vercel" || explicit === "postgres") {
     return explicit;
   }
-  if (
-    process.env.BLOB_READ_WRITE_TOKEN?.trim() ||
-    process.env.PLASM_RUN_ARTIFACTS_URL?.trim()
-  ) {
-    if (process.env.KV_REST_API_URL?.trim() || process.env.PLASM_KV_REST_API_URL?.trim()) {
-      return "vercel";
-    }
+  if (isVercelHosted() || hasLinkedBlobStore()) {
+    return "vercel";
   }
   if (world?.type === "postgres") return "postgres";
   return "local";
 }
 
 function resolveBlobAdapter(): BlobArchiveAdapter | undefined {
-  if (process.env.BLOB_READ_WRITE_TOKEN?.trim()) {
+  if (hasLinkedBlobStore() || isVercelHosted()) {
     return new VercelBlobArchiveAdapter();
   }
   return undefined;
 }
 
-function resolveIndexAdapter(
-  backend: ArchiveBackend,
-): KvArchiveIndexAdapter | undefined {
-  if (backend === "vercel") {
-    return new VercelKvArchiveIndexAdapter();
-  }
-  if (backend === "postgres") {
-    return new PostgresArchiveIndexAdapter();
-  }
-  return undefined;
-}
-
 export function createArchiveStore(
   agentRoot: string,
   options?: { backend?: ArchiveBackend; world?: AgentWorkflowWorldDefinition },
 ): LocalArchiveStore | ProdArchiveStore {
   const backend = options?.backend ?? resolveArchiveBackend(options?.world);
   const blob = resolveBlobAdapter();
-  const index = resolveIndexAdapter(backend);
-  if (backend !== "local" && blob && index) {
-    return new ProdArchiveStore(agentRoot, blob, index);
+  if (backend === "vercel" && blob) {
+    return new ProdArchiveStore(agentRoot, blob);
   }
   return LocalArchiveStore.fromAgentRoot(agentRoot);
 }

package/src/archive/types.ts

@@ -65,6 +65,7 @@ export interface ArchivePaths {
 export interface BlobArchiveAdapter {
   put(key: string, body: string | Uint8Array): Promise<void>;
   get(key: string): Promise<Uint8Array | null>;
+  list(prefix: string): Promise<string[]>;
 }
 
 /** Production KV / Postgres index adapter for archive listings. */

package/src/archive/vercel-blob-adapter.ts

@@ -1,4 +1,5 @@
 import type { BlobArchiveAdapter } from "./types.js";
+import { blobList } from "../storage/vercel-blob.js";
 
 export class VercelBlobArchiveAdapter implements BlobArchiveAdapter {
   async put(key: string, body: string | Uint8Array): Promise<void> {
@@ -18,4 +19,8 @@ export class VercelBlobArchiveAdapter implements BlobArchiveAdapter {
     if (!response.ok) return null;
     return new Uint8Array(await response.arrayBuffer());
   }
+
+  async list(prefix: string): Promise<string[]> {
+    return blobList(prefix);
+  }
 }

package/src/authoring/schedule-manager.ts

@@ -10,28 +10,48 @@ export interface ScheduleHandle {
   stop(): void;
 }
 
+export interface ScheduleTaskManifest {
+  scheduledTasks: Record<string, string | string[]>;
+  tasks: Array<{ name: string; cron: string }>;
+}
+
 export interface ScheduleCronManifest {
   crons: Array<{ path: string; schedule: string; name: string }>;
 }
 
-export function exportScheduleCronManifest(schedules: LoadedSchedule[]): ScheduleCronManifest {
+export function exportScheduleTaskManifest(schedules: LoadedSchedule[]): ScheduleTaskManifest {
+  const scheduledTasks: Record<string, string | string[]> = {};
+  const tasks: Array<{ name: string; cron: string }> = [];
+
+  for (const schedule of schedules) {
+    const { name, cron } = schedule.definition;
+    tasks.push({ name, cron });
+    const existing = scheduledTasks[cron];
+    if (!existing) {
+      scheduledTasks[cron] = name;
+    } else if (Array.isArray(existing)) {
+      existing.push(name);
+    } else {
+      scheduledTasks[cron] = [existing, name];
+    }
+  }
+
+  return { scheduledTasks, tasks };
+}
+
+/** @deprecated Use Nitro scheduled tasks in production. */
+export function exportScheduleCronManifest(schedules: LoadedSchedule[]) {
   return {
     crons: schedules.map((schedule) => ({
       name: schedule.definition.name,
-      path: `/internal/cron/${schedule.definition.name}`,
+      path: `/internal/schedule/${schedule.definition.name}`,
       schedule: schedule.definition.cron,
     })),
   };
 }
 
-function authorizeCronRequest(req: IncomingMessage): boolean {
-  const secret = process.env.CRON_SECRET?.trim();
-  if (!secret) return process.env.NODE_ENV !== "production";
-  const auth = req.headers.authorization ?? "";
-  return auth === `Bearer ${secret}`;
-}
-
-export function tryHandleScheduleCronRoute(
+/** Eve-style dev dispatch — manually trigger a schedule by name. */
+export function tryHandleScheduleDevDispatch(
   req: IncomingMessage,
   res: ServerResponse,
   schedules: LoadedSchedule[],
@@ -39,14 +59,8 @@ export function tryHandleScheduleCronRoute(
 ): boolean {
   const method = (req.method ?? "GET").toUpperCase();
   const pathname = new URL(req.url ?? "/", "http://localhost").pathname;
-  const match = pathname.match(/^\/internal\/cron\/([^/]+)$/);
-  if (method !== "GET" || !match) return false;
-
-  if (!authorizeCronRequest(req)) {
-    res.statusCode = 401;
-    res.end("Unauthorized");
-    return true;
-  }
+  const match = pathname.match(/^\/internal\/schedule\/([^/]+)$/);
+  if (method !== "POST" || !match) return false;
 
   const name = match[1]!;
   const schedule = schedules.find((s) => s.definition.name === name);
@@ -61,7 +75,7 @@ export function tryHandleScheduleCronRoute(
     .then(() => {
       res.statusCode = 200;
       res.setHeader("content-type", "application/json; charset=utf-8");
-      res.end(JSON.stringify({ ok: true, schedule: name }));
+      res.end(JSON.stringify({ ok: true, schedule: name, mode: "dev_dispatch" }));
     })
     .catch((err: unknown) => {
       res.statusCode = 500;
@@ -79,10 +93,10 @@ export function startScheduleTimers(
 ): ScheduleHandle {
   const world = resolveWorkflowWorldType(workflow);
   if (world !== "local") {
-    const manifest = exportScheduleCronManifest(schedules);
+    const manifest = exportScheduleTaskManifest(schedules);
     console.log(
-      `[plasm:schedule] prod world=${world} — register Vercel Cron routes:`,
-      JSON.stringify(manifest.crons, null, 2),
+      `[plasm:schedule] prod world=${world} — Nitro scheduled tasks:`,
+      JSON.stringify(manifest.scheduledTasks, null, 2),
     );
     return { stop: () => {} };
   }

package/src/cli/build-manifest.ts

@@ -0,0 +1,18 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+export interface PlasmBuildManifest {
+  compiledSlots?: Record<string, string>;
+  projectRoot?: string;
+}
+
+/** Read `.plasm/discovery/manifest.json` written by `plasm-agent build`. */
+export async function readBuildManifest(agentRoot: string): Promise<PlasmBuildManifest | null> {
+  const manifestPath = path.join(agentRoot, ".plasm", "discovery", "manifest.json");
+  try {
+    const raw = await readFile(manifestPath, "utf8");
+    return JSON.parse(raw) as PlasmBuildManifest;
+  } catch {
+    return null;
+  }
+}

package/src/cli/build.ts

@@ -1,6 +1,7 @@
-import { mkdir, writeFile, readFile } from "node:fs/promises";
+import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 
+import { readBuildManifest } from "./build-manifest.js";
 import { compileAuthoredSlots } from "./compile-authored-slots.js";
 import type { ResolvedAgentProject } from "./project-root.js";
 import { isNativeEngineAvailable } from "../engine/napi-binding.js";
@@ -79,15 +80,5 @@ export async function runPlasmBuild(project: ResolvedAgentProject): Promise<Plas
   };
 }
 
-export async function readBuildManifest(agentRoot: string): Promise<{
-  compiledSlots?: Record<string, string>;
-  projectRoot?: string;
-} | null> {
-  const manifestPath = path.join(agentRoot, ".plasm", "discovery", "manifest.json");
-  try {
-    const raw = await readFile(manifestPath, "utf8");
-    return JSON.parse(raw) as { compiledSlots?: Record<string, string>; projectRoot?: string };
-  } catch {
-    return null;
-  }
-}
+export { readBuildManifest } from "./build-manifest.js";
+export type { PlasmBuildManifest } from "./build-manifest.js";

package/src/cli/compile-authored-slots.ts

@@ -62,6 +62,15 @@ export async function compileAuthoredSlots(
         format: "esm",
         outfile: outFile,
         banner: { js: ESBUILD_BANNER },
+        external: [
+          "@plasm_lang/vercel-agent",
+          "@plasm_lang/vercel-agent/*",
+          "@plasm_lang/engine",
+          "@vercel/functions",
+          "@vercel/blob",
+          "workflow",
+          "workflow/api",
+        ],
         logLevel: "silent",
       });
 

package/src/cli/init-scaffold.ts

@@ -114,20 +114,24 @@ export async function patchProjectPackageJson(
       ...pkg.dependencies,
       "@plasm_lang/vercel-agent": `^${version}`,
       "@plasm_lang/engine": `^${version}`,
+      "@ai-sdk/otel": "^1.0.3",
       "@vercel/blob": "^0.27.3",
       "@vercel/functions": "^3.4.3",
-      "@vercel/kv": "^3.0.0",
       "@vercel/otel": "^1.5.0",
+      ai: "^6.0.0",
+      workflow: "^4.5.0",
     };
   } else {
     pkg.dependencies = {
       ...pkg.dependencies,
       "@plasm_lang/vercel-agent": `file:${path.resolve(packageRoot)}`,
       "@plasm_lang/engine": `file:${monorepoEngineRoot(packageRoot)}`,
+      "@ai-sdk/otel": "^1.0.3",
       "@vercel/blob": "^0.27.3",
       "@vercel/functions": "^3.4.3",
-      "@vercel/kv": "^3.0.0",
       "@vercel/otel": "^1.5.0",
+      ai: "^6.0.0",
+      workflow: "^4.5.0",
     };
   }
 

package/src/cli/init.ts

@@ -94,15 +94,11 @@ const ENV_EXAMPLE = `# Vercel AI Gateway
 # Local / self-host: run \`plasm-agent link\` or set AI_GATEWAY_API_KEY.
 AI_GATEWAY_API_KEY=
 
-# Vercel Cron auth (production)
+# Optional: manual cron trigger auth (Vercel Cron uses x-vercel-cron by default)
 CRON_SECRET=
 
-# Durable state on Vercel (optional locally)
-KV_REST_API_URL=
-KV_REST_API_TOKEN=
+# Optional local overrides (Vercel Blob OIDC is automatic when a store is linked)
 BLOB_READ_WRITE_TOKEN=
-PLASM_STATE_BACKEND=kv
-PLASM_ARCHIVE_BACKEND=vercel
 
 # Optional overrides
 PLASM_AGENT_MODEL=anthropic/claude-sonnet-4.6

package/src/index.ts

@@ -52,10 +52,11 @@ export type {
 export { tryHandleChannelRoute, listChannelRoutes } from "./authoring/channel-dispatch.js";
 export {
   exportScheduleCronManifest,
+  exportScheduleTaskManifest,
   startScheduleTimers,
-  tryHandleScheduleCronRoute,
+  tryHandleScheduleDevDispatch,
 } from "./authoring/schedule-manager.js";
-export type { ScheduleCronManifest, ScheduleHandle } from "./authoring/schedule-manager.js";
+export type { ScheduleCronManifest, ScheduleHandle, ScheduleTaskManifest } from "./authoring/schedule-manager.js";
 export {
   createSubagentRegistry,
   loadSubagents,

package/src/nitro/agent-summary.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 
 import type { LoadedProjectSlots } from "../authoring/slot-loader.js";
 import { listChannelRoutes } from "../authoring/channel-dispatch.js";
-import { exportScheduleCronManifest } from "../authoring/schedule-manager.js";
+import { exportScheduleTaskManifest } from "../authoring/schedule-manager.js";
 import type { AgentDefinition } from "../define-agent.js";
 import type { ProjectDiscovery } from "../discovery/project-walker.js";
 import { frameworkPackageVersion } from "../package-version.js";
@@ -78,7 +78,7 @@ export function buildPlasmAgentSummary(options: {
     })),
   );
 
-  const scheduleManifest = exportScheduleCronManifest(loadedSlots.schedules);
+  const scheduleManifest = exportScheduleTaskManifest(loadedSlots.schedules);
 
   const diagnostics = [...loadedSlots.diagnostics, ...discovery.diagnostics];
 
@@ -92,12 +92,12 @@ export function buildPlasmAgentSummary(options: {
       modelId: definition.model,
     },
     instructions,
-    schedules: scheduleManifest.crons.map((cron) => ({
-      name: cron.name,
-      cron: cron.schedule,
+    schedules: scheduleManifest.tasks.map((task) => ({
+      name: task.name,
+      cron: task.cron,
       logicalPath: rel(
-        loadedSlots.schedules.find((s) => s.definition.name === cron.name)?.sourcePath ??
-          path.join(agentRoot, "schedules", `${cron.name}.ts`),
+        loadedSlots.schedules.find((s) => s.definition.name === task.name)?.sourcePath ??
+          path.join(agentRoot, "schedules", `${task.name}.ts`),
       ),
     })),
     tools: [],

package/src/nitro/build-application.ts

@@ -11,6 +11,9 @@ import { copyVercelFunctionAssets } from "./copy-vercel-function-assets.js";
 import { isVercelBuildEnvironment, vercelOutputDir } from "./paths.js";
 import { preparePlasmHost } from "./prepare-host.js";
 import { writePlasmNitroCatchAllRoute } from "./write-nitro-entry.js";
+import { ensureWorkflowBuilderDirs } from "./ensure-workflow-builder-dirs.js";
+import { writeNitroScheduleTasks } from "./write-nitro-schedule-tasks.js";
+import { writeWorkflowDispatchRoute } from "./write-workflow-dispatch-route.js";
 
 export interface PlasmApplicationBuildResult {
   outputDir: string;
@@ -36,6 +39,26 @@ export async function buildPlasmApplication(options: {
 
   await writePlasmNitroCatchAllRoute(projectRoot, compiledSlots);
 
+  const loadedSlotsForTasks = await loadAuthoredSlots({
+    discovery,
+    agentRoot,
+    projectRoot,
+    compiledSlots,
+  });
+  if (loadedSlotsForTasks.schedules.length > 0) {
+    await writeNitroScheduleTasks({
+      projectRoot,
+      agentRoot,
+      schedules: loadedSlotsForTasks.schedules,
+      compiledSlots,
+    });
+  }
+
+  if (host.workflowEnabled) {
+    await ensureWorkflowBuilderDirs(projectRoot);
+    await writeWorkflowDispatchRoute(projectRoot);
+  }
+
   const nitro = await createPlasmNitro(host, false);
   try {
     const outputDir = await buildNitroOutput(nitro);
@@ -86,6 +109,26 @@ export async function startPlasmNitroDev(options: {
   const host = await preparePlasmHost(options);
   await writePlasmNitroCatchAllRoute(options.projectRoot, options.compiledSlots);
 
+  const loadedSlotsForTasks = await loadAuthoredSlots({
+    discovery: options.discovery,
+    agentRoot: options.agentRoot,
+    projectRoot: options.projectRoot,
+    compiledSlots: options.compiledSlots,
+  });
+  if (loadedSlotsForTasks.schedules.length > 0) {
+    await writeNitroScheduleTasks({
+      projectRoot: options.projectRoot,
+      agentRoot: options.agentRoot,
+      schedules: loadedSlotsForTasks.schedules,
+      compiledSlots: options.compiledSlots,
+    });
+  }
+
+  if (host.workflowEnabled) {
+    await ensureWorkflowBuilderDirs(options.projectRoot);
+    await writeWorkflowDispatchRoute(options.projectRoot);
+  }
+
   const nitro = await createPlasmNitro(host, true);
   const server = createDevServer(nitro);