@moda-ai/cli 1.50.0 → 1.54.0

package/dist/{cli-jqfm8dp4.js → cli-a2jq9yd5.js}

@@ -1,11 +1,18 @@
 import {
+  computePromptContentHash,
+  stableJson
+} from "./cli-mm48br00.js";
+import {
+  $isSeq,
   $parseDocument,
   $stringify,
   assertFlags,
   assertPositionals,
+  backfillPromptSource,
   callControlAPI,
   callDataAPI,
   inventoryFiles,
+  normalizeHarnessReport,
   readHarnessSyncState,
   renderDoctorHuman,
   renderStatusHuman,
@@ -13,7 +20,7 @@ import {
   resolvePromptSource,
   safePromptEvidencePath,
   scanHarness
-} from "./cli-x0x0n35w.js";
+} from "./cli-9250ckvg.js";
 import {
   SKILL_SOURCE_HARNESS,
   SKILL_SOURCE_INTEGRATION_BUNDLED,
@@ -26,7 +33,7 @@ import {
 import {
   isAuthSessionValid,
   loadAuthSession
-} from "./cli-7kbzqact.js";
+} from "./cli-kxwm7y62.js";
 import {
   CliInputError,
   EXIT_ERROR,
@@ -45,7 +52,7 @@ import {
   resolveTenantId,
   secretFilePathFromRef,
   validateConfig
-} from "./cli-xrs02c0t.js";
+} from "./cli-ac3p2byq.js";
 import {
   __commonJS,
   __require,
@@ -6463,6 +6470,7 @@ function checkPromptAttribution(rootDir, keys) {
 var MODA_DIR = ".moda";
 var MANIFEST_PATH = join(MODA_DIR, "prompts.yml");
 var LOCK_PATH = join(MODA_DIR, "prompts.lock.json");
+var DISCOVERY_IGNORE = ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/.env*", "**/*.pem", "**/*.key"];
 var DEFAULT_PROMPT_PATHS = [
   "prompts/**/*.prompt.md",
   "prompts/**/*.prompt.json",
@@ -6473,6 +6481,7 @@ var PROMPT_WRITE_SUBCOMMAND_FLAGS = {
   init: ["from-harness"],
   status: [],
   diff: [],
+  migrate: ["dry-run", "discover"],
   sync: [
     "dry-run",
     "from-harness",
@@ -6577,18 +6586,41 @@ async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
           kind: "prompt_manifest",
           path: init.manifestPath,
           description: init.created ? "Prompt discovery manifest created by this run." : "Prompt discovery manifest already existed; left unchanged."
-        }]
+        }],
+        ...imported?.skipped.length ? { warnings: [harnessSkipWarning(imported)] } : {}
       });
       break;
     }
-    case "status":
-      context.output.writeData(await getPromptStatus());
+    case "status": {
+      const status = await getPromptStatus();
+      const warnings = promptManifestWarnings(status);
+      context.output.writeData(status, warnings.length > 0 ? { warnings } : undefined);
       break;
+    }
+    case "migrate": {
+      assertPositionals("prompts migrate", positionals, 1, "moda prompts migrate [--dry-run] [--discover]");
+      const result = await migratePromptManifest({
+        dryRun: flags["dry-run"] === "true",
+        discover: flags.discover === "true",
+        env: profileOptions.env
+      });
+      context.output.writeData(result, {
+        summary: {
+          text: !result.changed ? `${MANIFEST_PATH} is already version 2 with nothing to add.` : `${result.dryRun ? "Would migrate" : "Migrated"} ${MANIFEST_PATH} from version ${result.fromVersion} to 2: ${result.addedPaths.length} legacy-discovered path(s), ${result.addedSources.length} discovered source(s) added.`,
+          confidence: "high"
+        },
+        ...result.changed && !result.dryRun ? {
+          artifacts: [{ kind: "prompt_manifest", path: result.manifestPath, description: "Prompt manifest rewritten to version 2." }]
+        } : {},
+        ...migrateWarnings(result).length > 0 ? { warnings: migrateWarnings(result) } : {}
+      });
+      break;
+    }
     case "diff": {
       const status = await getPromptStatus();
       const differing = status.prompts.filter((row) => row.state !== "unchanged");
       const tracked = existsSync2(MANIFEST_PATH);
-      const untrackedWarning = tracked ? [] : [
+      const diffWarnings = tracked ? promptManifestWarnings(status) : [
         `No ${MANIFEST_PATH} here, so diff has no last sync to compare against: it only covers prompts tracked by \`moda prompts sync\`${differing.length > 0 ? ", and every discovered prompt file lists as new" : ""}. For a registry manifest, preview with \`moda registry push --dry-run\`.`
       ];
       context.output.writeData({
@@ -6601,7 +6633,7 @@ async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
           text: !tracked ? differing.length === 0 ? `Not a prompts-sync project (no ${MANIFEST_PATH}) and no prompt files found; diff has nothing to compare.` : `Not a prompts-sync project (no ${MANIFEST_PATH}): ${differing.length} discovered prompt file(s) are untracked and would be new on \`moda prompts sync\`.` : differing.length === 0 ? "No prompt differs from the last sync." : `${differing.length} prompt(s) differ from the last sync (changed ${status.changed}, new ${status.new}, deleted ${status.deleted}).`,
           confidence: "high"
         },
-        ...untrackedWarning.length > 0 ? { warnings: untrackedWarning } : {}
+        ...diffWarnings.length > 0 ? { warnings: diffWarnings } : {}
       });
       break;
     }
