@moda-ai/cli 1.30.2 → 1.31.1

package/README.md

@@ -126,6 +126,11 @@ Prompt management is code-first. Keep prompts in `prompts/**/*.prompt.md` or
 `prompts/**/*.prompt.json`, sync them with the CLI, and render them through the
 SDK so LLM spans include prompt metadata.
 
+JSON definitions can provide `content`, `systemPrompt`, or `messages`. Existing
+files with a nonempty text `template` also work: the CLI uses it as content when
+none of those fields supplies usable text. Sync preserves placeholders and
+leaves the source file unchanged; empty definitions still produce an error.
+
 ```bash
 moda prompts init
 moda prompts status

package/dist/{cli-c1vhkg8n.js → cli-j3rr0nh7.js}

@@ -11,7 +11,7 @@ import {
   renderStatusHuman,
   scanHarness,
   validateHarnessReport
-} from "./cli-ts6nhn51.js";
+} from "./cli-p3271yp2.js";
 import {
   isAuthSessionValid,
   loadAuthSession
@@ -772,7 +772,19 @@ function parsePromptFile(absPath) {
   if (absPath.endsWith(".json")) {
     const parsed = JSON.parse(raw);
     const key2 = parsed.key || keyFromPath(sourcePath);
-    const content = parsed.content || JSON.stringify(parsed.messages ?? [], null, 2);
+    const hasContent = typeof parsed.content === "string" && parsed.content.trim().length > 0;
+    const hasSystemPrompt = typeof parsed.systemPrompt === "string" && parsed.systemPrompt.trim().length > 0;
+    const hasTemplate = typeof parsed.template === "string" && parsed.template.trim().length > 0;
+    const hasMessages = Array.isArray(parsed.messages) && parsed.messages.some((message) => {
+      if (!message || typeof message !== "object" || !("role" in message) || !["system", "developer", "user", "assistant", "tool"].includes(String(message.role)) || !("content" in message))
+        return false;
+      const content2 = message.content;
+      return typeof content2 === "string" ? content2.trim().length > 0 : Array.isArray(content2) && content2.some((part) => part && typeof part === "object" && part.type === "text" && typeof part.text === "string" && part.text.trim().length > 0);
+    });
+    if (!hasContent && !hasSystemPrompt && !hasMessages && !hasTemplate) {
+      throw new Error(`${sourcePath}: prompt JSON requires non-empty content, systemPrompt, messages, or a text template.`);
+    }
+    const content = hasContent ? parsed.content : hasSystemPrompt ? parsed.systemPrompt : hasMessages ? JSON.stringify(parsed.messages, null, 2) : parsed.template;
     return normalizePrompt({ ...parsed, key: key2, name: parsed.name || key2, sourcePath, content });
   }
   const { frontmatter, body } = parseFrontmatter(raw);
@@ -931,11 +943,18 @@ function printJson(value) {
 
 // src/init/rules.ts
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "node:fs";
+import { join as join3 } from "node:path";
+import { confirm } from "@inquirer/prompts";
+
+// src/package-assets.ts
 import { dirname as dirname2, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { confirm } from "@inquirer/prompts";
-var PACKAGE_ROOT = join2(dirname2(fileURLToPath(import.meta.url)), "..", "..");
-var SKILLS_SOURCE_DIR = join2(PACKAGE_ROOT, "skills");
+function packageAssetPath(...parts) {
+  return join2(dirname2(fileURLToPath(import.meta.url)), "..", ...parts);
+}
+
+// src/init/rules.ts
+var SKILLS_SOURCE_DIR = packageAssetPath("skills");
 var SKILLS = [
   {
     id: "moda-cli",
@@ -946,7 +965,7 @@ var ADAPTERS = {
   "Claude Code": {
     name: "Claude Code",
     targetFor: (skillId) => ({
-      dir: join2(".claude", "skills", skillId),
+      dir: join3(".claude", "skills", skillId),
       filename: "SKILL.md"
     }),
     transform: (content) => content
@@ -954,7 +973,7 @@ var ADAPTERS = {
   Cursor: {
     name: "Cursor",
     targetFor: (skillId) => ({
-      dir: join2(".cursor", "rules"),
+      dir: join3(".cursor", "rules"),
       filename: `${skillId}.mdc`
     }),
     transform: claudeSkillToCursorRule
@@ -979,7 +998,7 @@ function claudeSkillToCursorRule(skillContent) {
 ${body.replace(/^\s+/, "")}`;
 }
 function loadSkillSource(skillId) {
-  const path = join2(SKILLS_SOURCE_DIR, skillId, "SKILL.md");
+  const path = join3(SKILLS_SOURCE_DIR, skillId, "SKILL.md");
   if (!existsSync3(path)) {
     throw new Error(`Skill source missing: ${path}`);
   }
@@ -987,9 +1006,9 @@ function loadSkillSource(skillId) {
 }
 function installSkillForAgent(skill, adapter, content) {
   const { dir, filename } = adapter.targetFor(skill.id);
-  const dirPath = join2(process.cwd(), dir);
-  const filePath = join2(dirPath, filename);
-  const relativePath = join2(dir, filename);
+  const dirPath = join3(process.cwd(), dir);
+  const filePath = join3(dirPath, filename);
+  const relativePath = join3(dir, filename);
   try {
     mkdirSync2(dirPath, { recursive: true });
     if (existsSync3(filePath)) {
@@ -1075,7 +1094,7 @@ async function installRules(detectedAgents, options = {}) {
 
 // src/init/mcp.ts
 import { existsSync as existsSync4 } from "node:fs";
-import { join as join3 } from "node:path";
+import { join as join4 } from "node:path";
 import { execSync } from "node:child_process";
 function isOnPath(cmd) {
   try {
@@ -1088,10 +1107,10 @@ function isOnPath(cmd) {
 function detectAgents() {
   const cwd = process.cwd();
   const agents = [];
-  if (existsSync4(join3(cwd, ".claude")) || isOnPath("claude")) {
+  if (existsSync4(join4(cwd, ".claude")) || isOnPath("claude")) {
     agents.push("Claude Code");
   }
-  if (existsSync4(join3(cwd, ".cursor"))) {
+  if (existsSync4(join4(cwd, ".cursor"))) {
     agents.push("Cursor");
   }
   return agents;
@@ -1108,7 +1127,7 @@ import {
   readFileSync as readFileSync5,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { basename, dirname as dirname5, join as join6, relative as relative3 } from "node:path";
+import { basename, dirname as dirname5, join as join7, relative as relative3 } from "node:path";
 
 // src/skills-manifest.ts
 import {
@@ -1120,12 +1139,12 @@ import {
   unlinkSync,
   writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname3, isAbsolute as isAbsolute4, join as join4, normalize, relative as relative2, resolve as resolve4 } from "node:path";
-var SKILLS_MANIFEST_PATH = join4(".moda", "skills.yml");
+import { dirname as dirname3, isAbsolute as isAbsolute4, join as join5, normalize, relative as relative2, resolve as resolve4 } from "node:path";
+var SKILLS_MANIFEST_PATH = join5(".moda", "skills.yml");
 var SKILL_SOURCE_HARNESS = "moda";
 var SKILL_SOURCE_INTEGRATION_BUNDLED = "integration-bundled";
 function readSkillsManifest(cwd) {
-  const manifestPath = join4(cwd, SKILLS_MANIFEST_PATH);
+  const manifestPath = join5(cwd, SKILLS_MANIFEST_PATH);
   if (!existsSync5(manifestPath))
     return null;
   let text = "";
@@ -1156,7 +1175,7 @@ function manifestHeaderFrom(manifest) {
   };
 }
 function writeSkillsManifest(cwd, header, records) {
-  const manifestPath = join4(cwd, SKILLS_MANIFEST_PATH);
+  const manifestPath = join5(cwd, SKILLS_MANIFEST_PATH);
   const managedPaths = [...new Set(records.flatMap((record) => record.paths))].sort();
   const lines = [
     "version: 1",
@@ -1211,7 +1230,7 @@ function pruneManagedSkillPaths(cwd, managedPaths, log) {
 function pruneEmptyClaudeSkillDir(cwd, relativePath) {
   if (!relativePath.startsWith(".claude/skills/") || !relativePath.endsWith("/SKILL.md"))
     return;
-  const dir = dirname3(join4(cwd, relativePath));
+  const dir = dirname3(join5(cwd, relativePath));
   try {
     if (existsSync5(dir) && readdirSync2(dir).length === 0) {
       rmdirSync(dir);
@@ -1331,7 +1350,7 @@ function yamlQuote(value) {
 
 // src/agents-md.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname4, join as join5 } from "node:path";
+import { dirname as dirname4, join as join6 } from "node:path";
 var AGENTS_MD_FILENAME = "AGENTS.md";
 var FIXES_BLOCK_BEGIN = "<!-- moda:fixes:begin -->";
 var FIXES_BLOCK_END = "<!-- moda:fixes:end -->";
@@ -1392,7 +1411,7 @@ function writeFileIfChanged(filePath, content) {
   }
 }
 function upsertFixesAgentsBlock(cwd) {
-  const filePath = join5(cwd, AGENTS_MD_FILENAME);
+  const filePath = join6(cwd, AGENTS_MD_FILENAME);
   let existing = null;
   if (existsSync6(filePath)) {
     try {
@@ -1408,7 +1427,7 @@ function upsertFixesAgentsBlock(cwd) {
 // src/skills.ts
 var SKILLS_REQUEST_TIMEOUT_MS = 15000;
 var VALID_STATUSES = new Set(["approved", "proposed", "all"]);
-var SKILL_PROPOSALS_MANIFEST_PATH = join6(".moda", "skill-proposals.yml");
+var SKILL_PROPOSALS_MANIFEST_PATH = join7(".moda", "skill-proposals.yml");
 async function fetchSkills(status) {
   const apiKey = resolveApiKey();
   if (!apiKey) {
@@ -1578,7 +1597,7 @@ async function pullSkills(options = {}) {
     }
   }
   const agents = detectAgents();
-  const writeCursor = agents.includes("Cursor") || existsSync7(join6(cwd, ".cursor"));
+  const writeCursor = agents.includes("Cursor") || existsSync7(join7(cwd, ".cursor"));
   const records = [];
   for (const skill of skills) {
     if (!skill.skill_id || !skill.skill_md) {
@@ -1591,7 +1610,7 @@ async function pullSkills(options = {}) {
       log(`  skipped invalid skill_id: ${JSON.stringify(skill.skill_id).slice(0, 80)}`);
       continue;
     }
-    const claudePath = join6(cwd, ".claude", "skills", safeId, "SKILL.md");
+    const claudePath = join7(cwd, ".claude", "skills", safeId, "SKILL.md");
     const claudeStatus = writeIfChanged(claudePath, skill.skill_md);
     const claudeRelativePath = `.claude/skills/${safeId}/SKILL.md`;
     recordOutcome(summary, claudeStatus, log, claudeRelativePath);
@@ -1599,7 +1618,7 @@ async function pullSkills(options = {}) {
     if (claudeStatus !== "failed")
       paths.push(claudeRelativePath);
     if (writeCursor) {
-      const cursorPath = join6(cwd, ".cursor", "rules", `${safeId}.mdc`);
+      const cursorPath = join7(cwd, ".cursor", "rules", `${safeId}.mdc`);
       const cursorStatus = writeIfChanged(cursorPath, claudeSkillToCursorRule(skill.skill_md));
       const cursorRelativePath = `.cursor/rules/${safeId}.mdc`;
       recordOutcome(summary, cursorStatus, log, cursorRelativePath);
@@ -1637,7 +1656,7 @@ function recordOutcome(summary, status, log, relativePath) {
       break;
   }
 }
-var SKILLS_DIR = join6(".claude", "skills");
+var SKILLS_DIR = join7(".claude", "skills");
 var SKILL_FILE = "SKILL.md";
 var MAX_SKILL_WALK_DEPTH = 4;
 async function runSkillSync(flags = {}, profileOptions = {}, options = {}) {
@@ -1668,7 +1687,7 @@ async function runSkillSync(flags = {}, profileOptions = {}, options = {}) {
   return { synced: response.synced ?? [], dryRun, ...agentsMd ? { agentsMd } : {} };
 }
 function discoverLocalSkills(cwd) {
-  const skillsRoot = join6(cwd, SKILLS_DIR);
+  const skillsRoot = join7(cwd, SKILLS_DIR);
   if (!existsSync7(skillsRoot))
     return [];
   const managed = new Set(managedSkillPaths(cwd));
@@ -1717,7 +1736,7 @@ function walkSkillFiles(dir, depth) {
   }
   const files = [];
   for (const entry of entries) {
-    const fullPath = join6(dir, entry);
+    const fullPath = join7(dir, entry);
     let stat;
     try {
       stat = lstatSync2(fullPath);
@@ -1791,7 +1810,7 @@ async function applySkillProposal(proposalId, flags, profileOptions = {}, option
   }
   const safeId = safeSkillId(proposal.skillId);
   const relativePath = `.claude/skills/${safeId}/SKILL.md`;
-  const writeStatus = writeIfChanged(join6(cwd, relativePath), proposal.skillMd);
+  const writeStatus = writeIfChanged(join7(cwd, relativePath), proposal.skillMd);
   if (writeStatus === "failed") {
     throw new Error(`Failed to write ${relativePath}`);
   }
@@ -1824,7 +1843,7 @@ function safeSkillId(skillId) {
   return safeId;
 }
 function writeSkillProposalManifest(cwd, proposal, relativePath) {
-  const manifestPath = join6(cwd, SKILL_PROPOSALS_MANIFEST_PATH);
+  const manifestPath = join7(cwd, SKILL_PROPOSALS_MANIFEST_PATH);
   mkdirSync5(dirname5(manifestPath), { recursive: true });
   const existing = existsSync7(manifestPath) ? readFileSync5(manifestPath, "utf8") : `applied_proposals:
 `;
@@ -2085,7 +2104,7 @@ function sha2562(input) {
 // src/doctor.ts
 import { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync8, readFileSync as readFileSync6, statSync } from "node:fs";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 async function runDoctorCommand(context) {
   const report = await buildDoctorReport(context, {
     offline: context.flags.offline === "true"
@@ -2208,7 +2227,7 @@ async function buildDoctorReport(context, options) {
   checks.push(urlCheck("base_url_valid", "config", "Base URL is valid", baseUrl));
   checks.push(urlCheck("ingest_url_valid", "config", "Ingest URL is valid", ingestUrl));
   checks.push(localBaseUrlCheck(activeProfile.environment, baseUrl));
-  const manifestPath = join7(context.cwd, ".moda", "harness.json");
+  const manifestPath = join8(context.cwd, ".moda", "harness.json");
   const manifestExists = existsSync8(manifestPath);
   checks.push({
     id: "harness_manifest_exists",
@@ -2498,7 +2517,7 @@ function harnessSyncStateCheck(cwd) {
   };
 }
 function harnessReportStateCheck(cwd) {
-  const reportPath = join7(cwd, HARNESS_REPORT_PATH);
+  const reportPath = join8(cwd, HARNESS_REPORT_PATH);
   if (!existsSync8(reportPath)) {
     return {
       id: "harness_report_approved_synced",
@@ -2592,7 +2611,7 @@ function harnessReportStateCheck(cwd) {
   }
 }
 function readHarnessReportApproval(cwd) {
-  const approvalPath = join7(cwd, HARNESS_REPORT_APPROVAL_PATH);
+  const approvalPath = join8(cwd, HARNESS_REPORT_APPROVAL_PATH);
   if (!existsSync8(approvalPath))
     return null;
   try {
@@ -2610,7 +2629,7 @@ function readHarnessReportApproval(cwd) {
   }
 }
 function discoveryCheck(id, group, title, cwd, relativePaths, nextCommand) {
-  const found = relativePaths.filter((path) => existsSync8(join7(cwd, path)));
+  const found = relativePaths.filter((path) => existsSync8(join8(cwd, path)));
   return {
     id,
     group,
@@ -2626,7 +2645,7 @@ function sdkInitializationCheck(cwd) {
   const candidates = ["src", "app", "agent_harness"];
   let detected = false;
   for (const candidate of candidates) {
-    const path = join7(cwd, candidate);
+    const path = join8(cwd, candidate);
     if (!existsSync8(path))
       continue;
     try {
@@ -2950,4 +2969,4 @@ function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 
-export { DEFAULT_POLL_INTERVAL_MS, DEFAULT_WAIT_TIMEOUT_MS, fetchLatestRun, runPromptsCommand, initPrompts, runPromptSync, claudeSkillToCursorRule, installRules, detectAgents, SKILL_SOURCE_INTEGRATION_BUNDLED, readSkillsManifest, upsertSkillManifestRecord, runSkillSync, runSkillsCommand, runDoctorCommand, runStatusCommand, buildDoctorReport };
+export { DEFAULT_POLL_INTERVAL_MS, DEFAULT_WAIT_TIMEOUT_MS, fetchLatestRun, runPromptsCommand, initPrompts, runPromptSync, packageAssetPath, claudeSkillToCursorRule, installRules, detectAgents, SKILL_SOURCE_INTEGRATION_BUNDLED, readSkillsManifest, upsertSkillManifestRecord, runSkillSync, runSkillsCommand, runDoctorCommand, runStatusCommand, buildDoctorReport };

package/dist/{cli-ts6nhn51.js → cli-p3271yp2.js}

@@ -1654,7 +1654,7 @@ function citationExcerptMatches(expected, actualLine) {
   return expectedNormalized.includes(actualNormalized) || actualNormalized.includes(expectedNormalized);
 }
 function normalizeComparableText(value) {
-  return value.replace(/\s+/g, " ").trim().slice(0, 240);
+  return value.replace(/\s+/g, " ").trim();
 }
 function validateCitation(citation, rootDir, errors, warnings, options) {
   if (citation.type === "command_output" || citation.type === "production_evidence") {
@@ -3546,7 +3546,7 @@ async function runHarnessCommand(context) {
         elapsed_ms: Date.now() - context.startedAt
       });
       if (context.flags["github-actions"] === "true") {
-        const { runGithubActionsAnalyze } = await import("./harness-github-actions-ze17s10y.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-kbw4z7q4.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -4237,9 +4237,22 @@ function repairCitationLines(report, rootDir) {
     const currentLine = typeof citation.line === "number" ? lines[citation.line - 1] : undefined;
     if (currentLine && citationLineMatches(currentLine, excerpt))
       continue;
-    const matchedIndex = lines.findIndex((line) => citationLineMatches(line, excerpt));
-    if (matchedIndex >= 0)
-      citation.line = matchedIndex + 1;
+    const needle = normalizeComparableLine(excerpt);
+    if (!needle)
+      continue;
+    const sourceLines = lines.map((line, index) => ({ text: normalizeComparableLine(line), index })).filter((line) => line.text.length > 0);
+    const source = sourceLines.map((line) => line.text).join(" ");
+    const match = source.indexOf(needle);
+    if (match < 0 || source.indexOf(needle, match + 1) >= 0)
+      continue;
+    let offset = 0;
+    for (const line of sourceLines) {
+      if (match >= offset && match < offset + line.text.length) {
+        citation.line = line.index + 1;
+        break;
+      }
+      offset += line.text.length + 1;
+    }
   }
 }
 function citationLineMatches(line, excerpt) {
@@ -4745,7 +4758,7 @@ function resolveExternalHarnessAnalystInvocation(options) {
   if (options.adapter === "claude") {
     const extraArgs = externalAnalystExtraArgs(options.adapter);
     const model = resolveAnalystModel(options.adapter, options.flags);
-    const permission = mode === "write" ? ["--permission-mode", "acceptEdits", "--allowedTools", "Read,Grep,Glob,Edit,Write,Bash"] : ["--allowedTools", `Read,Grep,Glob,Write(${HARNESS_REPORT_PATH}),Bash(pwd),Bash(ls *),Bash(find *),Bash(rg *),Bash(grep *),Bash(cat *),Bash(git status *),Bash(git ls-files *),Bash(git grep *)`];
+    const permission = mode === "write" ? ["--permission-mode", "acceptEdits", "--allowedTools", "Read,Grep,Glob,Edit,Write,Bash"] : ["--allowedTools", `Read,Grep,Glob,Edit(${HARNESS_REPORT_PATH}),Bash(pwd),Bash(ls *),Bash(find *),Bash(rg *),Bash(grep *),Bash(cat *),Bash(git status *),Bash(git ls-files *),Bash(git grep *)`];
     return {
       adapter: options.adapter,
       command,

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   runPromptsCommand,
   runSkillsCommand,
   runStatusCommand
-} from "./cli-c1vhkg8n.js";
+} from "./cli-j3rr0nh7.js";
 import {
   ApiError,
   HARNESS_REPORT_APPROVAL_PATH,
@@ -29,7 +29,7 @@ import {
   summarizeHarness,
   terminalStyles,
   validateHarnessReport
-} from "./cli-ts6nhn51.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)
@@ -6221,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);
@@ -6526,7 +6579,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result",
     handler: async (context) => {
-      const { runInit } = await import("./index-v3j2848b.js");
+      const { runInit } = await import("./index-4enh6fq6.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",
@@ -6908,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-ze17s10y.js → harness-github-actions-kbw4z7q4.js}

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

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

@@ -5,11 +5,12 @@ import {
   detectAgents,
   initPrompts,
   installRules,
+  packageAssetPath,
   readSkillsManifest,
   runPromptSync,
   runSkillSync,
   upsertSkillManifestRecord
-} from "./cli-c1vhkg8n.js";
+} from "./cli-j3rr0nh7.js";
 import {
   codingAgentDisplayName,
   describeCodingAgentEvent,
@@ -27,7 +28,7 @@ import {
   runHarnessCommand,
   startRemoteAnalyze,
   stripAnsi
-} from "./cli-ts6nhn51.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.2",
+  "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-03T05:01:51.741Z",
-  "cli_version": "1.30.2",
+  "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