@plasm_lang/vercel-agent 0.3.112 → 0.3.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plasm_lang/vercel-agent",
-  "version": "0.3.112",
+  "version": "0.3.113",
   "description": "Catalog-native TypeScript agent framework (Plasm CGS/CML, Vercel AI SDK, Nitro-oriented)",
   "license": "GPL-3.0-or-later",
   "repository": {
@@ -57,21 +57,22 @@
     "smoke:bootstrap:npm": "node scripts/run-plasm-cli.mjs scripts/smoke-bootstrap-npm.ts",
     "smoke:vercel-build": "node scripts/run-plasm-cli.mjs scripts/smoke-vercel-build.ts",
     "smoke:vercel-handler": "node scripts/run-plasm-cli.mjs scripts/smoke-vercel-handler.ts",
+    "test:resolve-app-options": "node scripts/run-plasm-cli.mjs scripts/test-resolve-app-options.ts",
     "agent": "node scripts/run-plasm-cli.mjs scripts/run-agent.ts",
     "dev": "node scripts/run-plasm-cli.mjs scripts/dev-server.ts",
     "plasm:dev": "npm run dev"
   },
   "dependencies": {
-    "@ai-sdk/otel": "^1.0.3",
+    "@ai-sdk/otel": "1.0.14",
     "@opentelemetry/api": "^1.9.0",
-    "@plasm_lang/engine": "^0.3.112",
+    "@plasm_lang/engine": "^0.3.113",
     "@vercel/blob": "^0.27.3",
     "@vercel/connect": "^0.2.6",
     "@vercel/kv": "^3.0.0",
     "@vercel/otel": "^1.14.2",
     "@workflow/nitro": "^4.1.1",
     "@workflow/world-postgres": "^4.2.0",
-    "ai": "^6.0.0",
+    "ai": "7.0.14",
     "esbuild": "^0.25.12",
     "js-yaml": "^4.1.0",
     "nitro": "^3.0.260610-beta",

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

@@ -118,8 +118,9 @@ export class ProdArchiveStore {
     return this.local.listRuns(limit);
   }
 
-  async listArchives(limit?: number) {
-    return this.local.listArchives(limit);
+  async listArchives(limit = 50) {
+    const [plans, runs] = await Promise.all([this.listPlans(limit), this.listRuns(limit)]);
+    return { plans, runs, paths: this.local.paths };
   }
 }
 

package/src/instrumentation.ts

@@ -1,9 +1,8 @@
 import { LegacyOpenTelemetry } from "@ai-sdk/otel";
-import type { AttributeValue } from "@opentelemetry/api";
 import {
-  registerTelemetryIntegration,
-  type TelemetryIntegration,
-  type TelemetrySettings,
+  registerTelemetry,
+  type Telemetry,
+  type TelemetryOptions,
 } from "ai";
 
 /** OpenTelemetry attribute keys for Plasm agent spans (Section 9). */
@@ -22,13 +21,12 @@ export const PlasmSpanAttributes = {
 
 export interface AgentInstrumentationOptions {
   serviceName?: string;
-  tracer?: TelemetrySettings["tracer"];
 }
 
 let registered = false;
 
-function otelIntegration(options: AgentInstrumentationOptions): TelemetryIntegration {
-  return new LegacyOpenTelemetry({ tracer: options.tracer }) as unknown as TelemetryIntegration;
+function otelIntegration(_options: AgentInstrumentationOptions): Telemetry {
+  return new LegacyOpenTelemetry();
 }
 
 /** Register global AI SDK OTEL integration (eve-style auto-discovered instrumentation). */
@@ -36,7 +34,7 @@ export function registerAgentInstrumentation(
   options: AgentInstrumentationOptions = {},
 ): void {
   if (registered) return;
-  registerTelemetryIntegration(otelIntegration(options));
+  registerTelemetry(otelIntegration(options));
   registered = true;
   void options.serviceName;
 }
@@ -44,13 +42,10 @@ export function registerAgentInstrumentation(
 /** Per-call AI SDK telemetry settings with OpenTelemetry integration. */
 export function createAgentTelemetry(
   options: AgentInstrumentationOptions = {},
-): TelemetrySettings {
+): TelemetryOptions {
   registerAgentInstrumentation(options);
   return {
     isEnabled: true,
-    metadata: {
-      "service.name": options.serviceName ?? "plasm-agent",
-    } satisfies Record<string, AttributeValue>,
-    integrations: otelIntegration(options),
+    functionId: options.serviceName ?? "plasm-agent",
   };
 }

package/src/load-env.ts

@@ -14,6 +14,54 @@ export function defaultEnvFileCandidates(): string[] {
   ];
 }
 
+/** Load project env by walking ancestors; nearer files override, empty values are ignored. */
+export function loadProjectAgentEnv(projectRoot: string): string | undefined {
+  const files = [...projectEnvFileCandidates(projectRoot)].reverse();
+  let loaded: string | undefined;
+  const pending = new Map<string, string>();
+  for (const file of files) {
+    if (!existsSync(file)) continue;
+    const text = readFileSync(file, "utf8");
+    for (const line of text.split(/\r?\n/)) {
+      const parsed = parseEnvLine(line);
+      if (!parsed || !parsed.value.trim()) continue;
+      pending.set(parsed.key, parsed.value);
+    }
+    loaded = file;
+  }
+  for (const [key, value] of pending) {
+    if (process.env[key] === undefined) {
+      process.env[key] = value;
+    }
+  }
+  if (!process.env.AI_GATEWAY_API_KEY?.trim()) {
+    const alias =
+      process.env.AI_API_GATEWAY_KEY?.trim() ??
+      process.env.AI_GATEWAY_KEY?.trim();
+    if (alias) {
+      process.env.AI_GATEWAY_API_KEY = alias;
+    }
+  }
+  return loaded;
+}
+
+/** `.env` candidates for an agent project root and ancestor directories. */
+export function projectEnvFileCandidates(projectRoot: string): string[] {
+  const resolved = path.resolve(projectRoot);
+  const files = [
+    path.join(resolved, ".env.local"),
+    path.join(resolved, ".env"),
+  ];
+  let dir = resolved;
+  for (let depth = 0; depth < 8; depth++) {
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    files.push(path.join(parent, ".env"));
+    dir = parent;
+  }
+  return files;
+}
+
 function parseEnvLine(line: string): { key: string; value: string } | null {
   const trimmed = line.trim();
   if (!trimmed || trimmed.startsWith("#")) return null;
@@ -33,7 +81,7 @@ function parseEnvLine(line: string): { key: string; value: string } | null {
   return { key, value };
 }
 
-/** Load `.env` into `process.env` without overriding existing variables. */
+/** Load `.env` into `process.env` without overriding existing variables. Empty values are skipped. */
 export function loadAgentEnv(files: string[] = defaultEnvFileCandidates()): string | undefined {
   let loaded: string | undefined;
   for (const file of files) {
@@ -41,7 +89,7 @@ export function loadAgentEnv(files: string[] = defaultEnvFileCandidates()): stri
     const text = readFileSync(file, "utf8");
     for (const line of text.split(/\r?\n/)) {
       const parsed = parseEnvLine(line);
-      if (!parsed) continue;
+      if (!parsed || !parsed.value.trim()) continue;
       if (process.env[parsed.key] === undefined) {
         process.env[parsed.key] = parsed.value;
       }

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

@@ -17,7 +17,10 @@ import {
 import { createPlasmVercelOptions } from "./vercel-build-output-config.js";
 
 const SERVER_TRACE_DEPS = [
+  "@ai-sdk/gateway",
   "@ai-sdk/otel",
+  "@ai-sdk/provider",
+  "@ai-sdk/provider-utils",
   "@opentelemetry/api",
   "@plasm_lang/engine",
   "@plasm_lang/engine-linux-x64-gnu",
@@ -27,10 +30,12 @@ const SERVER_TRACE_DEPS = [
   "@plasm_lang/vercel-agent",
   "@vercel/functions",
   "@vercel/blob",
+  "@vercel/oidc",
   "@vercel/otel",
   "ai",
   "workflow",
   "workflow/api",
+  "zod",
 ];
 
 function resolveNitroPreset(dev: boolean): NitroConfig["preset"] {

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

@@ -39,6 +39,7 @@ export default async (event: NitroNodeEvent) => {
   const body = await readJson(req);
   const job = String(body.job ?? "");
   const force = body.force === true;
+  const reset = body.reset === true;
 
   if (job !== "mcp-radar-scan") {
     res.statusCode = 404;
@@ -54,7 +55,7 @@ export default async (event: NitroNodeEvent) => {
     sessions: false,
   });
   const { runRadar } = await import("../../../../../lib/run-radar.js");
-  const result = await runRadar(app.getAuthoringContext(), { force });
+  const result = await runRadar(app.getAuthoringContext(), { force, reset });
 
   res.statusCode = 200;
   res.setHeader("content-type", "application/json; charset=utf-8");

package/src/runtime/agent-runtime.ts

@@ -311,6 +311,8 @@ export class AgentRuntime {
         });
 
         await this.emitHook("plan:commit", {
+          intent: session.intent,
+          planCommitRef: dry.planCommitRef,
           runRef: dry.planCommitRef,
           program: input.program,
           logicalSessionRef: session.logicalSessionRef,
@@ -395,6 +397,8 @@ export class AgentRuntime {
         });
 
         await this.emitHook("run:complete", {
+          intent: session.intent,
+          planCommitRef: input.runRef,
           runRef: input.runRef,
           runId,
           ok: result.ok,

package/src/server/plasm-handler.ts

@@ -32,6 +32,7 @@ import { sendJson } from "../dev/http.js";
 import { tryHandleSessionRoutes } from "../dev/session-routes.js";
 import { nitroOperatorHandler } from "../operator/routes.js";
 import { renderOperatorShell } from "../operator/ui-shell.js";
+import { resolvePlasmAppOptions } from "./resolve-app-options.js";
 
 export type PlasmAppMode = "dev" | "prod";
 
@@ -51,6 +52,7 @@ export interface PlasmApp {
   projectRoot: string;
   definition: AgentDefinition;
   mode: PlasmAppMode;
+  tenantScope: string;
   sessionsEnabled: boolean;
   reload(): Promise<void>;
   getAgent(): Promise<PlasmAgent>;
@@ -191,6 +193,7 @@ export async function handlePlasmOperatorRequest(
 
   const operatorHandler = nitroOperatorHandler({
     agentRoot: app.agentRoot,
+    tenantScope: app.tenantScope,
     runtime: undefined,
   });
 
@@ -213,6 +216,7 @@ export async function createPlasmApp(options: PlasmAppOptions): Promise<PlasmApp
   const projectRoot = path.dirname(agentRoot);
   const mode = options.mode ?? "prod";
   const sessionsEnabled = options.sessions ?? mode === "dev";
+  const resolved = resolvePlasmAppOptions(agentRoot, options);
   const definition = resolveAgentDefinition(options.definition, agentRoot);
   const sessionStore = sessionsEnabled ? new DevSessionStore() : undefined;
 
@@ -235,9 +239,10 @@ export async function createPlasmApp(options: PlasmAppOptions): Promise<PlasmApp
   const bootstrap = async (): Promise<PlasmAgent> => {
     agent = await createAgentFromDefinition(definition, {
       agentRoot,
-      tenantScope: options.tenantScope,
-      maxSteps: options.maxSteps,
-      telemetry: options.telemetry,
+      tenantScope: resolved.tenantScope,
+      maxSteps: resolved.maxSteps,
+      telemetry: resolved.telemetry,
+      hostTransport: resolved.hostTransport,
       loadedSlots,
       subagentRegistry,
       getAuthoringContext,
@@ -268,9 +273,9 @@ export async function createPlasmApp(options: PlasmAppOptions): Promise<PlasmApp
     const loaded = await loadSubagents({
       discovery: currentDiscovery,
       parentSlots: loadedSlots,
-      tenantScope: options.tenantScope,
-      maxSteps: options.maxSteps,
-      telemetry: options.telemetry,
+      tenantScope: resolved.tenantScope,
+      maxSteps: resolved.maxSteps,
+      telemetry: resolved.telemetry,
       importCacheBust,
     });
     if (loadedSlots) {
@@ -317,6 +322,7 @@ export async function createPlasmApp(options: PlasmAppOptions): Promise<PlasmApp
     projectRoot,
     definition,
     mode,
+    tenantScope: resolved.tenantScope,
     sessionsEnabled,
     reload,
     getAgent,

package/src/server/resolve-app-options.ts

@@ -0,0 +1,33 @@
+import path from "node:path";
+
+import { createProductionHostTransport } from "../engine/create-host-transport.js";
+import { loadProjectAgentEnv } from "../load-env.js";
+import type { AgentRuntimeConfig } from "../runtime/agent-runtime.js";
+
+import type { PlasmAppOptions } from "./plasm-handler.js";
+
+export interface ResolvedPlasmAppOptions {
+  tenantScope: string;
+  maxSteps: number;
+  telemetry: boolean;
+  hostTransport: NonNullable<AgentRuntimeConfig["hostTransport"]>;
+}
+
+/** Load project `.env` files and merge runtime options for prod Nitro bootstrap. */
+export function resolvePlasmAppOptions(
+  agentRoot: string,
+  partial: PlasmAppOptions,
+): ResolvedPlasmAppOptions {
+  const projectRoot = path.dirname(path.resolve(agentRoot));
+  loadProjectAgentEnv(projectRoot);
+
+  const maxStepsRaw = partial.maxSteps ?? Number(process.env.PLASM_AGENT_MAX_STEPS ?? 24);
+  const maxSteps = Number.isFinite(maxStepsRaw) && maxStepsRaw > 0 ? maxStepsRaw : 24;
+
+  return {
+    tenantScope: partial.tenantScope ?? process.env.PLASM_TENANT_SCOPE?.trim() ?? "local",
+    maxSteps,
+    telemetry: partial.telemetry ?? process.env.PLASM_AGENT_TELEMETRY !== "0",
+    hostTransport: createProductionHostTransport(),
+  };
+}

package/src/stubs/plasm-value-emitter.ts

@@ -109,6 +109,27 @@ export function renderProgramStatements(
     }
     case "SearchFiltered": {
       const q = searchFieldName(cap) ?? "q";
+      if (binding.searchSurface === "named-dot" && binding.searchMethodSegment) {
+        const body = invokeBodyFields(cap, shape, entityIdField);
+        const allArgs = body.map((f) => ({
+          key: f.name,
+          valueExpr: `${inputVar}.${f.name}`,
+          kind: emissionKindForField(f, catalogValues),
+          optional: !f.required,
+        }));
+        const qField = body.find((f) => f.name === q);
+        if (!qField) {
+          allArgs.unshift({
+            key: q,
+            valueExpr: `${inputVar}.${q}`,
+            kind: "literal" as const,
+            optional: false,
+          });
+        }
+        const dottedCall = renderBuildDottedArgsCall(allArgs);
+        return `const args = ${dottedCall};
+  const program = \`${sym}.${binding.searchMethodSegment}(\${args})\`;`;
+      }
       const args = dottedArgsCodegen(cap, catalogValues, shape, entityIdField, inputVar);
       const dottedCall = renderBuildDottedArgsCall(args);
       return `const filterArgs = ${dottedCall};

package/src/stubs/stub-symbols.ts

@@ -4,6 +4,23 @@ import {
   type CapabilityInvokeShape,
 } from "./capability-invoke-shape.js";
 
+function capabilitySearchMethodSegment(cap: CapabilityIntrospectionJson): string {
+  const ent = cap.entity.toLowerCase();
+  const prefix = `${ent}_`;
+  const stripped = cap.name.startsWith(prefix) ? cap.name.slice(prefix.length) : cap.name;
+  return stripped.replaceAll("_", "-");
+}
+
+function primarySearchCapabilityName(
+  catalog: CatalogIntrospectionJson,
+  entity: string,
+): string | undefined {
+  const caps = catalog.capabilities
+    .filter((c) => c.entity === entity && c.kind.toLowerCase() === "search")
+    .sort((a, b) => a.name.localeCompare(b.name));
+  return caps[0]?.name;
+}
+
 export interface EntitySymbolBinding {
   entity: string;
   symbol: string;
@@ -15,6 +32,9 @@ export interface CapabilityBinding {
   methodSymbol?: string;
   methodWire: string;
   invokeShape: CapabilityInvokeShape;
+  /** Primary search uses `e#~text`; non-primary uses `e#.search-by-date(...)`. */
+  searchSurface?: "tilde" | "named-dot";
+  searchMethodSegment?: string;
 }
 
 /** Entities with capabilities, stable lexicographic order → `e1`…`eN`. */
@@ -73,12 +93,26 @@ export function assignCapabilityBindings(
     if (!entityBinding) continue;
     const entityCaps = capsByEntity.get(cap.entity) ?? [];
     const invokeShape = classifyInvokeShape(cap);
+    const primarySearch =
+      invokeShape === "SearchText" || invokeShape === "SearchFiltered"
+        ? primarySearchCapabilityName(catalog, cap.entity)
+        : undefined;
     out.set(cap.name, {
       capability: cap.name,
       entitySymbol: entityBinding.symbol,
       methodSymbol: methodSymbolForCapability(cap, entityCaps),
       methodWire: cap.invoke_wire_name,
       invokeShape,
+      searchSurface:
+        primarySearch != null
+          ? cap.name === primarySearch
+            ? "tilde"
+            : "named-dot"
+          : undefined,
+      searchMethodSegment:
+        primarySearch != null && cap.name !== primarySearch
+          ? capabilitySearchMethodSegment(cap)
+          : undefined,
     });
   }
   return out;

package/templates/mcp-radar/README.md

@@ -26,23 +26,27 @@ The canonical template source is this directory (`examples/mcp-radar-agent/`).
 
 ## Deploy to Vercel
 
-Eve-aligned production path: link Blob once, deploy — **no manual env vars on Vercel** for Gateway, Blob, or cron auth.
+Canonical stack: **AI SDK v7** (`ai@7.0.14`, `@ai-sdk/otel@1.0.14`) + **Workflow 4.5** + pinned `zod@4.3.6`. Use **pnpm** (lockfile committed).
 
 ```bash
 cd examples/mcp-radar-agent
 plasm-agent link
-node scripts/provision-vercel-storage.mjs   # vercel blob create-store → project OIDC
-plasm-agent build
-vercel deploy --prod
+node scripts/provision-vercel.mjs   # sync monorepo .env secrets + Blob store
+pnpm install
+pnpm run build                      # local Nitro output
+# Remote build on Vercel requires @plasm_lang/vercel-agent@0.3.114+ on npm
+VERCEL=1 pnpm run build && vercel deploy --prebuilt --prod   # monorepo prebuilt path
 curl -s "$DEPLOY_URL/channel/mcp-radar/status" | jq .
 ```
 
 | Concern | On Vercel |
 |---------|-----------|
 | AI Gateway | OIDC via linked project — no API key |
+| Tavily | `TAVILY_API_TOKEN` synced from monorepo `.env` via provision script |
+| Tenant scope | `PLASM_TENANT_SCOPE` (default `mcp-radar`) synced from `.env` |
 | 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` |
+| Local dev | monorepo `.env` loaded automatically; optional `AI_GATEWAY_API_KEY` off-Vercel |
 
 `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)).
 
@@ -61,7 +65,8 @@ cp .env.example .env.local
 | Variable | Required | Role |
 |----------|----------|------|
 | `AI_GATEWAY_API_KEY` | Local only | Agent model turns off-Vercel |
-| `TAVILY_API_TOKEN` | Optional | Tavily corroboration; HN-only when unset |
+| `TAVILY_API_TOKEN` | Recommended | Tavily corroboration; set in monorepo `.env`, synced to Vercel via `provision-vercel.mjs` |
+| `PLASM_TENANT_SCOPE` | Optional | Session/operator partition (default `mcp-radar`) |
 
 Build CGS stubs (symlinked catalogs):
 

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

@@ -3,7 +3,6 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { waitUntil } from "@vercel/functions";
 import { defineChannel } from "@plasm_lang/vercel-agent";
 
-import { readProofMarkdown } from "../../lib/proof-store.js";
 import { radarStatus } from "../../lib/run-radar.js";
 import { startMcpRadarRun } from "../../lib/start-mcp-radar.js";
 
@@ -41,8 +40,11 @@ export default defineChannel({
       method: "POST",
       path: "/channel/mcp-radar/run",
       handler: async (req, res, ctx) => {
-        const body = (await readJsonBody(req)) as { force?: boolean };
-        const options = { force: body.force === true };
+        const body = (await readJsonBody(req)) as { force?: boolean; reset?: boolean };
+        const options = {
+          force: body.force === true,
+          reset: body.reset === true,
+        };
 
         if (process.env.VERCEL === "1") {
           waitUntil(
@@ -58,20 +60,25 @@ export default defineChannel({
         sendJson(res, 200, { accepted: true, workflow: true, run });
       },
     },
+    {
+      method: "POST",
+      path: "/channel/mcp-radar/reset",
+      handler: async (_req, res, _ctx) => {
+        sendJson(res, 200, {
+          ok: true,
+          message: 'Trigger POST /channel/mcp-radar/run with {"reset":true}',
+        });
+      },
+    },
     {
       method: "GET",
       path: "/channel/mcp-radar/proof",
-      handler: async (req, res, ctx) => {
-        const url = new URL(req.url ?? "/", "http://localhost");
-        const format = url.searchParams.get("format");
-        const markdown = await readProofMarkdown(ctx.agentRoot);
-        if (format === "json") {
-          sendJson(res, 200, { markdown, path: "agent/research/mcp-innovations-proof.md" });
-          return;
-        }
-        res.statusCode = 200;
-        res.setHeader("content-type", "text/markdown; charset=utf-8");
-        res.end(markdown);
+      handler: async (_req, res, _ctx) => {
+        sendJson(res, 200, {
+          note: "Proof document lives in the proof catalog; read/write via agent Plasm session.",
+          sessions: "/operator/sessions",
+          runs: "/operator/runs",
+        });
       },
     },
     {

package/templates/mcp-radar/agent/hooks/proof-audit.ts

@@ -1,10 +1,24 @@
 import { defineHook } from "@plasm_lang/vercel-agent";
 
+import { recordRunAudit } from "../../lib/run-audit.js";
+
 export default defineHook({
   name: "proof-audit",
   on: ["run:complete", "plan:commit"],
   handler: (_ctx, detail) => {
-    const keys = detail && typeof detail === "object" ? Object.keys(detail) : [];
-    console.log(`[mcp-radar:hook:proof-audit] event detail keys=${keys.join(",")}`);
+    if (!detail || typeof detail !== "object") return;
+    recordRunAudit(detail as Record<string, unknown>);
+    const d = detail as Record<string, unknown>;
+    console.log(
+      "[mcp-radar:hook:proof-audit]",
+      JSON.stringify({
+        event: "audit",
+        runId: d.runId,
+        planCommitRef: d.planCommitRef ?? d.runRef,
+        logicalSessionRef: d.logicalSessionRef,
+        intent: d.intent,
+        ok: d.ok,
+      }),
+    );
   },
 });

package/templates/mcp-radar/agent/instructions.md

@@ -1,24 +1,36 @@
 # MCP Radar
 
-You track **Model Context Protocol (MCP)** innovation signals on Hacker News and corroborate them with Tavily web search.
+You track **Model Context Protocol (MCP)** innovation on Hacker News, corroborate with Tavily, and **publish** to a live **Proof** document — all via **Plasm programs** in one federated execute session.
 
-## Tool order
+## Tool order (mandatory)
 
 1. **`discover_capabilities`** — only when unsure which catalog entities to use.
 2. **`plasm_context`** — open or extend a session with seeds:
    - `hackernews:Item`
    - `tavily:SearchResult`
-   - Use stable intent: `track MCP innovations from Hacker News and corroborate with Tavily web search`
-3. **`plasm`** — dry-run programs using teaching TSV symbols.
+   - `proof:Document`
+   - **Stable intent** (same every turn): `track MCP innovations from Hacker News and corroborate with Tavily web search`
+3. **`plasm`** — dry-run programs using teaching TSV symbols (`e#`, `m#`, `p#`, `r#`).
 4. **`plasm_run`** — live execute reviewed plans (`pcN` only).
 
-## Per-run workflow
+Reuse **`logical_session_ref`** across the whole radar cycle. Do not open a new context per story.
 
-1. Search HN (`item_search` or `item_search_by_date`) for MCP-related stories from the candidate list in the user goal.
-2. For each **new** story, optionally `item_get` for score and metadata.
-3. If Tavily is available, run `web_search` with a query derived from the story title to corroborate.
-4. Emit **proof entries** using the `mcp-proof-format` skill template (one `###` block per story).
+## HN search (Plasm)
 
-If Tavily is unavailable, synthesize from HN only and set **Confidence: low**.
+Use `item_search_by_date` (or `item_search`) with an MCP-focused query, e.g.:
 
-Do not invent `e#` / `p#` symbols — copy from the teaching TSV.
+`"Model Context Protocol" OR MCP server OR MCP tool`
+
+Filter to stories **about MCP** — not general Hacker News. Skip ids already in the Proof document body (read via `document_get_markdown` first).
+
+## Proof document (Plasm)
+
+See skill **`proof-publish`**: bind share link (`document_share_bind`), `presence_update`, read markdown, append via `document_edit_v2`.
+
+If no document exists yet, `share_link_create` then bind. Do not emit proof only in chat — **`plasm_run` must mutate Proof**.
+
+## Tavily
+
+When Tavily is on the session, corroborate with `web_search`. If unavailable, set **Confidence: low** per `mcp-proof-format`.
+
+Do not invent symbols — copy from the teaching TSV.

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

@@ -1,18 +1,17 @@
 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";
+import { registerOTel } from "@vercel/otel";
+import { registerTelemetry } 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());
+  registerTelemetry(new OpenTelemetry());
 }
 
 register();

package/templates/mcp-radar/agent/skills/proof-publish.md

@@ -0,0 +1,15 @@
+# Publish MCP proof entries to Proof
+
+After composing proof markdown (see `mcp-proof-format`), **append to the live Proof document** via Plasm — not chat-only output.
+
+## Sequence (same `logical_session_ref`)
+
+1. `document_share_bind` — once per doc if not already bound (`share_url` or `share_token`).
+2. `presence_update` — agent_id e.g. `mcp-radar`.
+3. `editor_state_get` — host caches `base_token` for edits.
+4. `block_query` — list blocks; pick last block ref for append.
+5. `document_edit_v2` — `insert_after` with the proof markdown block(s), `base_revision` from editor state, `by` = agent name.
+
+On stale revision, re-run `editor_state_get` + `block_query` before retrying the edit.
+
+Reset runs: replace body with `# MCP Innovations Proof Log` only, then append fresh entries.