@@ -6625,7 +6657,7 @@ async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
       await runPromptRegistryRead(subcommand, positionals, flags, profileOptions, context);
       break;
     default:
-      throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, sync, promote, ab, propose, list, show, proposals, usage, replay-runs, or decide.`);
+      throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, migrate, sync, promote, ab, propose, list, show, proposals, usage, replay-runs, or decide.`);
   }
   return 0;
 }
@@ -6640,7 +6672,7 @@ async function initPrompts(options = {}) {
   if (!existsSync2(MANIFEST_PATH)) {
     assertContainedSource(cwd, MODA_DIR);
     try {
-      writeFileSync2(manifestPath, ["version: 1", "prompt_paths:", ...DEFAULT_PROMPT_PATHS.map((path) => `  - "${path}"`), ""].join(`
+      writeFileSync2(manifestPath, ["version: 2", "prompt_paths:", ...DEFAULT_PROMPT_PATHS.map((path) => `  - "${path}"`), "sources: []", ""].join(`
 `), { flag: "wx" });
       created = true;
     } catch (error) {
@@ -6698,20 +6730,26 @@ async function runPromptSync(flags, profileOptions, options = {}) {
   }
 }
 async function runPromptSyncExclusive(flags, profileOptions, options) {
+  let harnessImport;
   if (flags["from-harness"] && flags["dry-run"] !== "true")
-    importHarnessPromptSources(flags["from-harness"]);
+    harnessImport = importHarnessPromptSources(flags["from-harness"]);
   if (flags["dry-run"] !== "true")
     await initPrompts({ silent: true });
   const manifest = readManifest();
   const originalManifestHash = hashFile(MANIFEST_PATH);
-  let extraSources = flags["from-harness"] && flags["dry-run"] === "true" ? readHarnessSources(flags["from-harness"]) : [];
+  let extraSources = [];
+  if (flags["from-harness"] && flags["dry-run"] === "true") {
+    const read = readHarnessSources(flags["from-harness"]);
+    extraSources = read.sources;
+    harnessImport = read.result;
+  }
   mergePromptSources(manifest.sources, extraSources);
   const established = discoverPrompts(extraSources);
   let discovery;
   const analyzedDefinitions = new Map;
   if (flags["no-analyze"] !== "true") {
     options.onProgress?.("Analyzing prompt sources before sync.");
-    const { analyzeHarnessPrompts } = await import("./harness-7gr0xbtc.js");
+    const { analyzeHarnessPrompts } = await import("./harness-sd44jsaw.js");
     const result = await analyzeHarnessPrompts({
       rootDir: process.cwd(),
       existing: established.flatMap((prompt) => prompt.sourceDefinition ? [prompt.sourceDefinition.source] : []),
@@ -6761,7 +6799,7 @@ async function runPromptSyncExclusive(flags, profileOptions, options) {
   if (prompts.length === 0) {
     if (!dryRun && flags["allow-untrack"] === "true")
       writeLock([], []);
-    return { synced: [], dryRun, discovery, attribution };
+    return { synced: [], dryRun, discovery, attribution, ...harnessImport ? { harnessImport } : {} };
   }
   const signature = stableJson(prompts);
   const response = await callControlAPI("/prompts/sync", {
@@ -6793,7 +6831,7 @@ async function runPromptSyncExclusive(flags, profileOptions, options) {
       atomicWrite(MANIFEST_PATH, manifestUpdate);
     writeLock(prompts, synced);
   }
-  return { synced: response.synced ?? [], dryRun, discovery, attribution };
+  return { synced: response.synced ?? [], dryRun, discovery, attribution, ...harnessImport ? { harnessImport } : {} };
 }
 function writePromptSyncProgress(message, context, quiet = false) {
   if (quiet || context?.quiet)
@@ -6813,10 +6851,12 @@ async function syncPromptsOnce(flags, profileOptions, context) {
     synced: result.synced,
     discovery: result.discovery,
     attribution: result.attribution,
+    ...result.harnessImport ? { harnessImport: result.harnessImport } : {},
     lockfile: result.dryRun ? undefined : LOCK_PATH
   };
+  const skippedWarning = result.harnessImport?.skipped.length ? [harnessSkipWarning(result.harnessImport)] : [];
   if (context)
-    context.output.writeData(payload);
+    context.output.writeData(payload, skippedWarning.length ? { warnings: skippedWarning } : undefined);
   else
     printJson(payload);
   if (!result.dryRun && result.synced.length === 0 && result.discovery?.candidates?.length) {
@@ -6885,9 +6925,15 @@ async function getPromptStatus() {
       });
     }
   }
+  const inspection = inspectPromptManifest();
   return {
     manifest: MANIFEST_PATH,
     lockfile: LOCK_PATH,
+    manifestVersion: inspection.manifestVersion,
+    legacyManifest: inspection.legacyManifest,
+    zeroMatchPatterns: inspection.zeroMatchPatterns,
+    legacyOnlyFiles: inspection.legacyOnlyFiles,
+    sources: inspection.sources,
     total: rows.length,
     changed: rows.filter((row) => row.state === "changed").length,
     new: rows.filter((row) => row.state === "new").length,
@@ -6896,7 +6942,9 @@ async function getPromptStatus() {
   };
 }
 function discoverPrompts(extraSources = []) {
-  const manifest = readManifest();
+  return discoverManifestPrompts(readManifest(), extraSources);
+}
+function discoverManifestPrompts(manifest, extraSources = []) {
   const root = process.cwd();
   for (const pattern of manifest.promptPaths) {
     const positive = pattern.startsWith("!") ? pattern.slice(1) : pattern;
@@ -6912,7 +6960,7 @@ function discoverPrompts(extraSources = []) {
     followSymbolicLinks: false,
     dot: true,
     unique: true,
-    ignore: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/.env*", "**/*.pem", "**/*.key"]
+    ignore: DISCOVERY_IGNORE
   }).sort();
   const sources = new Map(manifest.sources.map((source) => [source.key, source]));
   for (const source of extraSources)
@@ -6934,6 +6982,185 @@ function discoverPrompts(extraSources = []) {
   }
   return prompts.sort((a, b) => a.key.localeCompare(b.key));
 }
+var LEGACY_PROMPT_SUFFIXES = [".prompt.md", ".prompt.json", ".prompt.yaml", ".prompt.yml"];
+function repoPath(root, path) {
+  return relative(root, resolve4(root, path)).replaceAll("\\", "/");
+}
+function globPromptFiles(root, patterns, ignore = []) {
+  if (patterns.length === 0)
+    return [];
+  return import_fast_glob.default.sync(patterns, {
+    cwd: root,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    dot: true,
+    unique: true,
+    ignore: [...DISCOVERY_IGNORE, ...ignore]
+  }).sort();
+}
+function inspectPromptManifest(root = process.cwd()) {
+  const manifest = readManifest(root);
+  const safe = (pattern) => !isAbsolute3(pattern) && !pattern.split(/[\\/]/).includes("..");
+  const positives = manifest.promptPaths.filter((pattern) => !pattern.startsWith("!") && safe(pattern));
+  const negations = manifest.promptPaths.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+  const patterns = manifest.promptPaths.filter((pattern) => !pattern.startsWith("!")).map((pattern) => ({
+    pattern,
+    matches: safe(pattern) ? globPromptFiles(root, [pattern], negations).length : 0
+  }));
+  const matched = new Set(globPromptFiles(root, positives, negations));
+  const owned = new Set(manifest.sources.map((source) => repoPath(root, source.path)));
+  const suffixes = [...new Set(manifest.promptPaths.filter((pattern) => pattern.includes(".prompt.")).flatMap((pattern) => LEGACY_PROMPT_SUFFIXES.filter((suffix) => pattern.endsWith(suffix))))];
+  const legacySuffixes = suffixes.length ? suffixes : [".prompt.md", ".prompt.json"];
+  const tracked = manifest.version === 2 ? lockedSourcePaths(root) : null;
+  const legacyOnlyFiles = manifest.version === null ? [] : globPromptFiles(root, legacySuffixes.map((suffix) => `**/*${suffix}`), negations).filter((path) => !matched.has(path) && !owned.has(path) && (!tracked || tracked.has(path)));
+  return {
+    manifestExists: manifest.version !== null,
+    manifestVersion: manifest.version,
+    legacyManifest: manifest.version === 1,
+    patterns,
+    zeroMatchPatterns: patterns.filter((row) => row.matches === 0).map((row) => row.pattern),
+    sources: manifest.sources.length,
+    matchedFiles: matched.size,
+    legacyOnlyFiles
+  };
+}
+function lockedSourcePaths(root) {
+  const lockPath = resolve4(root, LOCK_PATH);
+  if (!existsSync2(lockPath))
+    return new Set;
+  try {
+    const lock = JSON.parse(readFileSync(lockPath, "utf8"));
+    return new Set(Object.values(lock.prompts ?? {}).filter((entry) => entry.sourcePath).map((entry) => repoPath(root, String(entry.sourcePath))));
+  } catch {
+    return new Set;
+  }
+}
+function promptManifestWarnings(inspection) {
+  if (inspection.manifestVersion === null)
+    return [];
+  const warnings = [];
+  const legacyCount = inspection.legacyOnlyFiles.length;
+  if (legacyCount > 0) {
+    const sample = inspection.legacyOnlyFiles.slice(0, 3).join(", ");
+    warnings.push(`${legacyCount} prompt file(s) (${sample}${legacyCount > 3 ? ", ..." : ""}) were discovered by older CLIs but match no ${MANIFEST_PATH} pattern now: patterns are exact globs from the repository root. Run \`moda prompts migrate --dry-run\`, then \`moda prompts migrate\`, to keep them tracked under their existing keys.`);
+  }
+  if (inspection.zeroMatchPatterns.length > 0) {
+    warnings.push(`prompt_paths pattern(s) match no files: ${inspection.zeroMatchPatterns.join(", ")}. Fix the globs (relative to the repository root), map code-defined prompts under \`sources:\`, or preview discovery with \`moda prompts sync --dry-run\`.`);
+  }
+  if (inspection.legacyManifest && warnings.length > 0) {
+    warnings.push(`${MANIFEST_PATH} is a version 1 manifest; \`moda prompts migrate\` rewrites it to version 2 (explicit prompt_paths plus a sources: list).`);
+  }
+  return warnings;
+}
+function migrateWarnings(result) {
+  const warnings = [];
+  if (result.zeroMatchPatterns.length > 0) {
+    warnings.push(`Kept prompt_paths pattern(s) that match no files: ${result.zeroMatchPatterns.join(", ")}. Fix or remove them.`);
+  }
+  if (result.pendingSources.length > 0) {
+    const sample = result.pendingSources.slice(0, 3).map((source) => source.key).join(", ");
+    warnings.push(`${result.pendingSources.length} code-defined prompt candidate(s) (${sample}${result.pendingSources.length > 3 ? ", ..." : ""}) were found but not added: --discover never runs an analyst, and code mappings need independent verification. Run \`${HARNESS_REANALYZE_COMMAND}\`, then \`moda prompts sync --from-harness\`, or map them under \`sources:\` yourself. See pendingSources.`);
+  }
+  return warnings;
+}
+async function migratePromptManifest(options = {}) {
+  const root = process.cwd();
+  const manifestPath = resolve4(root, MANIFEST_PATH);
+  if (!existsSync2(manifestPath)) {
+    throw new CliInputError(`No ${MANIFEST_PATH} to migrate in ${root}.`, "Run `moda prompts init` to create a version 2 manifest.");
+  }
+  const original = readFileSync(manifestPath, "utf8");
+  const manifest = readManifest(root);
+  const inspection = inspectPromptManifest(root);
+  const addedPaths = inspection.legacyOnlyFiles;
+  const addedPatterns = addedPaths.map((path) => import_fast_glob.default.escapePath(path));
+  const promptPaths = [...manifest.promptPaths, ...addedPatterns];
+  let sources = manifest.sources;
+  let addedSources = [];
+  let pendingSources = [];
+  if (options.discover) {
+    const { analyzeHarnessPrompts } = await import("./harness-sd44jsaw.js");
+    const result = await analyzeHarnessPrompts({
+      rootDir: root,
+      existing: manifest.sources,
+      flags: { analyst: "local-scan" },
+      env: options.env ?? process.env,
+      dryRun: true
+    });
+    const negations = promptPaths.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+    const claimed = new Set([
+      ...globPromptFiles(root, promptPaths.filter((pattern) => !pattern.startsWith("!"))),
+      ...globPromptFiles(root, negations)
+    ]);
+    const existingKeys = new Set(sources.map((source) => source.key));
+    const found = result.sources.filter((source) => !existingKeys.has(source.key) && !claimed.has(repoPath(root, source.path)));
+    sources = mergePromptSources(sources, found);
+    addedSources = found.map((source) => source.key).sort();
+    pendingSources = (result.pending ?? []).filter((candidate) => !existingKeys.has(candidate.source.key) && !claimed.has(repoPath(root, candidate.source.path))).map((candidate) => ({
+      key: candidate.source.key,
+      path: candidate.source.path,
+      ...candidate.source.selector?.symbol ? { symbol: candidate.source.selector.symbol } : {},
+      reason: candidate.reason ?? "Awaiting independent semantic verification"
+    })).sort((a, b) => a.key.localeCompare(b.key));
+  }
+  try {
+    discoverManifestPrompts({ version: 2, promptPaths, sources });
+  } catch (error) {
+    throw new CliInputError(`Cannot migrate ${MANIFEST_PATH}: ${error instanceof Error ? error.message : String(error)}`, `Give the conflicting prompt a unique \`key:\` (frontmatter or ${MANIFEST_PATH} sources), then rerun \`moda prompts migrate --dry-run\`. Nothing was written.`);
+  }
+  const expected = stableJson({ version: 2, prompt_paths: promptPaths, sources });
+  const serialize = (inPlace) => {
+    const doc = $parseDocument(original, { uniqueKeys: true });
+    doc.set("version", 2);
+    const pathsNode = doc.get("prompt_paths", true);
+    if (inPlace && $isSeq(pathsNode)) {
+      for (const pattern of addedPatterns)
+        pathsNode.items.push(doc.createNode(pattern));
+    } else {
+      doc.set("prompt_paths", promptPaths);
+    }
+    const existingKeys = new Set(manifest.sources.map((source) => source.key));
+    const newSources = sources.filter((source) => !existingKeys.has(source.key));
+    const sourcesNode = doc.get("sources", true);
+    if (inPlace && $isSeq(sourcesNode)) {
+      for (const source of newSources)
+        sourcesNode.items.push(doc.createNode(source));
+    } else if (!inPlace || newSources.length > 0 || sourcesNode === undefined) {
+      doc.set("sources", sources);
+    }
+    return doc.toString();
+  };
+  const matchesExpected = (text) => {
+    const parsed = $parseDocument(text, { uniqueKeys: true }).toJS({ maxAliasCount: 20 }) ?? {};
+    return stableJson({ version: parsed.version, prompt_paths: parsed.prompt_paths ?? [], sources: parsed.sources ?? [] }) === expected;
+  };
+  let content = serialize(true);
+  if (!matchesExpected(content))
+    content = serialize(false);
+  if (!matchesExpected(content)) {
+    throw new CliInputError(`Cannot migrate ${MANIFEST_PATH}: the rewritten manifest does not round-trip (shared YAML anchors or aliases?). Nothing was written.`, `Replace anchors/aliases in prompt_paths and sources with plain lists, then rerun \`moda prompts migrate --dry-run\`.`);
+  }
+  const changed = content !== original;
+  if (!options.dryRun && changed) {
+    if (hashFile(MANIFEST_PATH) !== sha256(original))
+      throw new Error(`${MANIFEST_PATH} changed during migration. Retry.`);
+    atomicWrite(MANIFEST_PATH, content);
+  }
+  return {
+    manifest: MANIFEST_PATH,
+    manifestPath,
+    dryRun: options.dryRun === true,
+    changed,
+    fromVersion: manifest.version ?? 2,
+    toVersion: 2,
+    addedPaths,
+    addedSources,
+    pendingSources,
+    zeroMatchPatterns: inspection.zeroMatchPatterns,
+    promptPaths,
+    content
+  };
+}
 function assertContainedSource(root, path) {
   const abs = resolve4(root, path);
   const rel = relative(realpathSync(root), realpathSync(abs));
@@ -6987,18 +7214,6 @@ function parsePromptFile(absPath) {
   });
 }
 function normalizePrompt(prompt) {
-  const normalized = stableJson({
-    key: prompt.key,
-    content: prompt.content,
-    systemPrompt: prompt.systemPrompt ?? null,
-    messages: prompt.messages ?? [],
-    variables: prompt.variables ?? [],
-    variablesSchema: prompt.variablesSchema ?? {},
-    modelConfig: prompt.modelConfig ?? {},
-    toolRefs: prompt.toolRefs ?? [],
-    responseSchema: prompt.responseSchema ?? null,
-    ...prompt.sourceDefinition ? { sourceDefinition: promptSourceHashPayload(prompt.sourceDefinition) } : {}
-  });
   return {
     key: prompt.key,
     name: prompt.name || prompt.key,
@@ -7013,28 +7228,14 @@ function normalizePrompt(prompt) {
     modelConfig: prompt.modelConfig,
     toolRefs: prompt.toolRefs,
     responseSchema: prompt.responseSchema,
-    contentHash: sha256(normalized)
+    contentHash: computePromptContentHash(prompt)
   };
 }
-function promptSourceHashPayload(definition) {
-  return {
-    kind: definition.kind,
-    source: definition.source,
-    ...["text", "messages"].includes(definition.kind) ? {
-      sourceHash: definition.sourceHash
-    } : ["builder", "template"].includes(definition.kind) ? {
-      sourceHash: definition.sourceHash,
-      dependencies: definition.dependencies,
-      coverage: definition.coverage,
-      unresolved: definition.unresolved
-    } : {}
-  };
-}
-function readManifest() {
-  if (!existsSync2(MANIFEST_PATH))
-    return { promptPaths: DEFAULT_PROMPT_PATHS, sources: [] };
-  assertContainedSource(process.cwd(), MANIFEST_PATH);
-  const doc = $parseDocument(readFileSync(MANIFEST_PATH, "utf8"), { uniqueKeys: true });
+function readManifest(root = process.cwd()) {
+  if (!existsSync2(resolve4(root, MANIFEST_PATH)))
+    return { version: null, promptPaths: DEFAULT_PROMPT_PATHS, sources: [] };
+  assertContainedSource(root, MANIFEST_PATH);
+  const doc = $parseDocument(readFileSync(resolve4(root, MANIFEST_PATH), "utf8"), { uniqueKeys: true });
   if (doc.errors.length)
     throw new Error(`Invalid ${MANIFEST_PATH}: ${doc.errors[0].message}`);
   const parsed = doc.toJS({ maxAliasCount: 20 });
@@ -7055,33 +7256,96 @@ function readManifest() {
       throw new Error(`Duplicate prompt source key '${source.key}'.`);
     seen.add(source.key);
   }
-  return { promptPaths: parsed.prompt_paths ?? (parsed.version === 1 ? DEFAULT_PROMPT_PATHS : []), sources };
+  return { version: parsed.version, promptPaths: parsed.prompt_paths ?? (parsed.version === 1 ? DEFAULT_PROMPT_PATHS : []), sources };
 }
+var HARNESS_REANALYZE_COMMAND = "moda harness analyze --experimental --concern=prompts";
 function readHarnessSources(reportPath) {
   const selected = reportPath === "true" ? ".moda/harness-report.json" : reportPath;
   assertContainedSource(process.cwd(), selected);
-  const report = JSON.parse(readFileSync(resolve4(selected), "utf8"));
-  if (!Array.isArray(report?.graph?.artifacts))
-    throw new Error("Expected a harness report with graph.artifacts.");
-  const artifacts = report.graph.artifacts.filter((artifact) => artifact.type === "prompt");
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(resolve4(selected), "utf8"));
+  } catch (error) {
+    throw new CliInputError(`Could not read harness report ${selected}: ${error instanceof Error ? error.message : String(error)}.`, `Regenerate it with \`${HARNESS_REANALYZE_COMMAND}\`.`);
+  }
+  const record = raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  const graph = record.graph && typeof record.graph === "object" ? record.graph : undefined;
+  const schemaVersion = typeof record.schemaVersion === "string" ? record.schemaVersion : typeof graph?.schemaVersion === "string" ? graph.schemaVersion : typeof graph?.graphSchemaVersion === "string" ? graph.graphSchemaVersion : null;
+  const schemaLabel = schemaVersion ?? "no schemaVersion";
+  if (!graph) {
+    throw new CliInputError(`${selected} is not a harness report with a graph (schema: ${schemaLabel}). Regenerate it with \`${HARNESS_REANALYZE_COMMAND}\`.`);
+  }
+  const report = normalizeHarnessReport(raw);
+  const artifacts = (report.graph.artifacts ?? []).filter((artifact) => artifact.type === "prompt");
   const sources = [];
+  const skipped = [];
+  const tracked = [];
+  const root = process.cwd();
+  const manifest = readManifest(root);
+  const negations = manifest.promptPaths.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+  const globbed = new Set(globPromptFiles(root, manifest.promptPaths.filter((pattern) => !pattern.startsWith("!")), negations));
+  const ownedKeys = new Map(manifest.sources.map((source) => [repoPath(root, source.path), source.key]));
   for (const artifact of artifacts) {
-    if (!artifact.promptSource)
-      throw new Error(`Harness prompt '${artifact.name ?? artifact.id}' has no verified source mapping. Run harness analyze --concern=prompts; legacy body snippets cannot be registered.`);
-    const resolved = resolvePromptSource(process.cwd(), artifact.promptSource);
-    sources.push(resolved.sourceDefinition.source);
+    const label = String(artifact.name ?? artifact.id ?? "unnamed prompt");
+    let mapping;
+    try {
+      mapping = backfillPromptSource(process.cwd(), artifact);
+    } catch (error) {
+      skipped.push({ artifact: label, reason: `source mapping could not be derived: ${error instanceof Error ? error.message : String(error)}` });
+      continue;
+    }
+    if (!mapping) {
+      skipped.push({
+        artifact: label,
+        reason: artifact.sourcePath ? `no promptSource, and no single definition in ${artifact.sourcePath} matches its name` : "no promptSource or sourcePath (legacy body snippets cannot be registered)"
+      });
+      continue;
+    }
+    if (!artifact.promptSource && !mapping.selector) {
+      const path = repoPath(root, mapping.path);
+      const nativeFile = /\.prompt\.(md|json)$/i.test(path);
+      const ownedKey = ownedKeys.get(path);
+      if (ownedKey !== undefined || globbed.has(path)) {
+        let key = ownedKey ?? keyFromPath(path);
+        try {
+          if (ownedKey === undefined && nativeFile)
+            key = parsePromptFile(resolve4(root, path)).key;
+        } catch {}
+        tracked.push({ artifact: label, key, path });
+        continue;
+      }
+      if (nativeFile) {
+        skipped.push({
+          artifact: label,
+          reason: `${path} is a dedicated prompt file; add it to prompt_paths (\`moda prompts migrate\` adds files older CLIs discovered) so it keeps its own key and parser`
+        });
+        continue;
+      }
+      if (/\.prompt\.ya?ml$/i.test(path))
+        mapping = { ...mapping, key: keyFromPath(path) };
+    }
+    try {
+      sources.push(resolvePromptSource(process.cwd(), mapping).sourceDefinition.source);
+    } catch (error) {
+      skipped.push({ artifact: label, reason: error instanceof Error ? error.message : String(error) });
+    }
+  }
+  if (!sources.length && !tracked.length) {
+    const detail = skipped.length ? ` ${skipped.length} prompt artifact(s) skipped: ${skipped.slice(0, 5).map((skip) => `'${skip.artifact}' (${skip.reason})`).join("; ")}${skipped.length > 5 ? "; ..." : ""}.` : " It contains no prompt artifacts.";
+    throw new CliInputError(`Harness report ${selected} (schema: ${schemaLabel}) has no prompt that maps to current source.${detail} Regenerate it with \`${HARNESS_REANALYZE_COMMAND}\`.`, `Or map prompts directly under \`sources:\` in ${MANIFEST_PATH}.`);
   }
-  if (!sources.length)
-    throw new Error("Harness report contains no mapped prompts to register.");
-  return sources;
+  return { sources, result: { report: selected, schemaVersion, registered: sources.map((source) => source.key), skipped, tracked } };
+}
+function harnessSkipWarning(result) {
+  return `${result.skipped.length} harness prompt(s) skipped (registered ${result.registered.length}): ${result.skipped.slice(0, 3).map((skip) => `'${skip.artifact}' (${skip.reason})`).join("; ")}${result.skipped.length > 3 ? "; ..." : ""}. See harnessImport.skipped; regenerate the report with \`${HARNESS_REANALYZE_COMMAND}\` to map them.`;
 }
 function importHarnessPromptSources(reportPath = ".moda/harness-report.json") {
-  const sources = readHarnessSources(reportPath);
+  const { sources, result } = readHarnessSources(reportPath);
   const manifest = readManifest();
   const merged = mergePromptSources(manifest.sources, sources);
   discoverPrompts(sources);
   atomicWrite(MANIFEST_PATH, $stringify({ version: 2, prompt_paths: manifest.promptPaths, sources: merged }));
-  return { registered: sources.map((source) => source.key) };
+  return result;
 }
 function mergePromptSources(existingSources, sources) {
   const merged = new Map(existingSources.map((source) => [source.key, source]));
@@ -7174,17 +7438,6 @@ function getGitCommit() {
     return;
   }
 }
-function stableJson(value) {
-  return JSON.stringify(sortJson(value));
-}
-function sortJson(value) {
-  if (Array.isArray(value))
-    return value.map(sortJson);
-  if (value && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, sortJson(item)]));
-  }
-  return value;
-}
 function sha256(input) {
   return createHash("sha256").update(input).digest("hex");
 }
@@ -7304,6 +7557,9 @@ function renderFixesBlock() {
     "- Propose the change in the code, prompt, tool definition, or skill that",
     "  causes the issue, and cite the Moda problem or trace ids it is based on",
     "  in the PR description.",
+    "- Prompts live in `.moda/prompts.yml` (version 2: `prompt_paths` globs plus",
+    "  `sources:` mappings for prompts defined in code); after `moda prompts sync`,",
+    "  pass `prompt: lock.prompts['<key>']` to createThinkTelemetry/createAI7Telemetry.",
     "- After the fix ships, record it with",
     "  `moda problem-feedback <problem_id> --action=mark_fixed`; if the issue",
     "  is detected again, the Problem comes back.",
@@ -8315,10 +8571,7 @@ async function buildDoctorReport(context, options) {
   });
   checks.push(harnessCurrentCheck(context.cwd, manifestPath, manifestExists, tenantId));
   checks.push(harnessSyncStateCheck(context.cwd));
-  checks.push(discoveryCheck("prompts_discovered", "harness", "Prompts are discovered", context.cwd, [
-    "prompts",
-    ".moda/prompts.yml"
-  ], "moda prompts init"));
+  checks.push(promptsDiscoveredCheck(context.cwd));
   checks.push(discoveryCheck("skills_discovered", "harness", "Skills are discovered", context.cwd, [
     "skills",
     ".claude/skills",
@@ -8588,6 +8841,56 @@ function harnessSyncStateCheck(cwd) {
     ]
   };
 }
+function promptsDiscoveredCheck(cwd) {
+  const base = { id: "prompts_discovered", group: "harness", title: "Prompts are discovered" };
+  if (!existsSync5(join4(cwd, ".moda", "prompts.yml"))) {
+    return discoveryCheck(base.id, base.group, base.title, cwd, ["prompts", ".moda/prompts.yml"], "moda prompts init");
+  }
+  let inspection;
+  try {
+    inspection = inspectPromptManifest(cwd);
+  } catch (error) {
+    return {
+      ...base,
+      status: "fail",
+      severity: "warning",
+      evidence: [{ label: "manifest", value: ".moda/prompts.yml" }, { label: "error", value: error instanceof Error ? error.message : String(error) }],
+      remediation: "Fix .moda/prompts.yml (version, prompt_paths, sources).",
+      nextCommand: "moda prompts status"
+    };
+  }
+  const evidence = [
+    { label: "manifest", value: `.moda/prompts.yml (version ${inspection.manifestVersion})` },
+    { label: "matched_files", value: String(inspection.matchedFiles) },
+    { label: "sources", value: String(inspection.sources) },
+    ...inspection.zeroMatchPatterns.length > 0 ? [{ label: "zero_match_patterns", value: inspection.zeroMatchPatterns.join(", ") }] : [],
+    ...inspection.legacyOnlyFiles.length > 0 ? [{
+      label: "legacy_only_files",
+      value: `${inspection.legacyOnlyFiles.length} (${inspection.legacyOnlyFiles.slice(0, 3).join(", ")}${inspection.legacyOnlyFiles.length > 3 ? ", ..." : ""})`
+    }] : []
+  ];
+  if (inspection.legacyOnlyFiles.length > 0) {
+    return {
+      ...base,
+      status: "warning",
+      severity: "warning",
+      evidence,
+      remediation: "Prompt files found by older CLIs no longer match the manifest globs (they are exact paths from the repository root). Migrate the manifest to keep them tracked under their existing keys.",
+      nextCommand: "moda prompts migrate --dry-run"
+    };
+  }
+  if (inspection.matchedFiles === 0 && inspection.sources === 0) {
+    return {
+      ...base,
+      status: "warning",
+      severity: "warning",
+      evidence,
+      remediation: "The prompt manifest matches no files and maps no sources, so sync registers nothing. Fix prompt_paths or preview source discovery.",
+      nextCommand: "moda prompts sync --dry-run"
+    };
+  }
+  return { ...base, status: "pass", severity: "info", evidence };
+}
 function discoveryCheck(id, group, title, cwd, relativePaths, nextCommand) {
   const found = relativePaths.filter((path) => existsSync5(join4(cwd, path)));
   return {
@@ -8884,7 +9187,7 @@ function agentPurposeForCommand(command) {
   return "Inspect or repair Moda setup.";
 }
 function stableGraphHash(graph) {
-  return createHash3("sha256").update(JSON.stringify(sortJson2({
+  return createHash3("sha256").update(JSON.stringify(sortJson({
     ...graph,
     scan: {
       ...graph.scan,
@@ -8894,11 +9197,11 @@ function stableGraphHash(graph) {
     }
   }))).digest("hex");
 }
-function sortJson2(value) {
+function sortJson(value) {
   if (Array.isArray(value))
-    return value.map((item) => sortJson2(item));
+    return value.map((item) => sortJson(item));
   if (value && typeof value === "object") {
-    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, sortJson2(item)]));
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, sortJson(item)]));
   }
   return value;
 }