@moda-ai/cli 1.30.1 → 1.31.1

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   runPromptsCommand,
   runSkillsCommand,
   runStatusCommand
-} from "./cli-mq00fkwt.js";
+} from "./cli-j3rr0nh7.js";
 import {
   ApiError,
   HARNESS_REPORT_APPROVAL_PATH,
@@ -29,7 +29,7 @@ import {
   summarizeHarness,
   terminalStyles,
   validateHarnessReport
-} from "./cli-js4bmw21.js";
+} from "./cli-p3271yp2.js";
 import {
   authFetch,
   clearAuthSession,
@@ -152,6 +152,29 @@ var ProblemsSchema = z.object({
   limit: z.number().min(1).max(25).default(25).optional()
 });
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var ProblemImpactSchema = z.object({
+  node_id: z.string().min(1).max(256).optional(),
+  problem_id: z.string().regex(UUID_RE).optional(),
+  run_id: z.string().min(1).max(256).optional(),
+  days_back: z.union([z.literal("all"), z.coerce.number().refine((n) => [1, 3, 7, 30, 90].includes(n), "Use all, 1, 3, 7, 30, or 90 days")]).default(7),
+  mode: z.enum(["metrics", "trend", "evidence", "catalog", "overview", "affected-use-cases", "trace-use-cases"]).default("metrics"),
+  to: z.string().datetime({ precision: 3 }).optional(),
+  cursor: z.string().min(1).optional(),
+  conversation_ids: z.string().transform((value, ctx) => {
+    try {
+      return z.array(z.string().min(1).max(512)).min(1).max(25).parse(JSON.parse(value));
+    } catch {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Use a JSON array of 1–25 conversation IDs" });
+      return z.NEVER;
+    }
+  }).optional()
+}).refine((p) => p.mode !== "trace-use-cases" || p.problem_id && p.conversation_ids, {
+  message: "Trace use cases require --problem-id and --conversation-ids"
+}).refine((p) => p.node_id || p.problem_id || ["catalog", "overview"].includes(p.mode), {
+  message: "Select --node-id or --problem-id, or use --mode=catalog/overview"
+}).refine((p) => !p.cursor || p.mode === "evidence" && p.to && p.run_id, {
+  message: "An evidence cursor requires --mode=evidence, --to, and --run-id from the previous response"
+});
 var PROBLEM_FAMILIES = [
   "tool_failure",
   "emotion",
@@ -5356,6 +5379,7 @@ Commands:
   tool-failures                    Get tool failure overview
   tool-failure-detail <tool_name>  Get per-tool failure detail
   problems                         Rank cross-signal Problems by root cause (what to fix first)
+  problem-impact                   Live problem/use-case impact (--node-id, --problem-id, --mode, --days-back)
   problem <problem_id>             Open one Problem: dossier, or --evidence/--reports/--traces/--feedback
   problem-feedback <problem_id>    Mark a Problem fixed, dismiss, rename, or flag a bad attribution
   step-scores <conversation_id>    Graph-PRM step scores (per-segment curves, first bad step, rollup)
@@ -5514,6 +5538,11 @@ Init flags:
   --analyst-model=MODEL            Model for the claude analyst (default: sonnet;
                                    "default" = the claude CLI's own default;
                                    env: MODA_HARNESS_ANALYST_MODEL)
+  --concern=topology|tools|prompts|evals
+                                   Harness analyze: restrict the pass to one
+                                   concern (whole repo, one report scope); an
+                                   orchestrator merges the per-concern reports
+                                   (env: MODA_HARNESS_CONCERN, flag wins)
   --allow-no-agents                Allow harness sync to push a graph with zero
                                    runtime agents despite detected LLM usage
   --remote                         Run harness analysis server-side (Moda-hosted,
@@ -6216,6 +6245,35 @@ async function runCommand(command, positional, flags, positionals = positional ?
       await printWithOptionalWindows(withToolFailureAnchors(data), "examples", params.include_window === true, params.window ?? 1, context.output, warnings);
       break;
     }
+    case "problem-impact": {
+      const params = ProblemImpactSchema.parse(Object.fromEntries(Object.entries(flags).map(([key, value]) => [key.replace(/-/g, "_"), value])));
+      const query = new URLSearchParams({ days: String(params.days_back), mode: params.mode });
+      for (const [key, value] of Object.entries({
+        nodeId: params.node_id,
+        problemId: params.problem_id,
+        runId: params.run_id,
+        to: params.to,
+        cursor: params.cursor,
+        conversationIds: params.conversation_ids ? JSON.stringify(params.conversation_ids) : undefined
+      }))
+        if (value !== undefined)
+          query.set(key, value);
+      const data = asRecord(await callDataAPI(`/problem-impact?${query}`)) ?? {};
+      const link = new URLSearchParams({ impactDays: String(params.days_back) });
+      const window = asRecord(data.window);
+      const resolvedRun = asString(data.runId);
+      const windowEnd = asString(window?.to);
+      if (resolvedRun)
+        link.set("run", resolvedRun);
+      if (windowEnd)
+        link.set("impactTo", windowEnd);
+      if (params.node_id)
+        link.set("useCase", params.node_id);
+      const problem = asString(data.problemId) || params.problem_id;
+      const path = problem ? `/dashboard/problems/${encodeURIComponent(problem)}` : params.node_id ? `/dashboard/use-cases/${encodeURIComponent(params.node_id)}` : "/dashboard/use-cases";
+      context.output.writeData({ ...data, dashboard_url: `${resolveModaBaseUrl()}${path}?${link}` });
+      break;
+    }
     case "problems": {
       const args = flagsToArgs(flags);
       const params = ProblemsSchema.parse(args);
@@ -6521,7 +6579,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result",
     handler: async (context) => {
-      const { runInit } = await import("./index-14sr487g.js");
+      const { runInit } = await import("./index-4enh6fq6.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",
@@ -6903,6 +6961,21 @@ var commandRegistry = createCommandRegistry([
     examples: ["moda problems", "moda problems --days-back=7 --limit=10"],
     ...dataApiDefaults
   }),
+  legacyCommand({
+    name: "problem-impact",
+    description: "Live problem/use-case impact, full analysis denominators, daily recurrence, and paginated evidence",
+    examples: [
+      "moda problem-impact --mode=catalog",
+      "moda problem-impact --node-id=node_0 --days-back=all",
+      "moda problem-impact --problem-id=<uuid> --mode=metrics",
+      "moda problem-impact --node-id=node_0 --problem-id=<uuid> --mode=evidence",
+      "moda problem-impact --node-id=node_0 --mode=trend --days-back=30",
+      "moda problem-impact --mode=overview --days-back=7",
+      "moda problem-impact --problem-id=<uuid> --mode=affected-use-cases",
+      `moda problem-impact --problem-id=<uuid> --mode=trace-use-cases --conversation-ids='["trace_id"]'`
+    ],
+    ...dataApiDefaults
+  }),
   legacyCommand({
     name: "problem",
     description: "Open one Problem: dossier, or --evidence/--reports/--traces/--feedback pages (--conversations is a legacy alias of --traces)",

package/dist/{harness-github-actions-v98snak8.js → harness-github-actions-kbw4z7q4.js}

@@ -1,6 +1,6 @@
 import {
   buildSourceSnapshot
-} from "./cli-js4bmw21.js";
+} from "./cli-p3271yp2.js";
 import"./cli-59yacef3.js";
 
 // src/harness-github-actions.ts

package/dist/{index-14sr487g.js → index-4enh6fq6.js}

@@ -5,11 +5,12 @@ import {
   detectAgents,
   initPrompts,
   installRules,
+  packageAssetPath,
   readSkillsManifest,
   runPromptSync,
   runSkillSync,
   upsertSkillManifestRecord
-} from "./cli-mq00fkwt.js";
+} from "./cli-j3rr0nh7.js";
 import {
   codingAgentDisplayName,
   describeCodingAgentEvent,
@@ -27,7 +28,7 @@ import {
   runHarnessCommand,
   startRemoteAnalyze,
   stripAnsi
-} from "./cli-js4bmw21.js";
+} from "./cli-p3271yp2.js";
 import {
   selectTenantAndCreateKey
 } from "./cli-pq6rte0w.js";
@@ -57,9 +58,7 @@ import { dirname as dirname2, join as join3 } from "node:path";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
-import { fileURLToPath } from "node:url";
-var PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
-var BUNDLED_SKILLS_DIR = join(PACKAGE_ROOT, "skills", "integration");
+var BUNDLED_SKILLS_DIR = packageAssetPath("skills", "integration");
 function bundledSkillsDir() {
   return process.env.MODA_BUNDLED_SKILLS_DIR || BUNDLED_SKILLS_DIR;
 }
@@ -617,7 +616,7 @@ async function verifyExactTrace(opts) {
       const parsed = readAuditCounts(response);
       if (parsed) {
         counts = parsed;
-        if (counts.total_spans >= 1 && counts.llm_spans >= 1) {
+        if (counts.total_spans >= 1 && counts.llm_spans >= 1 && counts.orphan_count === 0 && !hasUnexpectedAuditDuplicates(response) && completeAI7Projection(response)) {
           return buildEvidence(true);
         }
       }
@@ -671,6 +670,62 @@ function isRecord2(value) {
 function isNonNegativeNumber(value) {
   return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
+function isAI7Audit(value) {
+  return isRecord2(value) && Array.isArray(value.spans) && value.spans.some((span) => isRecord2(span) && isRecord2(span.attributes) && ["cloudflare-think", "vercel-ai7"].includes(String(span.attributes["moda.integration.name"])));
+}
+function hasUnexpectedAuditDuplicates(value) {
+  if (!isRecord2(value) || !isRecord2(value.summary))
+    return true;
+  if (value.summary.duplicate_count === 0 || value.summary.duplicate_count === undefined)
+    return false;
+  if (!isAI7Audit(value) || !Array.isArray(value.duplicates) || !Array.isArray(value.spans) || value.duplicates.length !== value.summary.duplicate_count)
+    return true;
+  const spans = value.spans.filter(isRecord2);
+  return value.duplicates.some((group) => {
+    if (!isRecord2(group) || group.type !== "duplicate_operation" || !Array.isArray(group.span_ids) || group.span_ids.length < 2 || new Set(group.span_ids).size !== group.span_ids.length)
+      return true;
+    const calls = [];
+    for (const id of group.span_ids) {
+      const matches = spans.filter((span2) => span2.span_id === id);
+      if (matches.length !== 1)
+        return true;
+      const span = matches[0];
+      if (span.type !== "tool" || !isRecord2(span.tool) || typeof span.tool.call_id !== "string" || !span.tool.call_id)
+        return true;
+      if (!isRecord2(span.attributes) || !["cloudflare-think", "vercel-ai7"].includes(String(span.attributes["moda.integration.name"])))
+        return true;
+      calls.push(span.tool.call_id);
+    }
+    return new Set(calls).size !== calls.length;
+  });
+}
+function completeAI7Projection(value) {
+  if (!isAI7Audit(value))
+    return true;
+  if (!isRecord2(value) || !Array.isArray(value.spans) || value.parse_errors !== 0 || !isRecord2(value.summary) || value.summary.truncated !== false)
+    return false;
+  const spans = value.spans.filter(isRecord2);
+  for (const span of spans.filter((span2) => span2.type === "llm")) {
+    if (isRecord2(span.attributes) && span.attributes["gen_ai.system_instructions"]) {
+      if (!Array.isArray(span.prompt) || !span.prompt.some((message) => isRecord2(message) && message.role === "system"))
+        return false;
+    }
+  }
+  const transcript = value.conversationContext;
+  if (!isRecord2(transcript) || !isRecord2(transcript.context) || !Array.isArray(transcript.context.messages))
+    return false;
+  if (transcript.total_messages !== transcript.context.messages.length)
+    return false;
+  const expected = spans.filter((span) => span.type === "tool").map((span) => isRecord2(span.tool) ? span.tool.call_id : undefined);
+  const actual = [];
+  for (const message of transcript.context.messages) {
+    if (!isRecord2(message) || !Array.isArray(message.tool_calls))
+      return false;
+    for (const tool of message.tool_calls)
+      actual.push(isRecord2(tool) ? tool.id : undefined);
+  }
+  return expected.every((id) => typeof id === "string") && actual.every((id) => typeof id === "string") && new Set(actual).size === actual.length && expected.length === actual.length && expected.every((id) => actual.includes(id));
+}
 async function fetchAuditWithApiKey(id, apiKey, baseUrl) {
   const url = `${baseUrl}/api/v1/data/audit/${encodeURIComponent(id)}?kind=conversation`;
   const response = await fetch(url, {
@@ -682,7 +737,17 @@ async function fetchAuditWithApiKey(id, apiKey, baseUrl) {
   if (!response.ok) {
     throw new Error(`Audit fetch failed (${response.status}): ${body.slice(0, 200)}`);
   }
-  return JSON.parse(body);
+  const audit = JSON.parse(body);
+  if (isAI7Audit(audit) && isRecord2(audit)) {
+    const contextResponse = await fetch(`${baseUrl}/api/v1/data/conversations/${encodeURIComponent(id)}/context?window=20`, {
+      headers: { "x-api-key": apiKey },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!contextResponse.ok)
+      throw new Error(`AI7 conversation verification failed (${contextResponse.status})`);
+    return { ...audit, conversationContext: await contextResponse.json() };
+  }
+  return audit;
 }
 
 // src/init/sdk-integration.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.30.1",
+  "version": "1.31.1",
   "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,8 +1,20 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-09-02T04:30:52.582Z",
-  "cli_version": "1.30.1",
+  "bundled_at": "2026-09-15T20:51:36.329Z",
+  "cli_version": "1.31.1",
   "skills": [
+    {
+      "id": "integration-cloudflare-think",
+      "version": "1.0.0",
+      "summary": "Instrument Think on Workers with AI SDK 7, prompt versions, and acknowledged JSON export.",
+      "targets": {
+        "language": "node",
+        "frameworks": [
+          "cloudflare-think"
+        ],
+        "providers": []
+      }
+    },
     {
       "id": "integration-node-anthropic",
       "version": "1.0.0",
@@ -51,7 +63,7 @@
     },
     {
       "id": "integration-node-vercel-ai-sdk",
-      "version": "1.0.0",
+      "version": "1.0.2",
       "summary": "Instrument Vercel AI SDK calls (generateText, streamText, generateObject) with Moda telemetry in a Node.js or TypeScript app.",
       "targets": {
         "language": "node",

package/skills/integration/integration-cloudflare-think/EXAMPLE.md

@@ -0,0 +1,75 @@
+# Think with AI SDK 7
+
+Merge this hook into the existing Think class, preserving its model, tools,
+routes and hook overrides. Requires SDK 1.16.0's `moda-ai/think` entry point.
+
+```typescript
+import { Think, type TurnContext } from '@cloudflare/think';
+import { createThinkTelemetry } from 'moda-ai/think';
+
+interface Env { MODA_API_KEY: string; MODA_INGEST_URL?: string; AI: Ai }
+
+export class TaskAgent extends Think<Env> {
+  getModel() { return '@cf/moonshotai/kimi-k2.7-code' as const; }
+
+  async beforeTurn(_context: TurnContext) {
+    const moda = createThinkTelemetry({
+      apiKey: this.env.MODA_API_KEY,
+      endpoint: this.env.MODA_INGEST_URL,
+      recordInputs: true,
+      recordOutputs: true,
+      onExportError: error => console.error('Moda export failed', error.message),
+    });
+    return { telemetry: moda.telemetry };
+  }
+}
+```
+
+The helper delegates tracing, export and flushing to the shared AI7 integration;
+non-Think apps use `createAI7Telemetry` from `moda-ai/ai7`. Think's adapter includes
+only its session and turn identity keys from runtime context.
+The helper uses Think's runtime conversation ID by default. To attribute
+managed prompts, import the synced `.moda/prompts.lock.json` at build time
+and add `prompt: lock.prompts['your.prompt.key']` to the options. Keep the
+app's own prompt rendering. The helper flushes on completion/abort and
+retains failed batches for an explicit retry while the object is alive.
+
+## Smoke through an existing callable
+
+For the upstream `think-submissions` app, the public API is `submitTask` and
+`inspectTask`. Adapt these names to the application's existing callables.
+Use a temporary script, with the CLI's verification ID as its argument:
+
+```javascript
+import { AgentClient } from 'agents/client';
+
+const id = process.argv[2];
+if (!id) throw new Error('Pass the CLI verification ID');
+const client = new AgentClient({
+  host: '127.0.0.1:4190', protocol: 'ws', agent: 'TaskAgent', name: id,
+});
+try {
+  const task = await client.call('submitTask', ['Reply with OK.', crypto.randomUUID()]);
+  let completed = false;
+  for (let attempt = 0; attempt < 60; attempt++) {
+    const status = await client.call('inspectTask', [task.submissionId]);
+    if (status.status === 'completed') { completed = true; break; }
+    if (['error', 'aborted', 'skipped'].includes(status.status)) {
+      throw new Error(`Submission failed: ${status.status}`);
+    }
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  }
+  if (!completed) throw new Error('Submission timed out');
+} finally {
+  client.close();
+}
+```
+
+This example has one conversation per named Agent: set the telemetry option
+`conversationId: this.name` so the smoke's Agent name becomes the verification
+ID. Keep multi-session apps' own session identity instead. Never hard-code the
+verification ID in the application's source. Confirm delivery with the CLI's
+trace check after the submission completes.
+Use a new submission idempotency key on each smoke attempt, while keeping the
+same verification conversation ID. Reusing a completed submission's key only
+returns its old acknowledgment and does not exercise repaired instrumentation.

package/skills/integration/integration-cloudflare-think/SKILL.md

@@ -0,0 +1,123 @@
+---
+id: integration-cloudflare-think
+name: "Integrate Moda with Cloudflare Think"
+version: 1.0.0
+category: integration
+targets:
+  language: node
+  frameworks:
+    - cloudflare-think
+  providers: []
+sdk_package: moda-ai
+summary: "Instrument Think on Workers with AI SDK 7, prompt versions, and acknowledged JSON export."
+---
+
+# Integrate Moda with Cloudflare Think
+
+## Safety rules (apply to every step)
+
+- Only touch the repository you were launched in.
+- Never write the `MODA_API_KEY` value (or any secret) into source files, and
+  never create or edit `.env` files. The key belongs in the runtime
+  environment or a secret manager.
+- Make the smallest correct change. Match the existing code style and imports.
+- Do not commit unless the user asks.
+- If a step is ambiguous in this repository, stop and report rather than
+  guessing.
+
+## 1. Find the real Think entry point
+
+Find classes extending `Think` from `@cloudflare/think`, their `beforeTurn`
+hooks, session identity, and submission/chat route. Read installed versions.
+This recipe supports Think 0.18, AI SDK 7 and `@ai-sdk/otel` 1.x. For a
+different major, report the compatibility gap instead of upgrading the app.
+
+## 2. Install the Workers integration
+
+With the repository's package manager, install `moda-ai` with the
+`moda-ai/think` export (1.16.0 or later) and `@ai-sdk/otel` 1.x. Confirm the
+export exists before editing call sites. If it is not published yet, report
+the release prerequisite. Retain Workers' `nodejs_compat` configuration.
+
+The dedicated entry point owns a per-turn tracer and fetch-based JSON
+exporter. Instrument the loop once: reconcile existing instrumentation or
+native export to Moda before adding a second telemetry path.
+
+## 3. Wire the existing hook
+
+Follow [EXAMPLE.md](EXAMPLE.md). Create telemetry per invocation and merge
+it with existing hook return values. Preserve unrelated integrations.
+Supply `env.MODA_API_KEY` from runtime secrets.
+Pass `env.MODA_INGEST_URL` as `endpoint` when an ingest override is provided
+(for example, an isolated test deployment). Make both values available in
+the Worker runtime; shell variables alone are not automatically Worker bindings.
+Use the app's session ID or
+let the helper use Think's runtime conversation ID; agent name is suitable
+only for an agent with one conversation.
+
+Message and tool payload capture is opt-in via `recordInputs` and
+`recordOutputs`. The helper flushes on completion/abort. Keep its `flush()`
+available for explicit delivery verification and report `onExportError`.
+Retries preserve span IDs. Pending exports live in memory, so abrupt
+runtime termination does not have durable archival guarantees.
+
+## 4. Ingest reusable prompts when requested
+
+Find the source prompt (`getSystemPrompt` or context configuration). Inline
+TypeScript is not discovered by `moda prompts`. Extract the reusable
+definition into a supported `.prompt.json` file and have the original hook
+read it. Run `moda prompts init` then `moda prompts sync`; require the
+expected definition to be present. Import `.moda/prompts.lock.json` at
+build time and pass its `{ key, promptId, versionId }` entry as `prompt`.
+Re-sync changed definitions before building.
+
+Use the CLI's actual JSON fields, for example:
+
+```json
+{
+  "key": "task-agent.system",
+  "name": "Task agent system prompt",
+  "systemPrompt": "The exact existing getSystemPrompt text goes here."
+}
+```
+
+Existing JSON definitions with a plain-text `template` are also accepted;
+the CLI maps that text to registered content without rewriting the file.
+Keep the application's existing prompt field and have `getSystemPrompt` read
+that same definition so runtime and registry cannot drift.
+Check the sync payload includes the actual text; a lock entry or
+version ID alone does not prove that a nonempty definition was registered.
+
+Keep memory and variable substitutions separate from reusable template
+versions. Think adds instructions/tools: verify actual system instructions
+on each model span as well as the registry definition.
+Reference: https://docs.moda.dev/prompt-management/attribution
+
+## 5. Validate through the original application route
+
+Build and typecheck. Exercise a fresh session through the original route:
+an exact response, a real tool invocation, and a second turn. Wait for
+export acknowledgment. Use `moda audit` on that exact conversation to check
+expected model/tool counts, system/user inputs, output, prompt version,
+and zero duplicates/orphans. Check conversation records too: step spans
+must not become tools, real call IDs must occur once, and successful tools
+must not report failures. Re-running onboarding must reuse the integration.
+
+For callable submission methods, use the installed `AgentClient` from
+`agents/client` (the same protocol as `useAgent().call()`), rather than
+reimplementing its wire protocol. A plain HTTP GET to a WebSocket route may
+return 404 even when the WebSocket works. A submission acknowledgment only
+means queued: poll the app's inspection method until completion before
+checking telemetry.
+
+The CLI supplies an exact verification conversation ID. In a single-conversation
+per-Agent app such as `think-submissions`, `conversationId: this.name` lets a
+fresh named Agent use that ID. For apps with multiple sessions per Agent, use
+their actual session ID instead. Never hard-code the verification ID in source.
+
+Report missing evidence explicitly; connectivity alone is not a complete
+integration verdict. Finish with:
+
+```bash
+moda doctor --online --json
+```

package/skills/integration/integration-node-vercel-ai-sdk/SKILL.md

@@ -1,7 +1,7 @@
 ---
 id: integration-node-vercel-ai-sdk
 name: "Integrate Moda with the Vercel AI SDK (Node.js / TypeScript)"
-version: 1.0.0
+version: 1.0.2
 category: integration
 targets:
   language: node
@@ -37,6 +37,11 @@ prefer those; they match the installed SDK version).
 Find the real LLM call sites: search for `generateText`, `streamText`,
 `generateObject`, or `streamObject` imported from the `ai` package.
 
+Check the installed `ai` major version before selecting an API. For
+`@cloudflare/think` with AI SDK 7, use `integration-cloudflare-think`.
+For other AI SDK 7 apps, follow `references/ai7.md` instead of Steps 2 onward
+and the legacy `EXAMPLE.md`. The remaining steps here target AI SDK through v6.
+
 - If you find none, stop and report: this skill only applies to apps that
   call the Vercel AI SDK directly.
 - Instrument the Vercel AI SDK layer only. Do NOT also instrument raw
@@ -140,9 +145,8 @@ identifier exists anywhere, stop and report; do not invent one.
 
 ## Step 6: Attribute managed prompts (only if the repo uses them)
 
-Only if this repository has a `.moda/prompts.yml` manifest: render managed
-prompts through the SDK before creating the telemetry config, so traces point
-at exact prompt versions. See
+Only if this repository has a `.moda/prompts.yml` manifest: read synced prompt
+IDs from the lockfile and attach them explicitly to telemetry metadata. See
 [references/prompt-attribution.md](references/prompt-attribution.md).
 If there is no prompt manifest, skip this step.
 

package/skills/integration/integration-node-vercel-ai-sdk/references/ai7.md

@@ -0,0 +1,52 @@
+# AI SDK 7: shared integration
+
+Apply the parent skill's safety rules. This recipe supports direct
+`generateText` and `streamText` calls on AI SDK 7, in Node or Workers.
+Think apps use the `integration-cloudflare-think` entry because their framework
+supplies session/turn identity.
+
+1. Confirm the installed `ai` major is 7. Install `moda-ai` >=1.16.0 and
+   `@ai-sdk/otel` 1.x using the repository's package manager. Verify
+   `moda-ai/ai7` exports `createAI7Telemetry`. If unavailable, stop and report
+   that the SDK release is required; do not substitute the older tracer helper.
+2. Keep the app's model, tools, routes, prompts and streaming behavior. Create
+   the helper using the provisioned key from the runtime environment. Set
+   `conversationId` to the existing app session ID; without it each AI7 call is
+   a separate conversation. Set `userId` when the app has a user identifier.
+3. Set the existing call's `telemetry` to the returned configuration. Preserve
+   existing integrations when merging: retain their order and append Moda's
+   integration array. Avoid also tracing the underlying provider client.
+4. Prompt/tool payload capture defaults off. Enable `recordInputs` and
+   `recordOutputs` when prompt/content ingestion is required and authorized.
+   After source prompt extraction and `moda prompts sync`, pass the matching
+   lockfile `{key, promptId, versionId}` as `prompt`; keep the app's rendering.
+5. Await `flush()` after a completed generation (or a fully consumed stream)
+   for onboarding verification. Supply `onExportError` for runtime visibility;
+   AI7 may swallow hook exceptions. In Workers retain `nodejs_compat` and use
+   the runtime's request/stream lifecycle to finish asynchronous work.
+
+For same-zone Worker-to-Worker routing on `workers.dev`, configure a service
+binding and pass `fetch: (url, init) => env.MODA_INGEST.fetch(new Request(url, init))`.
+Other deployments use the default native fetch. This changes transport only;
+the SDK still serializes, authenticates, retries and verifies the export response.
+
+```typescript
+import { createAI7Telemetry } from 'moda-ai/ai7';
+
+const moda = createAI7Telemetry({
+  apiKey: process.env.MODA_API_KEY!, // Workers: use the request's env binding.
+  conversationId: sessionId,
+  recordInputs: true,
+  recordOutputs: true,
+  onExportError: error => console.error('Moda export failed', error.message),
+});
+const result = await generateText({ ...existingOptions, telemetry: moda.telemetry });
+await moda.flush();
+```
+
+Validate using a fresh verification conversation ID and the provisioned key.
+Require complete spans, normalized system prompts when captured, actual tool
+calls/results without duplicate summary records, and a complete conversation
+window. The CLI verifier checks this for `vercel-ai7` and `cloudflare-think`.
+An HTTP 200 alone is not acceptance. Retries retain span IDs, but the shared
+export buffer is in memory and cannot guarantee delivery across isolate eviction.

package/skills/integration/integration-node-vercel-ai-sdk/references/prompt-attribution.md

@@ -3,29 +3,31 @@
 Only relevant when the repository manages prompts with Moda
 (`.moda/prompts.yml` exists and prompts are synced with `moda prompts sync`).
 
-Render the managed prompt through the SDK, then create the telemetry config.
-`Moda.getVercelAITelemetry()` includes the rendered prompt's metadata
-(`moda.prompt_key`, `moda.prompt_id`, `moda.prompt_version`,
-`moda.prompt_version_id`) in `experimental_telemetry.metadata`, so production
-traces point at the exact prompt version:
+Run `moda prompts sync`, read `.moda/prompts.lock.json`, and pass its registry
+IDs explicitly in telemetry metadata. Keep the application's own rendering.
+This example uses the tracer-based AI SDK API through v6. Think with AI SDK
+7 uses `moda-ai/think` and `telemetry.integrations`; see its catalog entry.
 
 ```typescript
 import { Moda } from 'moda-ai';
 import { generateText } from 'ai';
 import { openai } from '@ai-sdk/openai';
+import prompts from './.moda/prompts.lock.json';
 
-const rendered = Moda.prompt('support.triage').render({
-  ticket: { text: userMessage },
-});
+const version = prompts.prompts['support.triage'];
 
 const result = await generateText({
   model: openai('gpt-4o'),
-  messages: rendered.messages,
-  experimental_telemetry: Moda.getVercelAITelemetry(),
+  prompt: 'Triage this support request.',
+  experimental_telemetry: Moda.getVercelAITelemetry({ metadata: {
+    'moda.prompt_key': version.key,
+    'moda.prompt_id': version.promptId,
+    'moda.prompt_version_id': version.versionId,
+  }}),
 });
 ```
 
-Order matters: render the prompt before calling
-`Moda.getVercelAITelemetry()` so prompt metadata is attached.
+Re-sync a changed definition before building. Different variable values can
+share a template version; full model inputs are recorded separately.
 
 Full reference: https://docs.moda.dev/ingestion/vercel-ai-sdk