@plasm_lang/vercel-agent 0.3.85 → 0.3.87

package/src/nitro/create-plasm-nitro.ts

@@ -9,6 +9,7 @@ import type { PreparedPlasmHost } from "./prepare-host.js";
 import {
   isVercelBuildEnvironment,
   plasmNitroBuildDir,
+  PLASM_NITRO_BUILD_DIR,
   plasmNitroOutputDir,
   plasmNitroRoutesDir,
   vercelOutputDir,
@@ -16,12 +17,16 @@ import {
 import { createPlasmVercelOptions } from "./vercel-build-output-config.js";
 
 const SERVER_TRACE_DEPS = [
+  "@ai-sdk/otel",
+  "@opentelemetry/api",
   "@plasm_lang/engine",
   "@plasm_lang/vercel-agent",
   "@vercel/functions",
   "@vercel/blob",
-  "@vercel/kv",
   "@vercel/otel",
+  "ai",
+  "workflow",
+  "workflow/api",
 ];
 
 function resolveNitroPreset(dev: boolean): NitroConfig["preset"] {
@@ -70,6 +75,7 @@ export async function createPlasmNitro(
   const config: NitroConfig = {
     rootDir: host.projectRoot,
     buildDir: plasmNitroBuildDir(host.projectRoot),
+    scanDirs: [path.join(host.projectRoot, PLASM_NITRO_BUILD_DIR)],
     preset,
     dev,
     serverDir: false,
@@ -77,6 +83,15 @@ export async function createPlasmNitro(
     handlers: [{ route: "/**", handler: catchAllHandler }],
     publicAssets,
     modules,
+    experimental: {
+      tasks: Object.keys(host.scheduledTasks).length > 0,
+    },
+    scheduledTasks: host.scheduledTasks,
+    workflow: host.workflowEnabled
+      ? {
+          dirs: ["workflows"],
+        }
+      : undefined,
     traceDeps: [
       ...traceDeps,
       "./agent/**",
@@ -96,7 +111,6 @@ export async function createPlasmNitro(
           },
           config: {
             ...vercelConfig,
-            crons: host.scheduleCrons,
           },
         }
       : undefined,

package/src/nitro/ensure-workflow-builder-dirs.ts

@@ -0,0 +1,42 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import path from "node:path";
+
+const WORKFLOW_DIRS_NEEDLE =
+  "dirs: ['.'], // Different apps that use nitro have different directories";
+const WORKFLOW_DIRS_REPLACEMENT =
+  "dirs: nitro.options.workflow?.dirs ?? ['workflows'], // plasm: scoped workflow scan";
+
+async function patchBuildersFile(buildersPath: string): Promise<void> {
+  const source = await readFile(buildersPath, "utf8");
+  if (!source.includes(WORKFLOW_DIRS_NEEDLE)) return;
+  await writeFile(
+    buildersPath,
+    source.replaceAll(WORKFLOW_DIRS_NEEDLE, WORKFLOW_DIRS_REPLACEMENT),
+    "utf8",
+  );
+}
+
+/** @workflow/nitro hardcodes dirs: ['.'] — scope to nitro.options.workflow.dirs for Eve apps. */
+export async function ensureWorkflowBuilderDirs(projectRoot: string): Promise<void> {
+  const candidates = new Set<string>();
+  candidates.add(path.join(projectRoot, "node_modules/@workflow/nitro/dist/builders.js"));
+
+  try {
+    const require = createRequire(import.meta.url);
+    const nitroEntry = require.resolve("@workflow/nitro");
+    candidates.add(path.join(path.dirname(nitroEntry), "builders.js"));
+  } catch {
+    // framework package may not resolve @workflow/nitro in all contexts
+  }
+
+  await Promise.all(
+    [...candidates].map(async (buildersPath) => {
+      try {
+        await patchBuildersFile(buildersPath);
+      } catch {
+        // optional copy
+      }
+    }),
+  );
+}

package/src/nitro/patch-vercel-config.ts

@@ -29,9 +29,6 @@ export async function patchVercelOutputConfig(
   config.framework = {
     version: frameworkPackageVersion(),
   };
-  if (host.scheduleCrons.length > 0) {
-    config.crons = host.scheduleCrons;
-  }
 
   await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
 }

package/src/nitro/prepare-host.ts

@@ -5,7 +5,7 @@ import type { CompiledSlotMap } from "../cli/compile-authored-slots.js";
 import { loadAuthoredSlots } from "../authoring/slot-loader.js";
 import type { AgentDefinition } from "../define-agent.js";
 import { walkAgentProject, type ProjectDiscovery } from "../discovery/project-walker.js";
-import { exportScheduleCronManifest } from "../authoring/schedule-manager.js";
+import { exportScheduleTaskManifest } from "../authoring/schedule-manager.js";
 import { projectUsesWorkflowDirectives } from "./workflow-directives.js";
 
 export interface PreparedPlasmHost {
@@ -15,6 +15,7 @@ export interface PreparedPlasmHost {
   discovery: ProjectDiscovery;
   compiledSlots: CompiledSlotMap;
   scheduleCrons: Array<{ path: string; schedule: string }>;
+  scheduledTasks: Record<string, string | string[]>;
   externalDeps: string[];
   workflowEnabled: boolean;
 }
@@ -46,10 +47,7 @@ export async function preparePlasmHost(options: {
     compiledSlots,
   });
 
-  const scheduleCrons = exportScheduleCronManifest(loadedSlots.schedules).crons.map((c) => ({
-    path: c.path,
-    schedule: c.schedule,
-  }));
+  const taskManifest = exportScheduleTaskManifest(loadedSlots.schedules);
 
   const externalDeps = definition.build?.externalDependencies ?? [];
   const workflowConfigured = definition.experimental?.workflow !== undefined;
@@ -62,7 +60,8 @@ export async function preparePlasmHost(options: {
     definition,
     discovery,
     compiledSlots,
-    scheduleCrons,
+    scheduleCrons: [],
+    scheduledTasks: taskManifest.scheduledTasks,
     externalDeps,
     workflowEnabled,
   };

package/src/nitro/workflow-directives.ts

@@ -28,6 +28,7 @@ async function walkTsFiles(dir: string): Promise<string[]> {
 /** True when authored sources contain Workflow SDK directives (needs @workflow/nitro). */
 export async function projectUsesWorkflowDirectives(projectRoot: string): Promise<boolean> {
   const roots = [
+    path.join(projectRoot, "workflows"),
     path.join(projectRoot, "agent"),
     path.join(projectRoot, "lib"),
   ];

package/src/nitro/write-nitro-schedule-tasks.ts

@@ -0,0 +1,67 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import type { CompiledSlotMap } from "../cli/compile-authored-slots.js";
+import type { LoadedSchedule } from "../authoring/slot-loader.js";
+import { PLASM_NITRO_BUILD_DIR } from "./paths.js";
+
+function compiledScheduleImport(
+  schedule: LoadedSchedule,
+  agentRoot: string,
+  compiledSlots: CompiledSlotMap,
+  projectRoot: string,
+): string {
+  const relFromAgent = path.relative(agentRoot, schedule.sourcePath);
+  const compiled = compiledSlots[relFromAgent];
+  if (!compiled) {
+    throw new Error(
+      `missing compiled schedule slot for ${schedule.definition.name} (${relFromAgent})`,
+    );
+  }
+  const relImport = path
+    .relative(path.join(projectRoot, PLASM_NITRO_BUILD_DIR, "tasks"), path.join(projectRoot, compiled))
+    .replace(/\\/g, "/");
+  return relImport.startsWith(".") ? relImport : `./${relImport}`;
+}
+
+/** Emit Nitro scheduled tasks (Eve-aligned — no HTTP /internal/cron routes). */
+export async function writeNitroScheduleTasks(options: {
+  projectRoot: string;
+  agentRoot: string;
+  schedules: LoadedSchedule[];
+  compiledSlots: CompiledSlotMap;
+}): Promise<void> {
+  const { projectRoot, agentRoot, schedules, compiledSlots } = options;
+  const tasksDir = path.join(projectRoot, PLASM_NITRO_BUILD_DIR, "tasks");
+  await mkdir(tasksDir, { recursive: true });
+
+  for (const schedule of schedules) {
+    const name = schedule.definition.name;
+    const importPath = compiledScheduleImport(schedule, agentRoot, compiledSlots, projectRoot);
+    const source = `import path from "node:path";
+
+import agentDefinition from "../../../agent/agent.js";
+import { createPlasmApp } from "@plasm_lang/vercel-agent/server";
+import scheduleSlot from "${importPath}";
+
+const agentRoot = path.join(process.cwd(), "agent");
+
+export default {
+  meta: {
+    description: ${JSON.stringify(`Plasm schedule: ${name}`)},
+  },
+  async run() {
+    const app = await createPlasmApp({
+      agentRoot,
+      definition: agentDefinition,
+      mode: "prod",
+      sessions: false,
+    });
+    const definition = scheduleSlot.default ?? scheduleSlot;
+    await definition.handler(app.getAuthoringContext());
+  },
+};
+`;
+    await writeFile(path.join(tasksDir, `${name}.ts`), source, "utf8");
+  }
+}

package/src/nitro/write-workflow-dispatch-route.ts

@@ -0,0 +1,68 @@
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+
+const WORKFLOW_DISPATCH_ROUTE = "/internal/workflow/dispatch";
+
+/** Emit workflow dispatch route for durable steps (no Plasm imports in workflow bundles). */
+export async function writeWorkflowDispatchRoute(projectRoot: string): Promise<string> {
+  const routesDir = path.join(projectRoot, ".plasm", "nitro", "routes", "internal", "workflow");
+  await mkdir(routesDir, { recursive: true });
+  const routePath = path.join(routesDir, "dispatch.post.ts");
+  const source = `import path from "node:path";
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+import agentDefinition from "../../../../agent/agent.js";
+import { createPlasmApp } from "@plasm_lang/vercel-agent/server";
+
+const agentRoot = path.join(process.cwd(), "agent");
+
+type NitroNodeEvent = {
+  node: { req: IncomingMessage; res: ServerResponse };
+};
+
+async function readJson(req: IncomingMessage): Promise<Record<string, unknown>> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) chunks.push(Buffer.from(chunk));
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) return {};
+  return JSON.parse(raw) as Record<string, unknown>;
+}
+
+export default async (event: NitroNodeEvent) => {
+  const { req, res } = event.node;
+  if ((req.method ?? "GET").toUpperCase() !== "POST") {
+    res.statusCode = 405;
+    res.end("Method Not Allowed");
+    return;
+  }
+
+  const body = await readJson(req);
+  const job = String(body.job ?? "");
+  const force = body.force === true;
+
+  if (job !== "mcp-radar-scan") {
+    res.statusCode = 404;
+    res.setHeader("content-type", "application/json; charset=utf-8");
+    res.end(JSON.stringify({ error: "unknown_job", job }));
+    return;
+  }
+
+  const app = await createPlasmApp({
+    agentRoot,
+    definition: agentDefinition,
+    mode: "prod",
+    sessions: false,
+  });
+  const { runRadar } = await import("../../../../lib/run-radar.js");
+  const result = await runRadar(app.getAuthoringContext(), { force });
+
+  res.statusCode = 200;
+  res.setHeader("content-type", "application/json; charset=utf-8");
+  res.end(JSON.stringify(result));
+};
+`;
+  await writeFile(routePath, source, "utf8");
+  return WORKFLOW_DISPATCH_ROUTE;
+}
+
+export { WORKFLOW_DISPATCH_ROUTE };

package/src/operator/routes.ts

@@ -200,23 +200,23 @@ export function createOperatorRoutes(ctx: OperatorRouteContext): OperatorHandler
     },
 
     async listTraces() {
-      const { LocalArchiveStore } = await import("../archive/index.js");
-      const archive = LocalArchiveStore.fromAgentRoot(ctx.agentRoot);
+      const { createArchiveStore } = await import("../archive/resolve-backend.js");
+      const archive = createArchiveStore(ctx.agentRoot);
       const tenantScope = ctx.tenantScope ?? "local";
       const traces = await archive.listTraces(tenantScope);
       return { traces };
     },
 
     async listArchives() {
-      const { LocalArchiveStore } = await import("../archive/index.js");
-      const archive = LocalArchiveStore.fromAgentRoot(ctx.agentRoot);
+      const { createArchiveStore } = await import("../archive/resolve-backend.js");
+      const archive = createArchiveStore(ctx.agentRoot);
       const { plans, runs, paths } = await archive.listArchives();
       return { plans, runs, paths };
     },
 
     async listRuns() {
-      const { LocalArchiveStore } = await import("../archive/index.js");
-      const archive = LocalArchiveStore.fromAgentRoot(ctx.agentRoot);
+      const { createArchiveStore } = await import("../archive/resolve-backend.js");
+      const archive = createArchiveStore(ctx.agentRoot);
       const runs = await archive.listRuns();
       return { runs };
     },

package/src/project-info.ts

@@ -7,7 +7,7 @@ import type { AgentDefinition } from "./define-agent.js";
 import type { ProjectDiscovery } from "./discovery/project-walker.js";
 import { walkAgentProject } from "./discovery/project-walker.js";
 import { isNativeEngineAvailable } from "./engine/napi-binding.js";
-import { exportScheduleCronManifest } from "./authoring/schedule-manager.js";
+import { exportScheduleTaskManifest } from "./authoring/schedule-manager.js";
 import { isGatewayConfigured } from "./gateway-model.js";
 import type { LoadedProjectSlots } from "./authoring/slot-loader.js";
 import { frameworkPackageVersion } from "./package-version.js";
@@ -38,7 +38,8 @@ export interface ProjectInfoRoutes {
   sessionContinue: string;
   sessionStream: string;
   channels: Array<{ method: string; path: string }>;
-  scheduleCrons: string[];
+  scheduledTasks: string[];
+  scheduleDevDispatch: string[];
   operator: string;
 }
 
@@ -75,7 +76,7 @@ export interface ProjectInfoPayload {
     modelOptions: AgentDefinition["modelOptions"] | null;
     build: AgentDefinition["build"] | null;
     experimental: AgentDefinition["experimental"] | null;
-    scheduleCrons: ReturnType<typeof exportScheduleCronManifest> | null;
+    scheduledTasks: ReturnType<typeof exportScheduleTaskManifest> | null;
     sessions: { active: number };
     routes: ProjectInfoRoutes;
   };
@@ -176,14 +177,14 @@ export async function collectProjectInfo(
   };
 
   if (dev) {
-    const scheduleCrons = exportScheduleCronManifest(loadedSlots.schedules);
+    const scheduledTasks = exportScheduleTaskManifest(loadedSlots.schedules);
     payload.dev = {
       model: dev.definition.model,
       compaction: dev.definition.compaction ?? null,
       modelOptions: dev.definition.modelOptions ?? null,
       build: dev.definition.build ?? null,
       experimental: dev.definition.experimental ?? null,
-      scheduleCrons,
+      scheduledTasks,
       sessions: { active: dev.sessionCount },
       routes: {
         health: "GET /plasm/v1/health",
@@ -192,7 +193,10 @@ export async function collectProjectInfo(
         sessionContinue: "POST /plasm/v1/session/:sessionId",
         sessionStream: "GET /plasm/v1/session/:id/stream",
         channels: listChannelRoutes(loadedSlots.channels),
-        scheduleCrons: scheduleCrons.crons.map((c) => `GET ${c.path}`),
+        scheduledTasks: scheduledTasks.tasks.map((t) => `nitro:task/${t.name}`),
+        scheduleDevDispatch: scheduledTasks.tasks.map(
+          (t) => `POST /internal/schedule/${t.name}`,
+        ),
         operator: "GET /operator",
       },
     };

package/src/server/plasm-handler.ts

@@ -6,7 +6,7 @@ import {
   createAgentFromDefinition,
   resolveAgentDefinition,
 } from "../define-agent.js";
-import { readBuildManifest } from "../cli/build.js";
+import { readBuildManifest } from "../cli/build-manifest.js";
 import { createAuthoringContext, type AuthoringContext } from "../authoring/context.js";
 import { tryHandleChannelRoute } from "../authoring/channel-dispatch.js";
 import {
@@ -20,8 +20,8 @@ import {
   type SubagentRegistry,
 } from "../authoring/subagent-loader.js";
 import {
+  tryHandleScheduleDevDispatch,
   startScheduleTimers,
-  tryHandleScheduleCronRoute,
   type ScheduleHandle,
 } from "../authoring/schedule-manager.js";
 import { walkAgentProject, type ProjectDiscovery } from "../discovery/project-walker.js";
@@ -143,13 +143,13 @@ export async function handlePlasmRequest(
 
   const loadedSlots = await app.getLoadedSlots();
   if (loadedSlots?.schedules.length) {
-    const handledCron = tryHandleScheduleCronRoute(
+    const handledSchedule = tryHandleScheduleDevDispatch(
       req,
       res,
       loadedSlots.schedules,
       app.getAuthoringContext(),
     );
-    if (handledCron) return;
+    if (handledSchedule) return;
   }
 
   if (loadedSlots?.channels.length) {

package/src/state/blob-state-adapter.ts

@@ -0,0 +1,65 @@
+import type { SymbolRegistrySnapshot } from "../symbol-registry.js";
+import type { AgentSessionState } from "../session-state.js";
+import {
+  blobGetJson,
+  blobList,
+  blobPutJson,
+} from "../storage/vercel-blob.js";
+import type { AgentStateStore, StateBackend } from "./define-state.js";
+import { intentKey } from "./fs-state-adapter.js";
+
+function sessionBlobKey(tenantScope: string, intent: string): string {
+  return `plasm/state/${tenantScope}/sessions/${intentKey(intent)}.json`;
+}
+
+function symbolsBlobKey(tenantScope: string): string {
+  return `plasm/state/${tenantScope}/symbols.json`;
+}
+
+function sessionPrefix(tenantScope: string): string {
+  return `plasm/state/${tenantScope}/sessions/`;
+}
+
+export class BlobStateAdapter implements AgentStateStore {
+  constructor(
+    private readonly agentRoot: string,
+    private readonly tenantScope: string,
+  ) {
+    void this.agentRoot;
+  }
+
+  backend(): StateBackend {
+    return "blob";
+  }
+
+  async get(intent: string): Promise<AgentSessionState | null> {
+    return blobGetJson<AgentSessionState>(sessionBlobKey(this.tenantScope, intent));
+  }
+
+  async put(state: AgentSessionState): Promise<void> {
+    await blobPutJson(sessionBlobKey(this.tenantScope, state.intent), state);
+  }
+
+  async listIntents(): Promise<string[]> {
+    const prefix = sessionPrefix(this.tenantScope);
+    const paths = await blobList(prefix);
+    const intents: string[] = [];
+    for (const pathname of paths) {
+      if (!pathname.endsWith(".json")) continue;
+      const state = await blobGetJson<AgentSessionState>(pathname);
+      if (state?.intent) intents.push(state.intent);
+    }
+    return intents;
+  }
+
+  async getSymbolRegistry(tenantId: string): Promise<SymbolRegistrySnapshot | null> {
+    return blobGetJson<SymbolRegistrySnapshot>(symbolsBlobKey(tenantId));
+  }
+
+  async putSymbolRegistry(
+    tenantId: string,
+    snapshot: SymbolRegistrySnapshot,
+  ): Promise<void> {
+    await blobPutJson(symbolsBlobKey(tenantId), snapshot);
+  }
+}

package/src/state/define-state.ts

@@ -1,11 +1,14 @@
 import type { AgentWorkflowWorldDefinition } from "../define-agent.js";
+import { isVercelHosted } from "../gateway-model.js";
 import type { SymbolRegistrySnapshot } from "../symbol-registry.js";
 import type { AgentSessionState, SessionStore } from "../session-state.js";
+import { hasLinkedBlobStore } from "../storage/vercel-blob.js";
+import { BlobStateAdapter } from "./blob-state-adapter.js";
 import { FsStateAdapter } from "./fs-state-adapter.js";
 import { KvStateAdapter } from "./kv-state-adapter.js";
 import { PostgresStateAdapter } from "./postgres-state-adapter.js";
 
-export type StateBackend = "fs" | "kv" | "postgres";
+export type StateBackend = "fs" | "blob" | "kv" | "postgres";
 
 export interface AgentStateStore extends SessionStore {
   backend(): StateBackend;
@@ -17,12 +20,15 @@ export function resolveStateBackend(
   world?: AgentWorkflowWorldDefinition,
 ): StateBackend {
   const explicit = process.env.PLASM_STATE_BACKEND?.trim().toLowerCase();
-  if (explicit === "fs" || explicit === "kv" || explicit === "postgres") {
+  if (explicit === "fs" || explicit === "blob" || explicit === "kv" || explicit === "postgres") {
     return explicit;
   }
   if (process.env.KV_REST_API_URL?.trim() || process.env.PLASM_KV_REST_API_URL?.trim()) {
     return "kv";
   }
+  if (isVercelHosted() || hasLinkedBlobStore()) {
+    return "blob";
+  }
   if (
     process.env.WORKFLOW_POSTGRES_URL?.trim() ||
     process.env.DATABASE_URL?.trim() ||
@@ -47,6 +53,8 @@ export function createAgentStateStore(options: {
   const backend = options.backend ?? resolveStateBackend(options.world);
   const tenantScope = options.tenantScope ?? "local";
   switch (backend) {
+    case "blob":
+      return new BlobStateAdapter(options.agentRoot, tenantScope);
     case "kv":
       return new KvStateAdapter(options.agentRoot, tenantScope);
     case "postgres":

package/src/state/fs-state-adapter.ts

@@ -8,7 +8,7 @@ import {
 } from "../session-state.js";
 import type { AgentStateStore, StateBackend } from "./define-state.js";
 
-function intentKey(intent: string): string {
+export function intentKey(intent: string): string {
   return Buffer.from(intent, "utf8").toString("base64url");
 }
 

package/src/storage/vercel-blob.ts

@@ -0,0 +1,47 @@
+/** Eve-aligned Vercel Blob helpers — OIDC on hosted Vercel, no manual tokens required. */
+
+export function hasLinkedBlobStore(): boolean {
+  return Boolean(
+    process.env.BLOB_READ_WRITE_TOKEN?.trim() ||
+      process.env.BLOB_STORE_ID?.trim() ||
+      process.env.PLASM_RUN_ARTIFACTS_URL?.trim(),
+  );
+}
+
+export async function blobGetText(key: string): Promise<string | null> {
+  const { head } = await import("@vercel/blob");
+  const meta = await head(key).catch(() => null);
+  if (!meta?.url) return null;
+  const response = await fetch(meta.url);
+  if (!response.ok) return null;
+  return response.text();
+}
+
+export async function blobPutText(key: string, body: string): Promise<void> {
+  const { put } = await import("@vercel/blob");
+  await put(key, body, { access: "public", addRandomSuffix: false });
+}
+
+export async function blobGetJson<T>(key: string): Promise<T | null> {
+  const text = await blobGetText(key);
+  if (!text) return null;
+  return JSON.parse(text) as T;
+}
+
+export async function blobPutJson(key: string, value: unknown): Promise<void> {
+  await blobPutText(key, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export async function blobList(prefix: string): Promise<string[]> {
+  const { list } = await import("@vercel/blob");
+  const keys: string[] = [];
+  let cursor: string | undefined;
+  do {
+    const page = await list({ prefix, cursor });
+    for (const blob of page.blobs) {
+      keys.push(blob.pathname);
+    }
+    cursor = page.hasMore ? page.cursor : undefined;
+  } while (cursor);
+  return keys;
+}

package/templates/mcp-radar/README.md

@@ -26,24 +26,25 @@ The canonical template source is this directory (`examples/mcp-radar-agent/`).
 
 ## Deploy to Vercel
 
-Low-friction production path (eve-aligned): `vercel.json` + catch-all `api/[[...path]].ts` mounts the same routes as local dev (channels, cron, `/plasm/v1/info`).
+Eve-aligned production path: link Blob once, deploy — **no manual env vars on Vercel** for Gateway, Blob, or cron auth.
 
 ```bash
-cd examples/mcp-radar-agent   # or your bootstrapped project
+cd examples/mcp-radar-agent
 plasm-agent link
+node scripts/provision-vercel-storage.mjs   # vercel blob create-store → project OIDC
 plasm-agent build
-vercel env pull .env.local    # AI_GATEWAY_API_KEY, CRON_SECRET, KV, Blob
-vercel deploy
+vercel deploy --prod
 curl -s "$DEPLOY_URL/channel/mcp-radar/status" | jq .
 ```
 
-| Variable | Deploy |
-|----------|--------|
-| `AI_GATEWAY_API_KEY` | Required for agent synthesis |
-| `CRON_SECRET` | Required — Vercel Cron hits `/internal/cron/mcp-radar-scan` |
-| `KV_REST_API_URL` + `KV_REST_API_TOKEN` | Durable seen-items + last-run state |
-| `BLOB_READ_WRITE_TOKEN` | Durable proof markdown log |
-| `TAVILY_API_TOKEN` | Optional corroboration |
+| Concern | On Vercel |
+|---------|-----------|
+| AI Gateway | OIDC via linked project — no API key |
+| Proof log + dedupe state | `@vercel/blob` only (markdown + JSON objects) |
+| Cron | Platform `x-vercel-cron` — no `CRON_SECRET` required |
+| Local dev | `vercel env pull .env.local` + optional `AI_GATEWAY_API_KEY` |
+
+`vercel blob create-store` wires Blob to the project; runtime auth is OIDC (same model as [eve content agent](https://github.com/vercel-labs/eve-content-agent-template)).
 
 On Vercel, `POST /channel/mcp-radar/run` returns `202` and continues in the background via `waitUntil`. Locally it runs synchronously for smoke tests.
 
@@ -59,7 +60,7 @@ cp .env.example .env.local
 
 | Variable | Required | Role |
 |----------|----------|------|
-| `AI_GATEWAY_API_KEY` | Yes (live runs) | Agent model turns |
+| `AI_GATEWAY_API_KEY` | Local only | Agent model turns off-Vercel |
 | `TAVILY_API_TOKEN` | Optional | Tavily corroboration; HN-only when unset |
 
 Build CGS stubs (symlinked catalogs):
@@ -82,7 +83,7 @@ Slash commands in the interactive TUI: `/info`, `/catalogs`, `/new`, `/quit`.
 
 ## Channel API
 
-Start headless dev server (`npm run dev:headless`), then:
+Start headless dev server (`npm run dev`), then:
 
 ```bash
 BASE=http://127.0.0.1:3000
@@ -102,16 +103,18 @@ curl -s -X POST "$BASE/channel/mcp-radar/run" -H 'content-type: application/json
 
 Proof artifact (local fs): [`agent/research/mcp-innovations-proof.md`](./agent/research/mcp-innovations-proof.md)
 
-Dedupe state (local fs): `agent/.plasm/research/seen-hn-items.json` (gitignored). On Vercel deploy, proof + dedupe use Blob + KV when env vars are set.
+Dedupe state (local fs): `agent/.plasm/research/seen-hn-items.json` (gitignored). On Vercel, proof + dedupe + last-run use Blob paths under `research/`.
 
 ## Schedule
 
-`agent/schedules/mcp-radar-scan.ts` runs every **6 hours** (`0 */6 * * *`). Vercel Cron calls `/internal/cron/mcp-radar-scan` with `Authorization: Bearer $CRON_SECRET`.
+`agent/schedules/mcp-radar-scan.ts` runs every **6 hours** (`0 */6 * * *`) as a **Nitro scheduled task** (Vercel Cron auto-wired at deploy). Durable execution uses **Vercel Workflows** (`workflow/api` `start()`).
+
+Manual dev trigger: `POST /internal/schedule/mcp-radar-scan`
 
 ## Evals
 
 ```bash
-npm run eval    # requires AI_GATEWAY_API_KEY
+npm run eval    # requires AI_GATEWAY_API_KEY locally
 ```
 
 Live eval: `evals/mcp-radar-discover.eval.ts`