@plasm_lang/vercel-agent 0.3.82 → 0.3.85

package/src/package-version.ts

@@ -1,14 +1,6 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
+import plasmAgentPackage from "../package.json" with { type: "json" };
 
-let cachedVersion: string | undefined;
-
-/** Published semver from @plasm_lang/vercel-agent package.json. */
+/** Published semver from @plasm_lang/vercel-agent package.json (inlined when Nitro bundles). */
 export function frameworkPackageVersion(): string {
-  if (cachedVersion) return cachedVersion;
-  const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-  const raw = readFileSync(path.join(packageRoot, "package.json"), "utf8");
-  cachedVersion = (JSON.parse(raw) as { version: string }).version;
-  return cachedVersion;
+  return plasmAgentPackage.version;
 }

package/src/runtime/agent-runtime.ts

@@ -21,6 +21,7 @@ import { createArchiveStore } from "../archive/resolve-backend.js";
 import type { ProdArchiveStore } from "../archive/prod-archive-store.js";
 import { computeRunId } from "../archive/run-id.js";
 import { activeTraceId, plasmSpans } from "../telemetry/plasm-spans.js";
+import { PlasmSpanAttributes } from "../instrumentation.js";
 import type { AuthoringContext } from "../authoring/context.js";
 import type { HookRunner } from "../authoring/hook-runner.js";
 import type { AgentWorkflowWorldDefinition } from "../define-agent.js";
@@ -61,7 +62,7 @@ export interface PlasmPlanInput {
 
 export interface PlasmRunInput {
   logicalSessionRef: string;
-  planCommitRef: string;
+  runRef: string;
   reasoning?: string;
 }
 
@@ -283,7 +284,7 @@ export class AgentRuntime {
         });
         await this.sessionManager.update(session);
 
-        span.setAttribute("plasm.plan_commit_ref", dry.planCommitRef);
+        span.setAttribute(PlasmSpanAttributes.RUN_REF, dry.planCommitRef);
         if (catalogCgsHash) {
           span.setAttribute("plasm.catalog_cgs_hash", catalogCgsHash);
         }
@@ -310,7 +311,7 @@ export class AgentRuntime {
         });
 
         await this.emitHook("plan:commit", {
-          planCommitRef: dry.planCommitRef,
+          runRef: dry.planCommitRef,
           program: input.program,
           logicalSessionRef: session.logicalSessionRef,
         });
