@moda-ai/cli 1.55.94 → 1.55.96

package/dist/cli-92zfpz9f.js

@@ -0,0 +1,1037 @@
+import {
+  computePromptContentHash,
+  stableJson
+} from "./cli-mm48br00.js";
+import {
+  require_out
+} from "./cli-764m5azg.js";
+import {
+  createCommandContext
+} from "./cli-13zdcv4w.js";
+import {
+  assertFlags,
+  assertPositionals
+} from "./cli-6ga6kmdp.js";
+import {
+  callControlAPI
+} from "./cli-dxajrq9h.js";
+import {
+  CliInputError
+} from "./cli-k4tqwah4.js";
+import {
+  $isSeq,
+  $parseDocument,
+  $stringify
+} from "./cli-9kfxkxmk.js";
+import {
+  __require,
+  __toESM
+} from "./cli-0v6na3yp.js";
+
+// src/prompts.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+var promptSourcesModule;
+async function loadPromptSources() {
+  promptSourcesModule ??= await import("./prompt-sources-cyqr5m4h.js");
+  return promptSourcesModule;
+}
+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",
+  "prompts/**/*.prompt.yaml",
+  "prompts/**/*.prompt.yml"
+];
+var PROMPT_WRITE_SUBCOMMAND_FLAGS = {
+  init: ["from-harness"],
+  status: [],
+  diff: [],
+  migrate: ["dry-run", "discover"],
+  sync: [
+    "dry-run",
+    "from-harness",
+    "no-analyze",
+    "allow-untrack",
+    "watch",
+    "interval",
+    "analyst",
+    "assist",
+    "analyst-command",
+    "analyst-model"
+  ],
+  promote: ["label", "version", "version-id"]
+};
+async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
+  const context = Array.isArray(input) ? createCommandContext({
+    command: "prompts",
+    positional: input[0],
+    positionals: input,
+    flags: legacyFlags ?? {}
+  }, {
+    commandFlags: legacyFlags ?? {},
+    outputMode: legacyFlags?.agent === "true" ? "agent" : legacyFlags?.json === "true" ? "json" : "human",
+    env: legacyProfileOptions?.env
+  }) : input;
+  const positionals = context.positionals;
+  const flags = context.flags;
+  const profileOptions = legacyProfileOptions ?? { profile: context.profile, env: context.env };
+  const subcommand = positionals[0] || "status";
+  const writeFlags = PROMPT_WRITE_SUBCOMMAND_FLAGS[subcommand];
+  if (writeFlags)
+    assertFlags(`prompts ${subcommand}`, flags, writeFlags);
+  switch (subcommand) {
+    case "init": {
+      const imported = flags["from-harness"] ? await importHarnessPromptSources(flags["from-harness"]) : undefined;
+      const init = await initPrompts({ silent: true });
+      context.output.writeData({
+        manifest: MANIFEST_PATH,
+        manifestPath: init.manifestPath,
+        lockfile: LOCK_PATH,
+        lockPath: init.lockPath,
+        cwd: init.cwd,
+        created: init.created,
+        promptPaths: init.promptPaths,
+        imported
+      }, {
+        artifacts: [{
+          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": {
+      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 = existsSync(MANIFEST_PATH);
+      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({
+        ...status,
+        unchanged: status.total - differing.length,
+        prompts: differing,
+        ...tracked ? {} : { tracked: false }
+      }, {
+        summary: {
+          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"
+        },
+        ...diffWarnings.length > 0 ? { warnings: diffWarnings } : {}
+      });
+      break;
+    }
+    case "sync":
+      await syncPrompts(flags, profileOptions, context);
+      break;
+    case "promote":
+      await promotePrompt(positionals, flags, profileOptions, context);
+      break;
+    case "list":
+    case "show":
+    case "proposals":
+    case "usage":
+    case "decide":
+      await runPromptRegistryRead(subcommand, positionals, flags, profileOptions, context);
+      break;
+    default:
+      throw new CliInputError(`Unknown prompts command '${subcommand}'. Use init, status, diff, migrate, sync, promote, list, show, proposals, usage, or decide.`, undefined, "unknown_subcommand");
+  }
+  return 0;
+}
+async function initPrompts(options = {}) {
+  const cwd = process.cwd();
+  const manifestPath = resolve(cwd, MANIFEST_PATH);
+  const lockPath = resolve(cwd, LOCK_PATH);
+  if (existsSync(MODA_DIR) && lstatSync(MODA_DIR).isSymbolicLink())
+    throw new CliInputError(".moda must not be a symlink.");
+  mkdirSync(MODA_DIR, { recursive: true });
+  let created = false;
+  if (!existsSync(MANIFEST_PATH)) {
+    assertContainedSource(cwd, MODA_DIR);
+    try {
+      writeFileSync(manifestPath, ["version: 2", "prompt_paths:", ...DEFAULT_PROMPT_PATHS.map((path) => `  - "${path}"`), "sources: []", ""].join(`
+`), { flag: "wx" });
+      created = true;
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+  }
+  if (!existsSync(manifestPath)) {
+    throw new Error(`Could not write ${manifestPath}: the file is missing after init. Check directory permissions and available disk space.`);
+  }
+  const result = {
+    manifestPath,
+    lockPath,
+    cwd,
+    created,
+    promptPaths: readManifest().promptPaths
+  };
+  if (!options.silent) {
+    printJson({
+      manifest: MANIFEST_PATH,
+      manifestPath,
+      lockfile: LOCK_PATH,
+      lockPath,
+      cwd,
+      created: result.created,
+      promptPaths: result.promptPaths
+    });
+  }
+  return result;
+}
+async function syncPrompts(flags, profileOptions, context) {
+  if (flags.watch === "true") {
+    await watchPromptSync(flags, profileOptions);
+    return;
+  }
+  await syncPromptsOnce(flags, profileOptions, context);
+}
+async function runPromptSync(flags, profileOptions, options = {}) {
+  if (flags["dry-run"] === "true")
+    return runPromptSyncExclusive(flags, profileOptions, options);
+  mkdirSync(dirname(MANIFEST_PATH), { recursive: true });
+  const syncLock = resolve(dirname(MANIFEST_PATH), "prompts.sync.lock");
+  try {
+    mkdirSync(syncLock);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new Error(`Another prompt sync owns ${syncLock}. Wait for it to finish. If it crashed, remove this directory only after confirming no sync is running.`);
+    }
+    throw error;
+  }
+  try {
+    return await runPromptSyncExclusive(flags, profileOptions, options);
+  } finally {
+    rmSync(syncLock, { recursive: true, force: true });
+  }
+}
+async function runPromptSyncExclusive(flags, profileOptions, options) {
+  let harnessImport;
+  if (flags["from-harness"] && flags["dry-run"] !== "true")
+    harnessImport = await importHarnessPromptSources(flags["from-harness"]);
+  if (flags["dry-run"] !== "true")
+    await initPrompts({ silent: true });
+  const manifest = readManifest();
+  const originalManifestHash = hashFile(MANIFEST_PATH);
+  let extraSources = [];
+  if (flags["from-harness"] && flags["dry-run"] === "true") {
+    const read = await readHarnessSources(flags["from-harness"]);
+    extraSources = read.sources;
+    harnessImport = read.result;
+  }
+  mergePromptSources(manifest.sources, extraSources);
+  const established = await 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-jka07f99.js");
+    const result = await analyzeHarnessPrompts({
+      rootDir: process.cwd(),
+      existing: established.flatMap((prompt) => prompt.sourceDefinition ? [prompt.sourceDefinition.source] : []),
+      flags,
+      env: profileOptions.env ?? process.env,
+      dryRun: flags["dry-run"] === "true",
+      onProgress: options.onProgress
+    });
+    const legacyPaths = new Set(established.filter((prompt) => !prompt.sourceDefinition).map((prompt) => resolve(prompt.sourcePath)));
+    const exclusions = manifest.promptPaths.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
+    const excludedPaths = new Set(exclusions.length ? import_fast_glob.default.sync(exclusions, { cwd: process.cwd(), onlyFiles: true, dot: true, followSymbolicLinks: false }).map((path) => resolve(path)) : []);
+    const found = result.sources.filter((source) => !legacyPaths.has(resolve(source.path)) && !excludedPaths.has(resolve(source.path)));
+    for (const source of found) {
+      const analyzed = result.resolved.find((item) => item.key === source.key);
+      if (!analyzed)
+        throw new Error(`Prompt discovery omitted resolved source '${source.key}'.`);
+      analyzedDefinitions.set(source.key, stableJson(analyzed.sourceDefinition));
+    }
+    extraSources = mergePromptSources(extraSources, found);
+    const { resolved: _resolved, ...diagnostics } = result;
+    discovery = { ...diagnostics, sources: found };
+  }
+  if (originalManifestHash !== hashFile(MANIFEST_PATH))
+    throw new Error("Prompt manifest changed during analysis. Retry with a stable checkout.");
+  const mergedSources = mergePromptSources(manifest.sources, extraSources);
+  const manifestUpdate = stableJson(mergedSources) === stableJson(mergePromptSources(manifest.sources, [])) ? undefined : $stringify({ version: 2, prompt_paths: manifest.promptPaths, sources: mergedSources });
+  const prompts = await discoverPrompts(extraSources);
+  const { checkPromptAttribution } = await import("./prompt-attribution-armk5gqt.js");
+  const attribution = checkPromptAttribution(process.cwd(), prompts.map((prompt) => prompt.key));
+  const brokenAttribution = attribution.references.filter((reference) => reference.status === "missing");
+  if (brokenAttribution.length) {
+    throw new CliInputError(`Prompt attribution keys are absent from this sync: ${brokenAttribution.map((reference) => `'${reference.key}' at ${reference.path}:${reference.line}`).join(", ")}. Map the referenced key to its verified source in .moda/prompts.yml, or update the runtime lookup to the intended mapped key. No prompt versions were uploaded.`);
+  }
+  for (const prompt of prompts) {
+    const analyzed = analyzedDefinitions.get(prompt.key);
+    if (analyzed && analyzed !== stableJson(prompt.sourceDefinition))
+      throw new Error("Prompt source changed after analysis. Retry with a stable checkout.");
+  }
+  const previous = readLock();
+  const previousLockHash = hashFile(LOCK_PATH);
+  const missing = Object.keys(previous?.prompts ?? {}).filter((key) => !prompts.some((prompt) => prompt.key === key));
+  if (missing.length && flags["allow-untrack"] !== "true") {
+    throw new CliInputError(`Previously synced prompts are absent: ${missing.join(", ")}. Restore their sources, or use --allow-untrack to explicitly remove local tracking.`);
+  }
+  const sourceCommit = getGitCommit();
+  const manifestHash = manifestUpdate === undefined ? originalManifestHash : sha256(manifestUpdate);
+  const dryRun = flags["dry-run"] === "true";
+  if (prompts.length === 0) {
+    if (!dryRun && flags["allow-untrack"] === "true")
+      writeLock([], []);
+    return { synced: [], dryRun, discovery, attribution, ...harnessImport ? { harnessImport } : {} };
+  }
+  const signature = stableJson(prompts);
+  const response = await callControlAPI("/prompts/sync", {
+    method: "POST",
+    body: JSON.stringify({
+      prompts: prompts.map((prompt) => ({
+        ...prompt,
+        sourceCommit,
+        manifestHash
+      })),
+      sourceCommit,
+      manifestHash,
+      dryRun
+    })
+  }, profileOptions);
+  if (signature !== stableJson(await discoverPrompts(extraSources)) || originalManifestHash !== hashFile(MANIFEST_PATH)) {
+    throw new Error("Prompt sources changed during sync. Remote writes may have completed; the prior lockfile was preserved. Retry with a stable checkout.");
+  }
+  const synced = response.synced;
+  if (!Array.isArray(synced) || synced.length !== prompts.length || new Set(synced.map((row) => row.key)).size !== prompts.length || prompts.some((prompt) => !synced.some((row) => row.key === prompt.key && row.promptId && row.versionId && row.contentHash === prompt.contentHash))) {
+    throw new Error("Prompt sync returned incomplete or mismatched versions. Remote writes may have completed; the prior lockfile was preserved.");
+  }
+  if (!dryRun) {
+    if (hashFile(LOCK_PATH) !== previousLockHash)
+      throw new Error("Prompt lockfile changed during sync. Another writer may have synced concurrently; its lockfile was preserved. Retry.");
+    if (originalManifestHash !== hashFile(MANIFEST_PATH))
+      throw new Error("Prompt manifest changed during sync. Retry with a stable checkout.");
+    if (manifestUpdate !== undefined)
+      atomicWrite(MANIFEST_PATH, manifestUpdate);
+    writeLock(prompts, synced);
+  }
+  return { synced: response.synced ?? [], dryRun, discovery, attribution, ...harnessImport ? { harnessImport } : {} };
+}
+function writePromptSyncProgress(message, context, quiet = false) {
+  if (quiet || context?.quiet)
+    return;
+  if (context?.outputMode === "agent-stream") {
+    context.output.writeEvent({ event: "progress", phase: "prompt_discovery", message, elapsed_ms: Date.now() - context.startedAt });
+  } else {
+    process.stderr.write(`[moda prompts] ${message.replace(/[\x00-\x1f\x7f]/g, " ")}
+`);
+  }
+}
+async function syncPromptsOnce(flags, profileOptions, context) {
+  const result = await runPromptSync(flags, profileOptions, {
+    onProgress: (message) => writePromptSyncProgress(message, context, flags.quiet === "true")
+  });
+  const payload = {
+    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, skippedWarning.length ? { warnings: skippedWarning } : undefined);
+  else
+    printJson(payload);
+  if (!result.dryRun && result.synced.length === 0 && result.discovery?.candidates?.length) {
+    writePromptSyncProgress("No eligible prompt sources were synced. Review discovery.pending and discovery.related.", context, flags.quiet === "true");
+    process.exitCode = 1;
+  }
+}
+async function watchPromptSync(flags, profileOptions) {
+  await syncPromptsOnce(flags, profileOptions);
+  console.error("Watching mapped prompt files. Press Ctrl+C to stop.");
+  let lastSignature = "";
+  const intervalMs = Math.max(1000, Number(flags.interval ?? 2500));
+  while (true) {
+    const status = await getPromptStatus();
+    const signature = stableJson(status.prompts);
+    if (signature !== lastSignature) {
+      lastSignature = signature;
+      if (status.changed > 0 || status.new > 0 || status.deleted > 0) {
+        await syncPromptsOnce({ ...flags, watch: "false", "no-analyze": "true" }, profileOptions);
+      }
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+  }
+}
+async function promotePrompt(positionals, flags, profileOptions, context) {
+  const key = positionals[1];
+  const label = flags.label;
+  const versionId = flags.version || flags["version-id"];
+  if (!key)
+    throw new CliInputError("Usage: moda prompts promote <prompt_key> --label=prod --version=<version_id>", undefined, "missing_positional");
+  if (!label)
+    throw new CliInputError("Missing required flag: --label=dev|staging|prod");
+  if (!versionId)
+    throw new CliInputError("Missing required flag: --version=<version_id>");
+  const response = await callControlAPI(`/prompts/${encodeURIComponent(key)}/labels`, {
+    method: "POST",
+    body: JSON.stringify({ label, versionId })
+  }, profileOptions);
+  context.output.writeData(response);
+}
+async function getPromptStatus() {
+  const prompts = await discoverPrompts();
+  const lock = readLock();
+  const rows = prompts.map((prompt) => {
+    const locked = lock?.prompts[prompt.key];
+    const state = !locked ? "new" : locked.contentHash === prompt.contentHash ? "unchanged" : "changed";
+    return {
+      key: prompt.key,
+      sourcePath: prompt.sourcePath,
+      contentHash: prompt.contentHash,
+      lockedHash: locked?.contentHash ?? null,
+      versionId: locked?.versionId ?? null,
+      state
+    };
+  });
+  const discoveredKeys = new Set(prompts.map((prompt) => prompt.key));
+  for (const [key, locked] of Object.entries(lock?.prompts ?? {})) {
+    if (!discoveredKeys.has(key)) {
+      rows.push({
+        key,
+        sourcePath: locked.sourcePath,
+        contentHash: null,
+        lockedHash: locked.contentHash,
+        versionId: locked.versionId ?? null,
+        state: "deleted"
+      });
+    }
+  }
+  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,
+    deleted: rows.filter((row) => row.state === "deleted").length,
+    prompts: rows
+  };
+}
+async function discoverPrompts(extraSources = []) {
+  return discoverManifestPrompts(readManifest(), extraSources);
+}
+var NATIVE_PROMPT_FILE_RE = /\.prompt\.(md|json)$/i;
+async function discoverManifestPrompts(manifest, extraSources = []) {
+  const root = process.cwd();
+  for (const pattern of manifest.promptPaths) {
+    const positive = pattern.startsWith("!") ? pattern.slice(1) : pattern;
+    if (isAbsolute(positive) || positive.split(/[\\/]/).includes(".."))
+      throw new CliInputError(`Prompt pattern must stay inside the repository: ${pattern}`);
+    if (!pattern.startsWith("!") && !import_fast_glob.default.isDynamicPattern(pattern) && !existsSync(resolve(root, pattern))) {
+      throw new CliInputError(`Configured prompt file is missing: ${pattern}`);
+    }
+  }
+  const paths = import_fast_glob.default.sync(manifest.promptPaths, {
+    cwd: root,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    dot: true,
+    unique: true,
+    ignore: DISCOVERY_IGNORE
+  }).sort();
+  const sources = new Map(manifest.sources.map((source) => [source.key, source]));
+  for (const source of extraSources)
+    sources.set(source.key, source);
+  const selectedPaths = new Set([...sources.values()].map((source) => resolve(root, source.path)));
+  const owned = paths.filter((path) => !selectedPaths.has(resolve(root, path)));
+  const resolver = sources.size > 0 || owned.some((path) => !NATIVE_PROMPT_FILE_RE.test(path)) ? (await loadPromptSources()).resolvePromptSource : undefined;
+  const prompts = owned.map((path) => {
+    assertContainedSource(root, path);
+    if (NATIVE_PROMPT_FILE_RE.test(path))
+      return parsePromptFile(resolve(root, path));
+    return normalizePrompt(resolver(root, { key: keyFromPath(path), path }));
+  });
+  for (const source of sources.values())
+    prompts.push(normalizePrompt(resolver(root, source)));
+  const seen = new Set;
+  for (const prompt of prompts) {
+    if (seen.has(prompt.key))
+      throw new CliInputError(`Duplicate prompt key '${prompt.key}'. Give each source a unique stable key.`);
+    seen.add(prompt.key);
+  }
+  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, resolve(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) => !isAbsolute(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 = resolve(root, LOCK_PATH);
+  if (!existsSync(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 = resolve(root, MANIFEST_PATH);
+  if (!existsSync(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-jka07f99.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 {
+    await 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 = resolve(root, path);
+  const rel = relative(realpathSync(root), realpathSync(abs));
+  if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel))
+    throw new CliInputError(`Prompt source escapes repository: ${path}`);
+  let cursor = abs;
+  while (cursor !== resolve(root)) {
+    if (lstatSync(cursor).isSymbolicLink())
+      throw new CliInputError(`Prompt source uses a symlink: ${path}`);
+    const next = dirname(cursor);
+    if (next === cursor)
+      throw new CliInputError(`Prompt source escapes repository: ${path}`);
+    cursor = next;
+  }
+}
+function parsePromptFile(absPath) {
+  const sourcePath = relative(process.cwd(), absPath);
+  const raw = readFileSync(absPath, "utf8");
+  if (absPath.endsWith(".json")) {
+    const document = $parseDocument(raw, { uniqueKeys: true });
+    if (document.errors.length)
+      throw new CliInputError(`${sourcePath}: ${document.errors[0].message}`);
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch (err) {
+      throw new CliInputError(`${sourcePath}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const key2 = parsed.key || keyFromPath(sourcePath);
+    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 CliInputError(`${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);
+  const key = frontmatter.key || keyFromPath(sourcePath);
+  return normalizePrompt({
+    key,
+    name: frontmatter.name || key,
+    description: frontmatter.description,
+    category: frontmatter.category,
+    systemPrompt: frontmatter.system_prompt || frontmatter.systemPrompt,
+    modelConfig: frontmatter.model ? { model: frontmatter.model } : undefined,
+    sourcePath,
+    content: body.trim()
+  });
+}
+function normalizePrompt(prompt) {
+  return {
+    key: prompt.key,
+    name: prompt.name || prompt.key,
+    description: prompt.description,
+    sourcePath: prompt.sourcePath,
+    sourceDefinition: prompt.sourceDefinition,
+    content: prompt.content,
+    systemPrompt: prompt.systemPrompt,
+    messages: prompt.messages,
+    variables: prompt.variables,
+    variablesSchema: prompt.variablesSchema,
+    modelConfig: prompt.modelConfig,
+    toolRefs: prompt.toolRefs,
+    responseSchema: prompt.responseSchema,
+    contentHash: computePromptContentHash(prompt)
+  };
+}
+function readManifest(root = process.cwd()) {
+  if (!existsSync(resolve(root, MANIFEST_PATH)))
+    return { version: null, promptPaths: DEFAULT_PROMPT_PATHS, sources: [] };
+  assertContainedSource(root, MANIFEST_PATH);
+  const doc = $parseDocument(readFileSync(resolve(root, MANIFEST_PATH), "utf8"), { uniqueKeys: true });
+  if (doc.errors.length)
+    throw new CliInputError(`Invalid ${MANIFEST_PATH}: ${doc.errors[0].message}`);
+  const parsed = doc.toJS({ maxAliasCount: 20 });
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || ![1, 2].includes(parsed.version))
+    throw new CliInputError(`${MANIFEST_PATH} requires version: 1 or 2.`);
+  if (Object.keys(parsed).some((key) => !["version", "prompt_paths", "sources"].includes(key)))
+    throw new CliInputError("Unknown prompt manifest field. Use version, prompt_paths, and sources.");
+  if (parsed.prompt_paths !== undefined && (!Array.isArray(parsed.prompt_paths) || parsed.prompt_paths.some((p) => typeof p !== "string" || !p.trim())))
+    throw new CliInputError("prompt_paths must be an array of nonempty patterns.");
+  if (parsed.sources !== undefined && !Array.isArray(parsed.sources))
+    throw new CliInputError("sources must be an array of prompt source descriptors.");
+  const sources = parsed.sources ?? [];
+  const seen = new Set;
+  for (const source of sources) {
+    if (!source || typeof source.key !== "string" || !source.key.trim() || typeof source.path !== "string" || !source.path.trim())
+      throw new CliInputError("Every prompt source requires a stable key and path.");
+    if (seen.has(source.key))
+      throw new CliInputError(`Duplicate prompt source key '${source.key}'.`);
+    seen.add(source.key);
+  }
+  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";
+async function readHarnessSources(reportPath) {
+  const selected = reportPath === "true" ? ".moda/harness-report.json" : reportPath;
+  assertContainedSource(process.cwd(), selected);
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(resolve(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 { normalizeHarnessReport } = await import("./harness-report-hn2aarv2.js");
+  const { backfillPromptSource, resolvePromptSource } = await loadPromptSources();
+  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) {
+    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(resolve(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}.`);
+  }
+  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.`;
+}
+async function importHarnessPromptSources(reportPath = ".moda/harness-report.json") {
+  const { sources, result } = await readHarnessSources(reportPath);
+  const manifest = readManifest();
+  const merged = mergePromptSources(manifest.sources, sources);
+  await discoverPrompts(sources);
+  atomicWrite(MANIFEST_PATH, $stringify({ version: 2, prompt_paths: manifest.promptPaths, sources: merged }));
+  return result;
+}
+function mergePromptSources(existingSources, sources) {
+  const merged = new Map(existingSources.map((source) => [source.key, source]));
+  for (const source of sources) {
+    const existing = merged.get(source.key);
+    if (existing && stableJson(existing) !== stableJson(source)) {
+      throw new CliInputError(`Harness source '${source.key}' conflicts with an existing mapping. Edit ${MANIFEST_PATH} explicitly to change its source; no mappings were imported.`);
+    }
+    merged.set(source.key, source);
+  }
+  return [...merged.values()].sort((a, b) => a.key.localeCompare(b.key));
+}
+function atomicWrite(path, content) {
+  mkdirSync(dirname(path), { recursive: true });
+  assertContainedSource(process.cwd(), dirname(path));
+  if (existsSync(path) && lstatSync(path).isSymbolicLink())
+    throw new CliInputError(`Refusing to overwrite symlink: ${path}`);
+  const temp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync(temp, content, { flag: "wx" });
+    renameSync(temp, path);
+  } finally {
+    rmSync(temp, { force: true });
+  }
+}
+function readLock() {
+  if (!existsSync(LOCK_PATH))
+    return null;
+  assertContainedSource(process.cwd(), LOCK_PATH);
+  return JSON.parse(readFileSync(LOCK_PATH, "utf8"));
+}
+function writeLock(prompts, synced) {
+  const syncedByKey = new Map(synced.map((item) => [item.key, item]));
+  const lock = {
+    version: 1,
+    generatedAt: new Date().toISOString(),
+    prompts: Object.fromEntries(prompts.map((prompt) => {
+      const result = syncedByKey.get(prompt.key);
+      return [prompt.key, {
+        key: prompt.key,
+        sourcePath: prompt.sourcePath,
+        contentHash: prompt.contentHash,
+        promptId: result?.promptId,
+        versionId: result?.versionId
+      }];
+    }))
+  };
+  mkdirSync(dirname(LOCK_PATH), { recursive: true });
+  atomicWrite(LOCK_PATH, `${JSON.stringify(lock, null, 2)}
+`);
+}
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---"))
+    return { frontmatter: {}, body: raw };
+  const end = raw.indexOf(`
+---`, 3);
+  if (end === -1)
+    return { frontmatter: {}, body: raw };
+  const frontmatterText = raw.slice(3, end).trim();
+  const frontmatter = Object.fromEntries(frontmatterText.split(`
+`).map((line) => line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/)).filter((match) => Boolean(match)).map((match) => [match[1], match[2].replace(/^["']|["']$/g, "")]));
+  return { frontmatter, body: raw.slice(end + 4) };
+}
+function keyFromPath(path) {
+  return path.replace(/^prompts\//, "").replace(/(?:\.prompt)?\.(md|txt|json|ya?ml|jinja2?|j2|hbs|tmpl|prompt)$/i, "").replace(/[\\/]/g, ".");
+}
+function hashFile(path) {
+  return existsSync(path) ? sha256(readFileSync(path, "utf8")) : "";
+}
+function getGitCommit() {
+  try {
+    return execFileSync("git", ["rev-parse", "HEAD"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return;
+  }
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+var PROMPT_LABELS = ["prod", "staging", "dev"];
+async function runPromptRegistryRead(subcommand, positionals, flags, profileOptions, context) {
+  const allowed = {
+    list: ["label", "search"],
+    show: [],
+    proposals: [],
+    usage: [],
+    decide: ["action", "dry-run"]
+  };
+  assertFlags(`prompts ${subcommand}`, flags, allowed[subcommand] ?? []);
+  const maxPositionals = subcommand === "list" ? 1 : subcommand === "decide" ? 3 : 2;
+  assertPositionals(`prompts ${subcommand}`, positionals, maxPositionals, `moda prompts ${subcommand}${subcommand === "list" ? "" : " <key>"}${subcommand === "decide" ? " <proposal_id> --action=merge|reject|reopen" : ""}`);
+  const keyOrId = positionals[1];
+  const needKey = (usage) => {
+    if (!keyOrId)
+      throw new CliInputError("<prompt key or id> is required.", `Usage: ${usage}`);
+    return encodeURIComponent(keyOrId);
+  };
+  switch (subcommand) {
+    case "list": {
+      const label = flags.label;
+      if (label && label !== "unlabeled" && !PROMPT_LABELS.includes(label)) {
+        throw new CliInputError(`--label must be one of ${PROMPT_LABELS.join(", ")}, or unlabeled.`);
+      }
+      const response = asRecordValue(await callControlAPI("/prompts", {}, profileOptions));
+      const all = Array.isArray(response.prompts) ? response.prompts.map(asRecordValue) : [];
+      const search = flags.search?.toLowerCase();
+      const prompts = all.filter((prompt) => {
+        if (search && !`${prompt.key ?? ""} ${prompt.name ?? ""} ${prompt.description ?? ""}`.toLowerCase().includes(search))
+          return false;
+        if (!label)
+          return true;
+        const labelField = (name) => name === "dev" ? prompt.currentVersion ?? prompt.current_version : prompt[`${name}Version`] ?? prompt[`${name}_version`];
+        const labels = PROMPT_LABELS.filter((name) => labelField(name));
+        return label === "unlabeled" ? labels.length === 0 : labels.includes(label);
+      });
+      context.output.writeData({ prompts, total: prompts.length, ...label || search ? { filtered_from: all.length } : {} });
+      return;
+    }
+    case "show":
+      context.output.writeData(await callControlAPI(`/prompts/${needKey("moda prompts show <key>")}`, {}, profileOptions));
+      return;
+    case "proposals":
+      context.output.writeData(await callControlAPI(`/prompts/${needKey("moda prompts proposals <key>")}/proposals`, {}, profileOptions));
+      return;
+    case "usage":
+      context.output.writeData(await callControlAPI(`/prompts/${needKey("moda prompts usage <key>")}/usage`, {}, profileOptions));
+      return;
+    case "decide": {
+      const usage = "moda prompts decide <key> <proposal_id> --action=merge|reject|reopen";
+      const id = needKey(usage);
+      const proposalId = positionals[2];
+      const action = flags.action;
+      if (!proposalId)
+        throw new CliInputError("<proposal_id> is required.", `Usage: ${usage}`);
+      if (!action || !["merge", "reject", "reopen"].includes(action)) {
+        throw new CliInputError("--action must be merge, reject, or reopen.", `Usage: ${usage}`);
+      }
+      if (context.dryRun) {
+        context.output.writeData({ dryRun: true, planned: { method: "PATCH", endpoint: `/api/prompts/${id}/proposals/${encodeURIComponent(proposalId)}`, body: { action } } });
+        return;
+      }
+      context.output.writeData(await callControlAPI(`/prompts/${id}/proposals/${encodeURIComponent(proposalId)}`, { method: "PATCH", body: JSON.stringify({ action }) }, profileOptions, { retries: 0 }));
+      return;
+    }
+  }
+}
+function asRecordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+
+export { runPromptsCommand, initPrompts, runPromptSync, writePromptSyncProgress, discoverPrompts, inspectPromptManifest, promptManifestWarnings, migratePromptManifest, parsePromptFile, importHarnessPromptSources };