@@ -325,14 +326,14 @@ export class AgentRuntime {
     void input.reasoning;
     const entryId = session.seeds[0]?.api;
     const catalogCgsHash = entryId ? this.catalogHashForEntry(entryId) : undefined;
-    const planCommit = session.planCommits.find((pc) => pc.ref === input.planCommitRef);
+    const planCommit = session.planCommits.find((pc) => pc.ref === input.runRef);
 
     return plasmSpans.liveRun(
       {
         intent: session.intent,
         logicalSessionRef: session.logicalSessionRef,
         sessionId: session.logicalSessionId,
-        planCommitRef: input.planCommitRef,
+        runRef: input.runRef,
         entryId,
         catalogCgsHash,
       },
@@ -340,8 +341,8 @@ export class AgentRuntime {
         const started = Date.now();
         const result =
           this.hostTransport && typeof this.engine.runPlanLive === "function"
-            ? await this.engine.runPlanLive(input.planCommitRef, this.hostTransport)
-            : await this.engine.runPlan(input.planCommitRef);
+            ? await this.engine.runPlanLive(input.runRef, this.hostTransport)
+            : await this.engine.runPlan(input.runRef);
         const program = planCommit?.program ?? "";
         const runMeta = parseRunMeta(result.metaJson);
         const requestFingerprints = collectRequestFingerprints(runMeta);
@@ -349,7 +350,7 @@ export class AgentRuntime {
           catalogCgsHash && program
             ? computeRunId({
                 catalogCgsHash,
-                planCommitRef: input.planCommitRef,
+                planCommitRef: input.runRef,
                 program,
                 entryId,
                 requestFingerprints,
@@ -357,7 +358,7 @@ export class AgentRuntime {
             : `pr${createHash("sha256").update(randomUUID()).digest("hex")}`;
 
         span.setAttribute("plasm.run_id", runId);
-        span.setAttribute("plasm.plan_commit_ref", input.planCommitRef);
+        span.setAttribute(PlasmSpanAttributes.RUN_REF, input.runRef);
         if (catalogCgsHash) {
           span.setAttribute("plasm.catalog_cgs_hash", catalogCgsHash);
         }
@@ -365,7 +366,7 @@ export class AgentRuntime {
         if (this.archive) {
           await this.archive.writeRunSnapshot({
             run_id: runId,
-            plan_commit_ref: input.planCommitRef,
+            plan_commit_ref: input.runRef,
             catalog_cgs_hash: catalogCgsHash ?? "unknown",
             entry_id: entryId,
             logical_session_ref: session.logicalSessionRef,
@@ -386,7 +387,7 @@ export class AgentRuntime {
         await this.recordToolTrace("plasm", "plasm.live_run", started, {
           intent: session.intent,
           logical_session_ref: session.logicalSessionRef,
-          plan_commit_ref: input.planCommitRef,
+          plan_commit_ref: input.runRef,
           run_id: runId,
           catalog_cgs_hash: catalogCgsHash,
           ok: result.ok,
@@ -394,7 +395,7 @@ export class AgentRuntime {
         });
 
         await this.emitHook("run:complete", {
-          planCommitRef: input.planCommitRef,
+          runRef: input.runRef,
           runId,
           ok: result.ok,
           logicalSessionRef: session.logicalSessionRef,

package/src/runtime/compaction.ts

@@ -66,7 +66,7 @@ export async function maybeCompactMessages(
   const summary = await generateText({
     model: summaryModel,
     system:
-      "Summarize the prior agent conversation for continuation. Preserve goals, catalog picks, logical_session_ref, plan_commit_ref, and unresolved tasks. Be concise.",
+      "Summarize the prior agent conversation for continuation. Preserve goals, catalog picks, logical_session_ref, run_ref, and unresolved tasks. Be concise.",
     prompt: transcript,
     temperature: 0,
   });

package/src/server/plasm-handler.ts

@@ -6,6 +6,7 @@ import {
   createAgentFromDefinition,
   resolveAgentDefinition,
 } from "../define-agent.js";
+import { readBuildManifest } from "../cli/build.js";
 import { createAuthoringContext, type AuthoringContext } from "../authoring/context.js";
 import { tryHandleChannelRoute } from "../authoring/channel-dispatch.js";
 import {
@@ -75,9 +76,24 @@ export function normalizePlasmPathname(url: string | undefined): string {
   return pathname;
 }
 
+/** Resolve request path on Vercel (rewrite-to-/api preserves public path in req.url). */
+function vercelIncomingUrl(req: IncomingMessage): string {
+  for (const key of [
+    "x-vercel-original-url",
+    "x-middleware-request-url",
+    "x-forwarded-uri",
+  ] as const) {
+    const raw = req.headers[key];
+    if (typeof raw === "string" && raw.length > 0) {
+      return raw.startsWith("/") ? raw : new URL(raw, "http://localhost").pathname;
+    }
+  }
+  return req.url ?? "/";
+}
+
 export function rewriteRequestPath(req: IncomingMessage): IncomingMessage {
-  const pathname = normalizePlasmPathname(req.url);
-  const original = req.url ?? "/";
+  const original = vercelIncomingUrl(req);
+  const pathname = normalizePlasmPathname(original);
   const query = original.includes("?") ? original.slice(original.indexOf("?")) : "";
   const proxy = Object.create(req) as IncomingMessage;
   Object.defineProperty(proxy, "url", {
@@ -235,9 +251,13 @@ export async function createPlasmApp(options: PlasmAppOptions): Promise<PlasmApp
 
   const refreshSlots = async (): Promise<LoadedProjectSlots> => {
     const currentDiscovery = discovery ?? (await refreshDiscovery());
+    const buildManifest = await readBuildManifest(agentRoot);
     loadedSlots = await loadAuthoredSlots({
       discovery: currentDiscovery,
       importCacheBust,
+      agentRoot,
+      projectRoot,
+      compiledSlots: buildManifest?.compiledSlots,
     });
     return loadedSlots;
   };

package/src/telemetry/plasm-spans.ts

@@ -8,7 +8,7 @@ export interface PlasmSpanContext {
   logicalSessionRef?: string;
   catalogCgsHash?: string;
   entryId?: string;
-  planCommitRef?: string;
+  runRef?: string;
   runId?: string;
   toolName?: string;
   transportHost?: string;
@@ -26,8 +26,8 @@ function applyPlasmAttributes(span: Span, ctx: PlasmSpanContext): void {
   if (ctx.catalogCgsHash) {
     span.setAttribute(PlasmSpanAttributes.CATALOG_CGS_HASH, ctx.catalogCgsHash);
   }
-  if (ctx.planCommitRef) {
-    span.setAttribute(PlasmSpanAttributes.PLAN_COMMIT_REF, ctx.planCommitRef);
+  if (ctx.runRef) {
+    span.setAttribute(PlasmSpanAttributes.RUN_REF, ctx.runRef);
   }
   if (ctx.runId) span.setAttribute(PlasmSpanAttributes.RUN_ID, ctx.runId);
   if (ctx.entryId) span.setAttribute(PlasmSpanAttributes.ENTRY_ID, ctx.entryId);

package/src/tools/descriptions.ts

@@ -17,7 +17,7 @@ Returns **\`logical_session_ref\`** + fenced teaching TSV. TSV is the active sym
 
 **\`_meta.plasm\`:** \`logical_session_ref\`, \`continuity\`, \`domain_revision\`, optional **\`relations\`**.`;
 
-export const PLASM_TOOL_DESCRIPTION = `**Plan Plasm** (dry-run): **\`logical_session_ref\`** + **\`program\`**. Returns reviewable plan topology and executable **\`plan_commit_ref\`** (\`pcN\`). Pass that token to **\`plasm_run\`**; do **not** echo the program.
+export const PLASM_TOOL_DESCRIPTION = `**Plan Plasm** (dry-run): **\`logical_session_ref\`** + **\`program\`**. Returns reviewable plan topology and executable **\`run_ref\`** (\`pcN\`). Pass that token to **\`plasm_run\`**; do **not** echo the program.
 
 **\`program\` is Plasm source text, not JSON data.** Write one raw expression (e.g. \`e3(p15="electric").r2[p4,p5]\`) or multiline bindings with final roots. If a plan merely echoes an object/array/string literal, that is a literal no-op; rewrite as Plasm source.
 
@@ -29,66 +29,53 @@ Output:
 
 TSV table semantics:
 - Header: \`plasm_expr<TAB>Meaning\`; one tab per row. Left = syntax/metadata; right = guidance only (never copy \`Meaning\`).
-- Executable rows start with \`e#\`/Entity; metadata-only \`p#\`/\`v#\` rows are never roots.
+- Executable rows start with \`e#\`; metadata-only \`p#\`/\`r#\`/\`v#\` rows are never roots.
 
 Symbol and fill rules:
 - \`e#\` entity; \`m#\` method; \`p#\` field/param/filter; \`r#\` relation nav; \`v#\` value-domain metadata only.
-- Relation hops: \`.wire\` or \`.r#\` on row producers — never bare \`p#\` after \`.\` (\`p#\` in \`e#{…}\` is filter/param).
+- Relation hops: \`.r#\` (or the relation wire) on row producers — never a bare filter \`p#\` after \`.\` (\`p#\` in \`e#{…}\` is filter/param).
 - Never write \`v#\` in code; use \`p#\` keys and read \`v#\` rows for allowed values.
-- \`e#(p#)\` identity rows: substitute real wire ids for \`<id>\`, \`<value>\`, \`<receiver>\`, \`elem\`.
-- Remove \`..\` ellipses or replace with real \`p#=\` assignments before output.
-- Optional keys (\`opt:\` in \`Meaning\`): add only as keyed assignments with real values.
-- Projection rows ending \`[p#,…]\` teach a valid field set. Reuse that suffix only on another expression returning the same entity or list type.
+- **Session handles** (\`logical_session_ref\`, \`run_ref\` / \`pcN\`): MCP tokens only — copy verbatim; not program syntax.
+- Replace teaching placeholders (\`$\`, \`<id>\`, \`<val>\`) and exemplar ids (\`pikachu\`, \`example-name\`, …) with real values before output. Never emit \`$\` from a teaching row.
+- Get-head: **parens = identity** (\`e_type(electric)\`; bare word = string identity when the slot is a name/string field), **braces = query/filter** (\`e#{p#=…}\`). Keyed \`e#(p#=<id>)\` only when that \`p#\` is the identity field.
+- **Quote scalars only in \`{…}\` predicates** (\`e#{p#="EVA"}\`); identity ids in \`e#(…)\` need no quotes. EntityRef slots use \`e#(id)\`, not bare scalars.
+- Remove \`..\` ellipses; add \`opt:\` keys (from \`Meaning\`) only as keyed assignments with real values.
+- Projection \`[p#,…]\` suffixes: reuse only on expressions returning the same entity/list type.
 
 Core surface:
 - Program shape: one \`plasm_expr\`, or \`label = …\` bindings then comma-separated final roots (no \`return\`).
-- Postfix on row producers: \`.limit(N)\` | \`.page_size(N)\` | \`.sort(p#, desc)\` / \`.sort(p#,dir)\` | \`.filter{…}\` | \`.filter(…)\` | \`.aggregate(specs)\` | \`.group_by(p#)\` then \`.aggregate(specs)\` | \`.group_by(p#, specs)\` (comma sugar) | \`.dedupe(p#[, …])\` | \`.distinct(p#[, …])\` | \`.distinct()\` | \`.singleton()\` | \`[p#,…]\`. Row postfix fields use teaching \`rows:\` \`p#\` symbols; wire field names are sugar.
-- Large list reads return the first **25 rows** in \`plasm_run\`; continue with \`page(l_<token>_pgN)\` from the tool result — not \`resources/read\`.
-- Run gate: pass \`pcN\` from a prior dry-run to \`plasm_run\`; MCP \`plasm_run\` does not accept program continuations.
-- Copy teaching TSV left cells; substitute placeholders; compose via bindings.
-- Search when exposed: \`e#~$\` or \`e#~"text"\` (bare \`e#~\` is invalid); optional scoped filters \`e#~"text"[{p#=…}]\`.
-- Field projection suffix: \`[p#,…]\`.
+- Postfix/\`[p#]\`/\`[fields]\`: copy exact forms from the TSV left column (\`.limit\` \`.sort\` \`.filter{…}\` \`.group_by\` \`.aggregate\` …).
+- Large list reads return the first **25 rows** in \`plasm_run\`; further pages copy the handle from the prior result's "more pages" line into **\`run_ref\`** on the next **\`plasm_run\`** (no second **\`plasm\`** call).
+- \`page(...)\` is HTTP-execute program syntax only — not an MCP tool argument or \`plasm\` program.
+- Search when exposed: \`e#~$\` or \`e#~"text"\` (bare \`e#~\` is a parse error); optional scoped filters \`e#~"text"[{p#=…}]\`.
 
 Composition rules:
 - One binding per line; final roots last (preferred). Single-line bindings coerced; default return is first binding.
-- Postfix/\`[fields]\` chain on any row-producing binding or expression.
-- Row text: \`label = source <<TAG\` … \`TAG\` (equals required — never \`label source <<TAG\`); optional column list: \`label = source[p#,…] <<TAG\`. Minijinja \`rows\` = that source's projected rows only — not \`\${}\`.
-- Pass \`binding.content\` to string params; compose with \`\${report.content}\` in later heredocs/strings (never bare \`\${}\` in prose; \`$$\` escapes \`$\`).
-- Minijinja \`{{ }}\` / \`{% %}\` only inside row-to-text heredoc bodies — not in capability heredocs that use \`\${binding.path}\`.
-- Do not use \`report.content\` as a final root or relation receiver.
+- Row text: \`label = source <<TAG\` … \`TAG\` (equals required); optional \`label = source[p#,…] <<TAG\`. Minijinja \`{{ }}\` / \`{% %}\` over \`rows\` only inside the heredoc body — not \`\${}\`.
+- Pass \`binding.content\` to string params; compose with \`\${report.content}\` in later heredocs/strings (\`$$\` escapes \`$\`). Do not use \`report.content\` as a final root or relation receiver.
 - Action/create roots: return the action row or follow with \`e#(p#=…)\` get — not \`created.p#\` as a program root.
-- Relation embed fan-out (\`Type.pokemon\` / \`.r#\`): prefer explicit Gets until embed path is warm; \`.limit\` on relation hops may need hydrate when graph targets are missing.
-- Heredoc: \`<<TAG\` + newline; first trimmed \`TAG\` line closes; pick a tag absent from the body.
-- Examples: array argument \`p#=[e#(<id>), …]\`. Quoted strings use only \`\\"\` and \`\\\\\` escapes.
-- Worked row-compute program (shape only — substitute \`e#\` / \`p#\` from your table below):
+- Heredoc: \`<<TAG\` + newline; first trimmed \`TAG\` line closes; pick a tag absent from the body. \`markdown\`/\`html\`/\`document\`/\`json_text\`/\`blob\` values use \`<<TAG\` … \`TAG\` only.
+- Worked shape (substitute symbols from your TSV):
 items = e_source
-filtered = items.filter{p_field>=300}  # prefer bind; bare \`e_source.filter{…}\` list-alls first
-sorted = filtered.sort(p_field, desc)
-limited = sorted.limit(10)
-limited[p_a,p_field]
-- Worked federated relation + row compute (shape only — copy \`e#\` / \`.r#\` from your table's left column):
-parent = e2(p_key=<val>)
-children = parent.rN
-limited = children.limit(5)
-limited[p_a,p_b]
-- \`markdown\`/\`html\`/\`document\`/\`json_text\`/\`blob\` values (per \`Meaning\`): \`<<TAG\` … \`TAG\` only; e.g. \`e2.mN(..., p#=<<TXT\` + newline body + \`TXT\` newline \`)\`.
+filtered = items.filter{p_field>=300}
+sorted = filtered.sort(p_field, desc).limit(10)
+sorted[p_a,p_field]
 
 Common pitfalls:
-- \`[fields]\`/\`.group_by\`/\`.sort\`/\`.dedupe\`/row \`.filter\` use \`rows:\` fields only — not \`inputs:\`/\`opt:\` filter keys.
-- \`e#{…}\` filters at HTTP; \`binding.filter{…}\` filters materialized rows. Prefer \`label = e#\` then filter; bare \`e#.filter{…}\` list-alls first.
-- Primary group/agg: \`group_by(p_key).aggregate(n=count)\`; bare \`group_by(p_key)\` ≡ \`group_by(p_key, count=count)\`; multi-key comma sugar: \`group_by(k1, k2, n=count)\`.
-- \`=>\` only for derive \`{ k: _.field }\` or \`for_each\` updates — not relation reads (\`labels = issues.r#\`).
-- Homograph: relation fanout via \`.r#\`/wire; \`labels = issues.p#\` forgiven when binding name matches.
-- Never emit \`$\` from teaching rows; substitute real ids and \`e#~"text"\` search terms.
+- Prefer \`label = e#\` then \`label.filter{…}\`; bare \`e#.filter{…}\` list-alls first. Row \`.filter{…}\` needs a materialized list.
+- \`=>\` only for derive \`{ k: _.field }\` or write effects (\`source => e#.m#(…)\`) — not relation reads (use \`child = source.r#\`).
+- Federated writes: one created-row return; discover anchors live — never hardcode workspace ids.
+- **Symbols only:** use this session's \`e#\` / \`m#\` / \`r#\` / \`p#\` from the teaching TSV — not catalog type names, method verbs, or API labels. Unambiguous single-catalog wire names may parse, but always prefer taught \`e#\`/\`m#\`.
 - Search operand: \`e#~$\` or \`e#~"text"\` required — bare \`e#~\` is a parse error.
 - Federated sessions: when the same wire entity/method/relation/field name appears in multiple catalogs, bare wire tokens are compile errors — copy the session \`e#\` / \`m#\` / \`r#\` / \`p#\` from the teaching row for that catalog. Never write \`entry_id:Entity\` or \`catalog.Entity\` in programs.
-- Cross-catalog stitch (shape only — substitute symbols from your TSV): pokeapi \`Type\` get → row-to-text bindings → proof \`ShareLink\` document param with \`\${binding.content}\` inside \`<<TAG\` … \`TAG\`.
 - Search-only entities (no query): no \`e#{}\` list-all — scoped \`e#{p#=…}\` and/or \`e#~"text"\`.`;
 
-export const PLASM_RUN_TOOL_DESCRIPTION = `**Run Plasm** (live): **\`logical_session_ref\`** + **\`plan_commit_ref\`** (\`pcN\`) from a prior **\`plasm\`** dry-run. Real HTTP/API; may return **\`resource_link\`** / \`_meta.plasm\` snapshots.
+export const PLASM_RUN_TOOL_DESCRIPTION = `**Run Plasm** (live): **\`logical_session_ref\`** + **\`run_ref\`** — a \`pcN\` plan commit from **\`plasm\`**, or the page handle from a prior result's "more pages" line. Real HTTP/API; may return **\`resource_link\`** snapshots.
 
-**Review gate:** \`plasm_run\` executes exactly the reviewed plan stored under the **\`plan_commit_ref\`**. If the token is missing, expired, or from another plan, call **\`plasm\`** again.
+**Review gate:** first live run executes the reviewed plan for the \`pcN\` **\`run_ref\`** from **\`plasm\`**. If the token is missing, expired, or from another plan, call **\`plasm\`** again.
+
+**Paging:** when a result says \`more pages — call plasm_run with run_ref: "…"\`, copy that handle into **\`run_ref\`** on the next **\`plasm_run\`** (same **\`logical_session_ref\`**; no second **\`plasm\`** call). \`page(...)\` is HTTP-execute program syntax only — not an MCP tool argument.
 
 **Live execute:** server spawns one async operation and awaits terminal rows in the tool response. Progress uses standard \`notifications/plasm/op\` on the registered handle.
 
-**Live results:** \`## {return_label} ({n} rows)\` + capped TSV (25 rows inline); multi-return programs use \`# Results\` with \`### {label} ({n} rows)\` per root. When more rows exist, continue with \`page(l_<token>_pgN)\` from the tool result or \`_meta.plasm.paging\`. Snapshot URI lines point at full JSON via MCP **\`resources/read\`** when needed. Run Explorer is supplemental.`;
+**Live results:** \`## {return_label} ({n} rows)\` + capped TSV (25 rows inline); multi-return programs use \`# Results\` with \`### {label} ({n} rows)\` per root. ≤25 rows → inline \` \`\`tsv \`\`; 26–499 → capped TSV + snapshot URI (\`resources/read\` when the host supports it); 500+ → preview + snapshot, no inline TSV — narrow the program or page.`;

package/src/tools/format.ts

@@ -13,8 +13,8 @@ export function formatPlasmContextMarkdown(
   return `\`${logicalSessionRef}\`\n\n\`\`\`tsv\n${delta}\n\`\`\`\n`;
 }
 
-export function formatPlasmDryRunMarkdown(summary: string, planCommitRef: string): string {
-  return `\`\`\`text\n${summary.trim()}\n\`\`\`\n\n**Run:** pass \`plan_commit_ref\`: \`${planCommitRef}\` to **\`plasm_run\`**. Do not echo the program.`;
+export function formatPlasmDryRunMarkdown(summary: string, runRef: string): string {
+  return `\`\`\`text\n${summary.trim()}\n\`\`\`\n\n**Run:** pass \`run_ref\`: \`${runRef}\` to **\`plasm_run\`**. Do not echo the program.`;
 }
 
 export function formatPlasmRunMarkdown(

package/src/tools/plasm-tools.ts

@@ -62,9 +62,9 @@ const plasmRunInputSchema = z.object({
   logical_session_ref: z
     .string()
     .describe("Same logical_session_ref returned by plasm_context"),
-  plan_commit_ref: z
+  run_ref: z
     .string()
-    .describe("Executable plan token (pcN) from a prior plasm dry-run"),
+    .describe("pcN from plasm dry-run, or page handle from a prior plasm_run more-pages line"),
   reasoning: z
     .string()
     .optional()
@@ -100,10 +100,10 @@ export function createPlasmTools(runtime: AgentRuntime): ToolSet {
     plasm_run: tool({
       description: PLASM_RUN_TOOL_DESCRIPTION,
       inputSchema: toolInput(plasmRunInputSchema),
-      execute: async ({ logical_session_ref, plan_commit_ref, reasoning }) =>
+      execute: async ({ logical_session_ref, run_ref, reasoning }) =>
         runtime.plasmRun({
           logicalSessionRef: logical_session_ref,
-          planCommitRef: plan_commit_ref,
+          runRef: run_ref,
           reasoning,
         }),
     }),

package/src/workflow/world-bootstrap.ts

@@ -19,7 +19,9 @@ export function resolveWorkflowWorldType(
 
 /**
  * Bootstrap Workflow SDK world from agent definition.
- * - `vercel`: platform-managed world on deploy (no-op here)
+ * - `vercel`: Vercel World is selected automatically by the Workflow SDK when
+ *   `VERCEL_DEPLOYMENT_ID` is set; durable session routes require `/.well-known/workflow/`
+ *   (eve emits these via Nitro + @workflow/nitro when sources contain `use workflow` / `use step`).
  * - `postgres`: `@workflow/world-postgres` long-lived worker
  * - `local`: `@workflow/world-local` for dev
  */
@@ -28,6 +30,15 @@ export async function bootstrapWorkflowWorld(
 ): Promise<WorkflowWorldType> {
   const worldType = resolveWorkflowWorldType(definition);
   if (worldType === "vercel") {
+    if (process.env.VERCEL_DEPLOYMENT_ID?.trim()) {
+      try {
+        const { getWorld } = await import("workflow/runtime");
+        await getWorld().start?.();
+      } catch (err) {
+        if (process.env.PLASM_WORKFLOW_STRICT === "1") throw err;
+        console.warn("[plasm:workflow] vercel world start skipped:", err);
+      }
+    }
     return worldType;
   }
 

package/templates/mcp-radar/agent/instrumentation.ts

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { registerOTel } from "@vercel/otel";
+import { OpenTelemetry } from "@ai-sdk/otel";
+import { registerTelemetryIntegration } from "ai";
+
+const agentRoot = path.dirname(fileURLToPath(import.meta.url));
+const serviceName =
+  process.env.PLASM_AGENT_NAME?.trim() || path.basename(path.dirname(agentRoot));
+
+/** Eve-shaped OTEL bootstrap — optional export to Braintrust/Datadog via registerOTel. */
+export function register(): void {
+  registerOTel({ serviceName });
+  registerTelemetryIntegration(new OpenTelemetry());
+}
+
+register();

package/templates/mcp-radar/lib/proof-store.ts

@@ -257,9 +257,16 @@ export function tavilyConfigured(): boolean {
 }
 
 export function gatewayConfigured(): boolean {
-  return Boolean(
+  if (
     process.env.AI_GATEWAY_API_KEY?.trim() ||
-      process.env.AI_API_GATEWAY_KEY?.trim() ||
-      process.env.AI_GATEWAY_KEY?.trim(),
+    process.env.AI_API_GATEWAY_KEY?.trim() ||
+    process.env.AI_GATEWAY_KEY?.trim()
+  ) {
+    return true;
+  }
+  return (
+    process.env.VERCEL === "1" ||
+    Boolean(process.env.VERCEL_DEPLOYMENT_ID?.trim()) ||
+    Boolean(process.env.VERCEL_ENV?.trim())
   );
 }

package/templates/mcp-radar/vercel.json

@@ -1,15 +1,4 @@
 {
-  "buildCommand": "npx tsx scripts/vercel-build.ts",
-  "rewrites": [{ "source": "/(.*)", "destination": "/api/$1" }],
-  "crons": [
-    {
-      "path": "/internal/cron/mcp-radar-scan",
-      "schedule": "0 */6 * * *"
-    }
-  ],
-  "functions": {
-    "api/**": {
-      "maxDuration": 300
-    }
-  }
+  "installCommand": "npm ci --omit=dev",
+  "buildCommand": "plasm-agent build"
 }

package/templates/scaffold/agent/instrumentation.ts

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { registerOTel } from "@vercel/otel";
+import { OpenTelemetry } from "@ai-sdk/otel";
+import { registerTelemetryIntegration } from "ai";
+
+const agentRoot = path.dirname(fileURLToPath(import.meta.url));
+const serviceName =
+  process.env.PLASM_AGENT_NAME?.trim() || path.basename(path.dirname(agentRoot));
+
+/** Eve-shaped OTEL bootstrap — optional export to Braintrust/Datadog via registerOTel. */
+export function register(): void {
+  registerOTel({ serviceName });
+  registerTelemetryIntegration(new OpenTelemetry());
+}
+
+register();

package/templates/scaffold/vercel.default.json

@@ -1,4 +1,4 @@
 {
-  "buildCommand": "plasm-agent build",
-  "rewrites": [{ "source": "/(.*)", "destination": "/api/$1" }]
+  "installCommand": "npm ci --omit=dev",
+  "buildCommand": "plasm-agent build"
 }

package/templates/scaffold/vercel.mcp-radar.json

@@ -1,15 +1,4 @@
 {
-  "buildCommand": "plasm-agent build",
-  "rewrites": [{ "source": "/(.*)", "destination": "/api/$1" }],
-  "crons": [
-    {
-      "path": "/internal/cron/mcp-radar-scan",
-      "schedule": "0 */6 * * *"
-    }
-  ],
-  "functions": {
-    "api/**": {
-      "maxDuration": 300
-    }
-  }
+  "installCommand": "npm ci --omit=dev",
+  "buildCommand": "plasm-agent build"
 }

package/templates/mcp-radar/api/[[...path]].ts

@@ -1,23 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import agentDefinition from "../agent/agent.js";
-import { createPlasmApp, vercelPlasmHandler } from "@plasm_lang/vercel-agent";
-
-const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const agentRoot = path.join(packageRoot, "agent");
-
-let app: Awaited<ReturnType<typeof createPlasmApp>> | undefined;
-
-export default async function handler(
-  req: import("node:http").IncomingMessage,
-  res: import("node:http").ServerResponse,
-): Promise<void> {
-  app ??= await createPlasmApp({
-    agentRoot,
-    definition: agentDefinition,
-    mode: "prod",
-    sessions: false,
-  });
-  await vercelPlasmHandler(app)(req, res);
-}

package/templates/mcp-radar/nitro.config.ts

@@ -1,17 +0,0 @@
-import { defineNitroConfig } from "nitropack/config";
-
-export default defineNitroConfig({
-  compatibilityDate: "2026-06-26",
-  srcDir: ".",
-  ignore: ["api/**"],
-  devServer: {
-    port: Number(process.env.PORT ?? 3000),
-    host: process.env.HOST ?? "127.0.0.1",
-  },
-  typescript: {
-    strict: false,
-  },
-  externals: {
-    inline: ["@plasm_lang/engine"],
-  },
-});

package/templates/mcp-radar/routes/[...path].ts

@@ -1,29 +0,0 @@
-import path from "node:path";
-
-import { fromNodeMiddleware } from "h3";
-
-import agentDefinition from "../agent/agent.js";
-import { createPlasmApp, vercelPlasmHandler } from "@plasm_lang/vercel-agent";
-
-const agentRoot = path.join(process.cwd(), "agent");
-
-let appPromise: ReturnType<typeof createPlasmApp> | undefined;
-
-async function plasmApp() {
-  appPromise ??= createPlasmApp({
-    agentRoot,
-    definition: agentDefinition,
-    mode: "prod",
-    sessions: false,
-  });
-  return appPromise;
-}
-
-export default fromNodeMiddleware(async (req, res) => {
-  const app = await plasmApp();
-  await new Promise<void>((resolve, reject) => {
-    res.once("finish", () => resolve());
-    res.once("error", reject);
-    void vercelPlasmHandler(app)(req, res).catch(reject);
-  });
-});

package/templates/scaffold/api/[[...path]].ts

@@ -1,23 +0,0 @@
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-import agentDefinition from "../agent/agent.js";
-import { createPlasmApp, vercelPlasmHandler } from "@plasm_lang/vercel-agent/server";
-
-const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-const agentRoot = path.join(packageRoot, "agent");
-
-let app: Awaited<ReturnType<typeof createPlasmApp>> | undefined;
-
-export default async function handler(
-  req: import("node:http").IncomingMessage,
-  res: import("node:http").ServerResponse,
-): Promise<void> {
-  app ??= await createPlasmApp({
-    agentRoot,
-    definition: agentDefinition,
-    mode: "prod",
-    sessions: false,
-  });
-  await vercelPlasmHandler(app)(req, res);
-}

package/templates/scaffold/nitro.config.ts

@@ -1,17 +0,0 @@
-import { defineNitroConfig } from "nitropack/config";
-
-export default defineNitroConfig({
-  compatibilityDate: "2026-06-26",
-  srcDir: ".",
-  ignore: ["api/**"],
-  devServer: {
-    port: Number(process.env.PORT ?? 3000),
-    host: process.env.HOST ?? "127.0.0.1",
-  },
-  typescript: {
-    strict: false,
-  },
-  externals: {
-    inline: ["@plasm_lang/engine"],
-  },
-});

package/templates/scaffold/routes/[...path].ts

@@ -1,29 +0,0 @@
-import path from "node:path";
-
-import { fromNodeMiddleware } from "h3";
-
-import agentDefinition from "../agent/agent.js";
-import { createPlasmApp, vercelPlasmHandler } from "@plasm_lang/vercel-agent/server";
-
-const agentRoot = path.join(process.cwd(), "agent");
-
-let appPromise: ReturnType<typeof createPlasmApp> | undefined;
-
-async function plasmApp() {
-  appPromise ??= createPlasmApp({
-    agentRoot,
-    definition: agentDefinition,
-    mode: "prod",
-    sessions: false,
-  });
-  return appPromise;
-}
-
-export default fromNodeMiddleware(async (req, res) => {
-  const app = await plasmApp();
-  await new Promise<void>((resolve, reject) => {
-    res.once("finish", () => resolve());
-    res.once("error", reject);
-    void vercelPlasmHandler(app)(req, res).catch(reject);
-  });
-});