@moda-ai/cli 1.55.108 → 1.55.110

package/dist/cli-h7hfpmwa.js

@@ -1,1019 +0,0 @@
-import {
-  SKILL_SOURCE_HARNESS,
-  SKILL_SOURCE_INTEGRATION_BUNDLED,
-  pruneManagedSkillPaths,
-  readSkillsManifest,
-  writeSkillsManifest
-} from "./cli-qm5b1vck.js";
-import {
-  detectAgents
-} from "./cli-rjav0vj1.js";
-import {
-  claudeSkillToCursorRule
-} from "./cli-hcwdz9sd.js";
-import {
-  createCommandContext
-} from "./cli-13zdcv4w.js";
-import {
-  assertFlags,
-  assertPositionals,
-  writeDryRun
-} from "./cli-2bhhk2nn.js";
-import {
-  callControlAPI
-} from "./cli-n9ng8mym.js";
-import {
-  recordApiRequest,
-  resolveApiKey,
-  resolveIngestUrl,
-  resolveTenantId,
-  shellArg
-} from "./cli-1nd4339b.js";
-import {
-  CliInputError
-} from "./cli-k4tqwah4.js";
-import {
-  __require
-} from "./cli-0v6na3yp.js";
-
-// src/skills.ts
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import {
-  existsSync as existsSync2,
-  lstatSync as lstatSync2,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  readFileSync as readFileSync2,
-  writeFileSync as writeFileSync2
-} from "node:fs";
-import { basename, dirname as dirname2, join as join2, relative } from "node:path";
-
-// src/agents-md.ts
-import { existsSync, lstatSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-var AGENTS_MD_FILENAME = "AGENTS.md";
-var FIXES_BLOCK_BEGIN = "<!-- moda:fixes:begin -->";
-var FIXES_BLOCK_END = "<!-- moda:fixes:end -->";
-function renderFixesBlock() {
-  return [
-    FIXES_BLOCK_BEGIN,
-    "## Fixing production issues with Moda (managed block — edits inside are overwritten by moda-cli)",
-    "",
-    "Moda supplies the production evidence; you propose and make the fix yourself.",
-    "The `moda` CLI needs `MODA_API_KEY` (or `npx -y -p @moda-ai/cli moda ...` when",
-    "not installed); `moda <command> --help` lists its flags.",
-    "",
-    '- Find where something happened in production: `moda traces search "<words>"`, then',
-    "  `moda traces get <conversation_id> --msg-index=<message_index>` to read the turn.",
-    "- Find what to fix: `moda investigate` ranks tool failures, user frustrations,",
-    "  and top Problems with evidence; `moda problems` ranks cross-signal Problems",
-    "  by root cause; `moda failures` lists tool failures only.",
-    "- Read the evidence before editing: `moda problems get <problem_id>` (dossier),",
-    "  `moda problems get <problem_id> --evidence` (attribution rationales and anchors),",
-    "  `moda problems get <problem_id> --traces` (affected traces),",
-    "  `moda detections tools <tool_name>` (failing calls in context), and",
-    "  `moda traces get <conversation_id>` (the messages around a turn; `--all` for",
-    "  the whole trace).",
-    "- 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 problems feedback <problem_id> --action=mark_fixed`; if the issue",
-    "  is detected again, the Problem comes back.",
-    FIXES_BLOCK_END
-  ].join(`
-`);
-}
-function countOccurrences(text, needle) {
-  return text.split(needle).length - 1;
-}
-function upsertManagedBlock(existing, block) {
-  if (existing === null) {
-    return { ok: true, content: `${block}
-` };
-  }
-  const begins = countOccurrences(existing, FIXES_BLOCK_BEGIN);
-  const ends = countOccurrences(existing, FIXES_BLOCK_END);
-  if (begins === 0 && ends === 0) {
-    const separator = existing === "" || existing.endsWith(`
-
-`) ? "" : existing.endsWith(`
-`) ? `
-` : `
-
-`;
-    return { ok: true, content: `${existing}${separator}${block}
-` };
-  }
-  const beginIdx = existing.indexOf(FIXES_BLOCK_BEGIN);
-  const endIdx = existing.indexOf(FIXES_BLOCK_END);
-  if (begins === 1 && ends === 1 && endIdx > beginIdx) {
-    const before = existing.slice(0, beginIdx);
-    const after = existing.slice(endIdx + FIXES_BLOCK_END.length);
-    return { ok: true, content: `${before}${block}${after}` };
-  }
-  const problem = begins === 1 && ends === 1 ? `its ${FIXES_BLOCK_END} marker comes before its ${FIXES_BLOCK_BEGIN} marker` : `it has ${begins} ${FIXES_BLOCK_BEGIN} and ${ends} ${FIXES_BLOCK_END} marker(s) instead of one of each`;
-  return {
-    ok: false,
-    reason: `The Moda block in ${AGENTS_MD_FILENAME} was not updated because ${problem}. ` + "The file was left unchanged so no text is lost. Keep exactly one begin marker followed by one end marker " + "(or delete the stray markers), then rerun `moda skills install moda-cli` (or `moda skills push`)."
-  };
-}
-function writeFileIfChanged(filePath, content) {
-  try {
-    mkdirSync(dirname(filePath), { recursive: true });
-    if (existsSync(filePath)) {
-      const current = readFileSync(filePath, "utf8");
-      if (current === content)
-        return { status: "unchanged" };
-      writeFileSync(filePath, content);
-      return { status: "updated" };
-    }
-    writeFileSync(filePath, content);
-    return { status: "wrote" };
-  } catch (err) {
-    return { status: "failed", error: err instanceof Error ? err.message : String(err) };
-  }
-}
-function upsertFixesAgentsBlock(cwd) {
-  const filePath = join(cwd, AGENTS_MD_FILENAME);
-  let existing = null;
-  try {
-    if (lstatSync(filePath).isSymbolicLink()) {
-      return { path: AGENTS_MD_FILENAME, status: "skipped", reason: "AGENTS.md is a symlink and was left unchanged. Update the linked file manually, or replace the link with a project file and rerun `moda skills install moda-cli`." };
-    }
-  } catch (err) {
-    if (err.code !== "ENOENT") {
-      return { path: AGENTS_MD_FILENAME, status: "failed", reason: `Could not inspect ${AGENTS_MD_FILENAME}: ${err instanceof Error ? err.message : String(err)}` };
-    }
-  }
-  if (existsSync(filePath)) {
-    try {
-      existing = readFileSync(filePath, "utf8");
-    } catch (err) {
-      return {
-        path: AGENTS_MD_FILENAME,
-        status: "failed",
-        reason: `Could not read ${AGENTS_MD_FILENAME}: ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-  }
-  const next = upsertManagedBlock(existing, renderFixesBlock());
-  if (!next.ok)
-    return { path: AGENTS_MD_FILENAME, status: "skipped", reason: next.reason };
-  const written = writeFileIfChanged(filePath, next.content);
-  return {
-    path: AGENTS_MD_FILENAME,
-    status: written.status,
-    ...written.error ? { reason: `Could not write ${AGENTS_MD_FILENAME}: ${written.error}` } : {}
-  };
-}
-function agentsMdProblem(agentsMd) {
-  if (!agentsMd || agentsMd.status !== "skipped" && agentsMd.status !== "failed")
-    return;
-  return agentsMd.reason ?? `The Moda block in ${agentsMd.path} could not be updated.`;
-}
-
-// src/skills.ts
-var SKILLS_REQUEST_TIMEOUT_MS = 15000;
-var VALID_STATUSES = new Set(["approved", "proposed", "all"]);
-var SKILL_PROPOSALS_MANIFEST_PATH = join2(".moda", "skill-proposals.yml");
-async function fetchSkills(status) {
-  const apiKey = resolveApiKey();
-  if (!apiKey) {
-    throw new CliInputError("No Moda API key found. Run `moda init` first (or set MODA_API_KEY).");
-  }
-  const ingestUrl = resolveIngestUrl().replace(/\/$/, "");
-  const url = `${ingestUrl}/v1/skills?status=${encodeURIComponent(status)}`;
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), SKILLS_REQUEST_TIMEOUT_MS);
-  let response;
-  try {
-    recordApiRequest();
-    response = await fetch(url, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: controller.signal
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Network error: failed to reach ${ingestUrl} (${message})`);
-  } finally {
-    clearTimeout(timeout);
-  }
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    throw new Error(`Failed to fetch skills (HTTP ${response.status}): ${body.slice(0, 200)}`);
-  }
-  const data = await response.json();
-  if (!data.success) {
-    throw new Error(data.message || "Failed to fetch skills");
-  }
-  const skills = Array.isArray(data.skills) ? data.skills : [];
-  const release = data.release && typeof data.release === "object" ? data.release : null;
-  return {
-    skills,
-    tenantId: data.tenant_id || resolveTenantId() || "",
-    release,
-    releaseKey: releaseKeyFor(release, skills, status),
-    status
-  };
-}
-async function skillRunsRequest(url) {
-  const apiKey = resolveApiKey();
-  if (!apiKey) {
-    throw new CliInputError("No Moda API key found. Run `moda init` first (or set MODA_API_KEY).");
-  }
-  const controller = new AbortController;
-  const timeout = setTimeout(() => controller.abort(), SKILLS_REQUEST_TIMEOUT_MS);
-  let response;
-  try {
-    recordApiRequest();
-    response = await fetch(url, {
-      headers: { Authorization: `Bearer ${apiKey}` },
-      signal: controller.signal
-    });
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`Network error: failed to reach ${url} (${message})`);
-  } finally {
-    clearTimeout(timeout);
-  }
-  const text = await response.text().catch(() => "");
-  if (!response.ok && response.status !== 404) {
-    throw new Error(`Failed to fetch run status (HTTP ${response.status}): ${text.slice(0, 200)}`);
-  }
-  let body = {};
-  try {
-    body = text ? JSON.parse(text) : {};
-  } catch {
-    body = {};
-  }
-  return { status: response.status, body };
-}
-async function fetchSkillRunStatus(runId) {
-  const ingestUrl = resolveIngestUrl().replace(/\/$/, "");
-  let resolvedRunId = runId;
-  if (!resolvedRunId) {
-    const list = await skillRunsRequest(`${ingestUrl}/v1/skills/runs?limit=1`);
-    const listBody = list.body;
-    const latest = Array.isArray(listBody.runs) ? listBody.runs[0] : undefined;
-    if (!latest)
-      return { run: null, events: [] };
-    resolvedRunId = latest.generation_run_id;
-    if (!resolvedRunId)
-      return { run: latest, events: [] };
-  }
-  const detail = await skillRunsRequest(`${ingestUrl}/v1/skills/runs/${encodeURIComponent(resolvedRunId)}`);
-  if (detail.status === 404) {
-    if (runId) {
-      throw new CliInputError(`No skill generation run found with id '${runId}'`);
-    }
-    return { run: null, events: [] };
-  }
-  const detailBody = detail.body;
-  return {
-    run: detailBody.run ?? null,
-    events: Array.isArray(detailBody.events) ? detailBody.events : []
-  };
-}
-var STATUS_HUMAN_EVENT_LIMIT = 10;
-function formatRunStatusHuman(run, events) {
-  const counters = run.counters ?? {};
-  const lines = [
-    run.generation_run_id && `run: ${run.generation_run_id}`,
-    `status: ${run.status || "unknown"}`,
-    run.current_stage && `stage: ${run.current_stage}`,
-    run.outcome && `outcome: ${run.outcome}`,
-    `processed: ${Number(counters.sessions_processed ?? 0)}`,
-    `failed: ${Number(counters.sessions_failed ?? 0)}`,
-    Number(counters.distilled_skills_generated ?? 0) > 0 && `distilled: ${Number(counters.distilled_skills_generated ?? 0)}`,
-    Number(counters.skills_indexed ?? 0) > 0 && `indexed: ${Number(counters.skills_indexed ?? 0)}`,
-    (run.generated_skill_ids?.length ?? 0) > 0 && `skills: ${(run.generated_skill_ids ?? []).join(", ")}`,
-    run.error && `error: ${run.error}`,
-    run.started_at && `started: ${run.started_at}`,
-    run.updated_at && `updated: ${run.updated_at}`
-  ].filter(Boolean);
-  if (events.length > 0) {
-    lines.push("recent events (newest first):");
-    for (const event of events.slice(0, STATUS_HUMAN_EVENT_LIMIT)) {
-      lines.push(`  ${[event.created_at, event.level, event.stage, event.message].filter(Boolean).join("  ")}`);
-    }
-  }
-  return lines.join(`
-`);
-}
-function writeIfChanged(filePath, content) {
-  try {
-    mkdirSync2(dirname2(filePath), { recursive: true });
-    if (existsSync2(filePath)) {
-      const current = readFileSync2(filePath, "utf8");
-      if (current === content)
-        return "unchanged";
-      writeFileSync2(filePath, content);
-      return "updated";
-    }
-    writeFileSync2(filePath, content);
-    return "wrote";
-  } catch {
-    return "failed";
-  }
-}
-async function pullSkills(options = {}) {
-  const status = options.status ?? "approved";
-  const cwd = options.cwd ?? process.cwd();
-  const log = (msg) => {
-    if (!options.silent)
-      console.log(msg);
-  };
-  const fetched = await fetchSkills(status);
-  const { skills } = fetched;
-  const summary = {
-    total: skills.length,
-    pruned: 0,
-    wrote: 0,
-    updated: 0,
-    unchanged: 0,
-    failed: 0
-  };
-  if (skills.length === 0) {
-    log("  No skills to pull yet.");
-    return summary;
-  }
-  const previousManifest = readSkillsManifest(cwd);
-  const preservedIntegrationRecords = (previousManifest?.records ?? []).filter((record) => record.source === SKILL_SOURCE_INTEGRATION_BUNDLED);
-  if (previousManifest && previousManifest.managedPaths.length > 0 && previousManifest.releaseKey !== fetched.releaseKey) {
-    const integrationPaths = new Set(preservedIntegrationRecords.flatMap((record) => record.paths));
-    const harnessPaths = previousManifest.managedPaths.filter((path) => !integrationPaths.has(path));
-    if (harnessPaths.length > 0) {
-      summary.pruned = pruneManagedSkillPaths(cwd, harnessPaths, log);
-    }
-  }
-  const agents = detectAgents();
-  const writeCursor = agents.includes("Cursor") || existsSync2(join2(cwd, ".cursor"));
-  const records = [];
-  for (const skill of skills) {
-    if (!skill.skill_id || !skill.skill_md) {
-      summary.failed++;
-      continue;
-    }
-    const safeId = basename(skill.skill_id);
-    if (!safeId || !/^[A-Za-z0-9_-]+$/.test(safeId)) {
-      summary.failed++;
-      log(`  skipped invalid skill_id: ${JSON.stringify(skill.skill_id).slice(0, 80)}`);
-      continue;
-    }
-    const claudePath = join2(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);
-    const paths = [];
-    if (claudeStatus !== "failed")
-      paths.push(claudeRelativePath);
-    if (writeCursor) {
-      const cursorPath = join2(cwd, ".cursor", "rules", `${safeId}.mdc`);
-      const cursorStatus = writeIfChanged(cursorPath, claudeSkillToCursorRule(skill.skill_md));
-      const cursorRelativePath = `.cursor/rules/${safeId}.mdc`;
-      recordOutcome(summary, cursorStatus, log, cursorRelativePath);
-      if (cursorStatus !== "failed")
-        paths.push(cursorRelativePath);
-    }
-    if (paths.length > 0) {
-      records.push({
-        skillId: safeId,
-        contentHash: sha256(skill.skill_md),
-        source: SKILL_SOURCE_HARNESS,
-        paths
-      });
-    }
-  }
-  writeSkillsManifest(cwd, manifestHeaderFor(fetched), [...records, ...preservedIntegrationRecords]);
-  return summary;
-}
-function recordOutcome(summary, status, log, relativePath) {
-  switch (status) {
-    case "wrote":
-      summary.wrote++;
-      log(`  wrote ${relativePath}`);
-      break;
-    case "updated":
-      summary.updated++;
-      log(`  updated ${relativePath}`);
-      break;
-    case "unchanged":
-      summary.unchanged++;
-      break;
-    case "failed":
-      summary.failed++;
-      log(`  failed ${relativePath}`);
-      break;
-  }
-}
-var SKILLS_DIR = join2(".claude", "skills");
-var SKILL_FILE = "SKILL.md";
-var MAX_SKILL_WALK_DEPTH = 4;
-async function runSkillSync(flags = {}, profileOptions = {}, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const dryRun = flags["dry-run"] === "true";
-  const agentsMd = dryRun ? undefined : upsertFixesAgentsBlock(cwd);
-  const skills = discoverLocalSkills(cwd);
-  if (skills.length === 0) {
-    return { synced: [], dryRun, ...agentsMd ? { agentsMd } : {} };
-  }
-  const sourceCommit = getGitCommit(cwd);
-  const response = await callControlAPI("/skills/sync", {
-    method: "POST",
-    body: JSON.stringify({
-      skills: skills.map((skill) => ({
-        key: skill.key,
-        name: skill.name,
-        description: skill.description,
-        skillMd: skill.skillMd,
-        sourcePath: skill.sourcePath,
-        contentHash: skill.contentHash,
-        sourceCommit
-      })),
-      sourceCommit,
-      dryRun
-    })
-  }, profileOptions);
-  return { synced: response.synced ?? [], dryRun, ...agentsMd ? { agentsMd } : {} };
-}
-function discoverLocalSkills(cwd) {
-  const skillsRoot = join2(cwd, SKILLS_DIR);
-  if (!existsSync2(skillsRoot))
-    return [];
-  const managed = new Set(managedSkillPaths(cwd));
-  const skills = [];
-  for (const absPath of walkSkillFiles(skillsRoot, 0)) {
-    const sourcePath = relative(cwd, absPath).replace(/\\/g, "/");
-    if (managed.has(sourcePath))
-      continue;
-    const key = basename(dirname2(absPath));
-    if (key === "moda-cli" || !/^[A-Za-z0-9_-]+$/.test(key))
-      continue;
-    let content;
-    try {
-      content = readFileSync2(absPath, "utf8");
-    } catch {
-      continue;
-    }
-    if (!content.trim())
-      continue;
-    const { name, description } = parseSkillFrontmatter(content, key);
-    skills.push({
-      key,
-      name,
-      description,
-      skillMd: content,
-      sourcePath,
-      contentHash: sha256(content)
-    });
-  }
-  return skills.sort((a, b) => a.key.localeCompare(b.key));
-}
-function managedSkillPaths(cwd) {
-  const manifest = readSkillsManifest(cwd);
-  if (!manifest)
-    return [];
-  return manifest.managedPaths.filter((path) => path.startsWith(".claude/skills/") && path.endsWith("/SKILL.md"));
-}
-function walkSkillFiles(dir, depth) {
-  if (depth > MAX_SKILL_WALK_DEPTH)
-    return [];
-  let entries;
-  try {
-    entries = readdirSync(dir);
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = join2(dir, entry);
-    let stat;
-    try {
-      stat = lstatSync2(fullPath);
-    } catch {
-      continue;
-    }
-    if (stat.isSymbolicLink())
-      continue;
-    if (stat.isDirectory()) {
-      files.push(...walkSkillFiles(fullPath, depth + 1));
-    } else if (stat.isFile() && entry === SKILL_FILE) {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
-function parseSkillFrontmatter(raw, fallbackKey) {
-  let name = fallbackKey;
-  let description;
-  if (raw.startsWith("---")) {
-    const end = raw.indexOf(`
----`, 3);
-    if (end !== -1) {
-      const frontmatter = raw.slice(3, end);
-      const nameMatch = frontmatter.match(/^name:\s*(.+)$/m);
-      const descMatch = frontmatter.match(/^description:\s*(.+)$/m);
-      if (nameMatch)
-        name = stripQuotes(nameMatch[1].trim()) || fallbackKey;
-      if (descMatch)
-        description = stripQuotes(descMatch[1].trim()) || undefined;
-    }
-  }
-  return { name, description };
-}
-function stripQuotes(value) {
-  return value.replace(/^["']|["']$/g, "");
-}
-function getGitCommit(cwd) {
-  try {
-    return execFileSync("git", ["rev-parse", "HEAD"], {
-      cwd,
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "ignore"]
-    }).trim();
-  } catch {
-    return;
-  }
-}
-async function fetchSkillProposals(flags, profileOptions = {}) {
-  const params = new URLSearchParams;
-  if (flags["generation-run-id"])
-    params.set("generationRunId", flags["generation-run-id"]);
-  const status = flags.status ?? "ready_for_pr";
-  if (status !== "all")
-    params.set("status", status);
-  if (flags["tenant-id"])
-    params.set("tenantId", flags["tenant-id"]);
-  const suffix = params.toString() ? `?${params.toString()}` : "";
-  const response = await callControlAPI(`/skills/proposals${suffix}`, { method: "GET" }, profileOptions);
-  return Array.isArray(response.proposals) ? response.proposals : [];
-}
-async function applySkillProposal(proposalId, flags, profileOptions = {}, options = {}) {
-  const cwd = options.cwd ?? process.cwd();
-  const params = new URLSearchParams;
-  if (flags["tenant-id"])
-    params.set("tenantId", flags["tenant-id"]);
-  const suffix = params.toString() ? `?${params.toString()}` : "";
-  const proposal = await callControlAPI(`/skills/proposals/${encodeURIComponent(proposalId)}${suffix}`, { method: "GET" }, profileOptions);
-  if (!proposal.skillMd?.trim()) {
-    throw new CliInputError(`Proposal ${proposalId} does not include SKILL.md content`);
-  }
-  const safeId = safeSkillId(proposal.skillId);
-  const relativePath = `.claude/skills/${safeId}/SKILL.md`;
-  const writeStatus = writeIfChanged(join2(cwd, relativePath), proposal.skillMd);
-  if (writeStatus === "failed") {
-    throw new Error(`Failed to write ${relativePath}`);
-  }
-  writeSkillProposalManifest(cwd, proposal, relativePath);
-  let acknowledged = true;
-  let ackError;
-  try {
-    await callControlAPI(`/skills/proposals/${encodeURIComponent(proposalId)}/mark-applied${suffix}`, {
-      method: "POST",
-      body: JSON.stringify({ appliedBy: "moda-cli" })
-    }, profileOptions);
-  } catch (err) {
-    acknowledged = false;
-    ackError = err instanceof Error ? err.message : String(err);
-  }
-  return {
-    proposalId,
-    skillId: proposal.skillId,
-    path: relativePath,
-    status: writeStatus,
-    acknowledged,
-    ackError
-  };
-}
-function safeSkillId(skillId) {
-  const safeId = basename(skillId || "");
-  if (!safeId || !/^[A-Za-z0-9_-]+$/.test(safeId)) {
-    throw new CliInputError(`Invalid skill_id in proposal: ${JSON.stringify(skillId).slice(0, 80)}`);
-  }
-  return safeId;
-}
-function writeSkillProposalManifest(cwd, proposal, relativePath) {
-  const manifestPath = join2(cwd, SKILL_PROPOSALS_MANIFEST_PATH);
-  mkdirSync2(dirname2(manifestPath), { recursive: true });
-  const existing = existsSync2(manifestPath) ? readFileSync2(manifestPath, "utf8") : `applied_proposals:
-`;
-  const entry = [
-    `  - proposal_id: "${escapeYamlString(proposal.proposalId)}"`,
-    `    skill_id: "${escapeYamlString(proposal.skillId)}"`,
-    `    skill_family_id: "${escapeYamlString(proposal.skillFamilyId)}"`,
-    `    skill_version: ${Number(proposal.skillVersion || 0)}`,
-    `    generation_run_id: "${escapeYamlString(proposal.generationRunId)}"`,
-    `    clustering_run_id: "${escapeYamlString(proposal.clusteringRunId)}"`,
-    `    topic_id: "${escapeYamlString(proposal.topicId)}"`,
-    `    replay_set_id: "${escapeYamlString(proposal.replaySetId)}"`,
-    `    delta_pass_rate: ${Number(proposal.deltaPassRate || 0)}`,
-    `    path: "${escapeYamlString(relativePath)}"`,
-    `    applied_at: "${new Date().toISOString()}"`
-  ].join(`
-`);
-  const prefix = existing.endsWith(`
-`) ? existing : `${existing}
-`;
-  writeFileSync2(manifestPath, `${prefix}${entry}
-`);
-}
-function escapeYamlString(value) {
-  return String(value ?? "").replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
-}
-function formatProposalRate(value) {
-  return `${(Number(value || 0) * 100).toFixed(1)}%`;
-}
-var SKILLS_SUBCOMMAND_FLAGS = {
-  gen: [
-    "source",
-    "wait",
-    "clustering-poll-seconds",
-    "clustering-run-id",
-    "clustering-timeout-seconds",
-    "end-at",
-    "force-reprocess",
-    "harness-url",
-    "lookback-hours",
-    "max-cluster-pct",
-    "max-sessions",
-    "max-traces",
-    "no-clustering",
-    "reprocess-segments",
-    "start-at",
-    "tenant-id",
-    "wait-for-completion"
-  ],
-  status: ["run-id"],
-  pull: ["status"],
-  proposals: ["status", "generation-run-id", "tenant-id"],
-  proposal: ["proposal-id", "tenant-id"],
-  install: ["list"]
-};
-async function runSkillsCommand(input) {
-  const context = "output" in input ? input : createCommandContext({
-    command: input.command,
-    positional: input.positional,
-    positionals: input.positionals,
-    flags: input.flags
-  }, {
-    outputMode: input.flags.agent === "true" ? "agent" : input.flags.json === "true" ? "json" : "human"
-  });
-  const sub = context.positional;
-  const positionals = context.positionals ?? (sub ? [sub] : []);
-  const flags = context.flags;
-  if (sub && SKILLS_SUBCOMMAND_FLAGS[sub])
-    assertFlags(`skills ${sub}`, flags, SKILLS_SUBCOMMAND_FLAGS[sub]);
-  if (sub === "gen") {
-    const result = await generateSkills(flags);
-    if (context.outputMode !== "human") {
-      context.output.writeData(result, {
-        status: Number(result.sessions_failed ?? 0) > 0 ? "error" : "success"
-      });
-    } else if (result.accepted) {
-      console.log([
-        "accepted: true",
-        result.generation_run_id && `generation_run_id: ${result.generation_run_id}`,
-        result.message && `message: ${result.message}`,
-        result.generation_run_id && `follow progress: moda skills status ${shellArg(result.generation_run_id)}`
-      ].filter(Boolean).join(`
-`));
-    } else {
-      console.log([
-        `processed: ${result.sessions_processed ?? 0}`,
-        `failed: ${result.sessions_failed ?? 0}`,
-        `pending: ${result.sessions_pending ?? 0}`,
-        `pending_found: ${result.pending_sessions_found ?? 0}`,
-        `distilled: ${Number(result.cluster_result?.distilled_skills_generated ?? 0)}`,
-        `indexed: ${Number(result.cluster_result?.skills_indexed ?? 0)}`,
-        result.distillation_skipped && `distillation skipped: ${result.distillation_skip_reason || "unknown"}`
-      ].filter(Boolean).join(`
-`));
-    }
-    return Number(result.sessions_failed ?? 0) > 0 ? 1 : 0;
-  }
-  if (sub === "status") {
-    const runId = positionals[1] || flags["run-id"] || undefined;
-    const { run, events } = await fetchSkillRunStatus(runId);
-    if (context.outputMode !== "human") {
-      context.output.writeData({ run, events }, { status: run?.status === "failed" ? "error" : "success" });
-    } else if (!run) {
-      console.log("No skill generation runs found yet. Start one with `moda skills gen`.");
-    } else {
-      console.log(formatRunStatusHuman(run, events));
-    }
-    return run?.status === "failed" ? 1 : 0;
-  }
-  if (sub === "proposals" && positionals[1] === "list") {
-    const proposals = await fetchSkillProposals(flags, { profile: context.profile });
-    if (flags.json === "true") {
-      console.log(JSON.stringify({ proposals }));
-    } else if (proposals.length === 0) {
-      console.log("No skill proposals found.");
-    } else {
-      for (const proposal of proposals) {
-        console.log([
-          proposal.proposalId,
-          proposal.proposalStatus,
-          `${proposal.skillId}@v${proposal.skillVersion}`,
-          `delta=${formatProposalRate(proposal.deltaPassRate)}`,
-          `baseline=${formatProposalRate(proposal.baselinePassRate)}`,
-          `candidate=${formatProposalRate(proposal.candidatePassRate)}`,
-          proposal.name
-        ].filter(Boolean).join("\t"));
-      }
-    }
-    return 0;
-  }
-  if (sub === "proposal" && positionals[1] === "apply") {
-    const proposalId = positionals[2] || flags["proposal-id"];
-    if (!proposalId) {
-      throw new CliInputError("A proposal id is required", "Usage: moda skills proposal apply <proposal-id>");
-    }
-    const result = await applySkillProposal(proposalId, flags, { profile: context.profile });
-    if (flags.json === "true") {
-      console.log(JSON.stringify(result));
-    } else {
-      console.log([
-        `${result.status} ${result.path}`,
-        result.acknowledged ? "acknowledged: true" : "acknowledged: false"
-      ].join(`
-`));
-    }
-    if (!result.acknowledged) {
-      console.error(`Warning: wrote ${result.path} but failed to acknowledge proposal ${proposalId} on the server` + (result.ackError ? ` (${result.ackError})` : "") + ". The proposal is still listed as ready — re-run `moda skills proposal apply` to acknowledge it.");
-      return 1;
-    }
-    return 0;
-  }
-  if (sub === "list" || sub === "show" || sub === "policy") {
-    return runSkillRegistryCommand(sub, positionals, flags, context);
-  }
-  if (sub === "sync") {
-    assertFlags("skills sync", flags, ["dry-run"]);
-    const result = await runSkillSync(flags, { profile: context.profile, env: context.env });
-    const agentsMdWarning = agentsMdProblem(result.agentsMd);
-    context.output.writeData({
-      synced: result.synced,
-      dryRun: result.dryRun,
-      ...result.agentsMd ? { agentsMd: result.agentsMd } : {}
-    }, agentsMdWarning ? { status: "degraded", warnings: [agentsMdWarning] } : {});
-    return 0;
-  }
-  if (sub === "install") {
-    return runSkillsInstall(context, positionals.slice(1));
-  }
-  if (sub !== "pull") {
-    throw new CliInputError(sub ? `Unknown skills subcommand '${sub}'` : "A skills subcommand is required", "Usage: moda skills gen [--source=all|sdk] [--max-sessions=N (default 200)] [--lookback-hours=N (default 720)] [--max-traces=N] [--start-at=ISO] [--end-at=ISO] [--reprocess-segments] [--force-reprocess] [--wait] | moda skills status [run-id] | moda skills proposals list [--status=ready_for_pr] | moda skills proposal apply <proposal-id> | moda skills pull [--status=approved|proposed|all] | moda skills push [--dry-run] | moda skills install [--list] <id...>");
-  }
-  const status = (flags.status ?? "approved").toLowerCase();
-  if (!VALID_STATUSES.has(status)) {
-    throw new CliInputError(`Invalid --status '${status}'`, `Must be one of: ${[...VALID_STATUSES].join(", ")}`);
-  }
-  const summary = await pullSkills({ status, silent: context.outputMode !== "human" });
-  const parts = [
-    summary.pruned && `${summary.pruned} pruned`,
-    summary.wrote && `${summary.wrote} written`,
-    summary.updated && `${summary.updated} updated`,
-    summary.unchanged && `${summary.unchanged} unchanged`,
-    summary.failed && `${summary.failed} failed`
-  ].filter(Boolean);
-  if (context.outputMode === "human" && summary.total > 0) {
-    console.log(`  Done — ${parts.join(", ") || "no changes"}`);
-  }
-  if (context.outputMode !== "human") {
-    context.output.writeData({ status, summary });
-  }
-  return summary.failed > 0 ? 1 : 0;
-}
-async function generateSkills(flags) {
-  const apiKey = resolveApiKey();
-  if (!apiKey) {
-    throw new CliInputError("No Moda API key found. Run `moda init` first (or set MODA_API_KEY).");
-  }
-  const tenantId = flags["tenant-id"] || resolveTenantId();
-  const directHarnessUrl = flags["harness-url"] || process.env.MODA_SKILL_HARNESS_URL;
-  if (directHarnessUrl && !tenantId) {
-    throw new CliInputError("No Moda tenant id found. Run `moda init` first (or set MODA_TENANT_ID / --tenant-id).");
-  }
-  const endpoint = directHarnessUrl ? `${directHarnessUrl.replace(/\/+$/, "")}/skills/generate` : `${resolveIngestUrl().replace(/\/+$/, "")}/v1/skills/generate`;
-  const waitForCompletion = flags.wait === "true" || flags["wait-for-completion"] === "true";
-  const forceReprocess = flags["force-reprocess"] === "true";
-  const source = normalizeSkillSource(flags.source);
-  const body = compactObject({
-    tenant_id: tenantId || undefined,
-    max_sessions: parseScopeInt(flags["max-sessions"], "max-sessions"),
-    lookback_hours: parseScopeInt(flags["lookback-hours"], "lookback-hours"),
-    start_at: flags["start-at"] || undefined,
-    end_at: flags["end-at"] || undefined,
-    clustering_run_id: flags["clustering-run-id"] || undefined,
-    run_clustering: flags["no-clustering"] !== "true",
-    source,
-    clustering_timeout_seconds: parsePositiveInt(flags["clustering-timeout-seconds"], 7200),
-    clustering_poll_seconds: parsePositiveInt(flags["clustering-poll-seconds"], 15),
-    max_cluster_pct: parseOptionalFloat(flags["max-cluster-pct"]),
-    reprocess_segments: flags["reprocess-segments"] === "true" || forceReprocess,
-    max_traces: parseScopeInt(flags["max-traces"], "max-traces"),
-    force_reprocess: forceReprocess,
-    wait_for_completion: waitForCompletion
-  });
-  const headers = {
-    Authorization: `Bearer ${apiKey}`,
-    "Content-Type": "application/json"
-  };
-  if (tenantId)
-    headers["X-Moda-Tenant-Id"] = tenantId;
-  recordApiRequest();
-  const response = await fetch(endpoint, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body)
-  });
-  if (!response.ok) {
-    const text = await response.text().catch(() => "");
-    throw new Error(`Failed to generate skills (HTTP ${response.status}): ${text.slice(0, 200)}`);
-  }
-  return await response.json();
-}
-function parseScopeInt(value, flag, max) {
-  if (value === undefined)
-    return;
-  const parsed = /^\d+$/.test(value.trim()) ? Number.parseInt(value, 10) : Number.NaN;
-  if (!Number.isFinite(parsed) || parsed < 1) {
-    throw new CliInputError(`--${flag}=${value} is not a positive integer, so nothing was sent.`, `0 would mean unlimited server-side; omit --${flag} for the server default, or pass a number of 1 or more.`);
-  }
-  if (max !== undefined && parsed > max) {
-    throw new CliInputError(`--${flag}=${value} is above the maximum of ${max}, so nothing was sent.`);
-  }
-  return parsed;
-}
-function parsePositiveInt(value, fallback) {
-  if (!value)
-    return fallback;
-  const parsed = Number.parseInt(value, 10);
-  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
-}
-function parseOptionalFloat(value) {
-  if (!value)
-    return;
-  const parsed = Number.parseFloat(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-function compactObject(input) {
-  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
-}
-function normalizeSkillSource(value) {
-  const normalized = (value || "all").toLowerCase();
-  if (["all", "sdk"].includes(normalized))
-    return normalized;
-  throw new CliInputError(`Invalid --source '${value}'. Use --source=all or --source=sdk.`);
-}
-function releaseKeyFor(release, skills, status) {
-  if (release?.generation_run_id)
-    return `${status}:run:${release.generation_run_id}`;
-  if (Number(release?.generation_version || 0) > 0) {
-    return `${status}:version:${Number(release?.generation_version)}`;
-  }
-  return `${status}:legacy:${sha256(JSON.stringify(skills.map((skill) => ({
-    skill_id: skill.skill_id,
-    hash: sha256(skill.skill_md || "")
-  })).sort((a, b) => a.skill_id.localeCompare(b.skill_id))))}`;
-}
-function manifestHeaderFor(fetched) {
-  const release = fetched.release;
-  return {
-    tenantId: fetched.tenantId,
-    releaseKey: fetched.releaseKey,
-    statusFilter: fetched.status,
-    generationRunId: release?.generation_run_id || "",
-    generationVersion: Number(release?.generation_version || 0),
-    releasedAt: release?.released_at || ""
-  };
-}
-function sha256(input) {
-  return createHash("sha256").update(input).digest("hex");
-}
-var MODA_CLI_SKILL_ID = "moda-cli";
-async function installModaCliSkill(context) {
-  const { detectAgents: detectAgents2 } = await import("./mcp-1qre9f0n.js");
-  const { installRules, summarizeInstall } = await import("./rules-qddx5t0j.js");
-  const result = await installRules(detectAgents2(), { yes: true, silent: true });
-  if (result.status === "skipped") {
-    throw new CliInputError("No supported coding agent was detected here, so the moda-cli skill was not installed.", "Run this from a project with a .claude or .cursor directory, or with Claude Code on PATH. Only Claude Code and Cursor are supported.");
-  }
-  const agentsMd = result.status === "failed" ? undefined : upsertFixesAgentsBlock(context.cwd);
-  const blockWarning = agentsMdProblem(agentsMd);
-  if (blockWarning) {
-    result.warnings.push(blockWarning);
-    result.status = "warning";
-  }
-  const summary = summarizeInstall(result);
-  if (context.outputMode !== "human") {
-    context.output.writeData({ skill: MODA_CLI_SKILL_ID, status: result.status, agents: result.agents, counts: result.counts, summary, outcomes: result.outcomes, notes: result.notes, agentsMd }, { ...result.status === "failed" ? { status: "error" } : {}, warnings: result.warnings });
-  } else {
-    console.log(`moda-cli skill for ${result.agents.join(", ")}: ${summary}`);
-    for (const note of result.notes)
-      console.log(`  ${note}`);
-    for (const warning of result.warnings)
-      console.error(`  ${warning}`);
-  }
-  return result.status === "failed" ? 1 : 0;
-}
-async function runSkillsInstall(context, ids) {
-  const { installIntegrationSkill, readBundledIndex, readBundledSkillMd } = await import("./skills-bundled-7jes6hqx.js");
-  const index = readBundledIndex();
-  if (context.flags.list === "true" || ids.length === 0) {
-    const { bundledSkillVersion } = await import("./rules-qddx5t0j.js");
-    if (!index) {
-      throw new CliInputError("This CLI build has no bundled integration guides", "Install a published @moda-ai/cli, or run `bun run bundle:skills` in apps/moda-cli.");
-    }
-    const skills = [
-      { id: MODA_CLI_SKILL_ID, version: bundledSkillVersion(MODA_CLI_SKILL_ID), language: "any", summary: "This CLI's own guide for coding agents; installs or refreshes it for each detected agent (copies edited locally are kept)." },
-      ...index.skills.map((skill) => ({
-        id: skill.id,
-        version: skill.version,
-        language: skill.targets.language,
-        summary: skill.summary
-      }))
-    ];
-    if (context.outputMode !== "human") {
-      context.output.writeData({ skills });
-    } else {
-      for (const skill of skills)
-        console.log(`${skill.id}	${skill.version}	${skill.summary}`);
-      if (ids.length === 0 && context.flags.list !== "true") {
-        console.error("Install one or more with: moda skills install <id...>");
-      }
-    }
-    return 0;
-  }
-  if (ids.includes(MODA_CLI_SKILL_ID)) {
-    const others = ids.filter((id) => id !== MODA_CLI_SKILL_ID);
-    if (others.length > 0) {
-      throw new CliInputError(`Install ${MODA_CLI_SKILL_ID} on its own, so nothing was written.`, `Run \`moda skills install ${MODA_CLI_SKILL_ID}\`, then \`moda skills install ${others.join(" ")}\`.`);
-    }
-    return installModaCliSkill(context);
-  }
-  const unknown = ids.filter((id) => !/^[a-z0-9-]+$/.test(id) || readBundledSkillMd(id) === null);
-  if (unknown.length > 0) {
-    throw new CliInputError(`Not bundled with this CLI: ${unknown.map((id) => JSON.stringify(id).slice(0, 80)).join(", ")}`, "List the bundled guides with: moda skills install --list");
-  }
-  const results = [];
-  for (const id of ids) {
-    try {
-      results.push(installIntegrationSkill(id));
-    } catch (error) {
-      const done = results.map((result) => result.skillId);
-      throw new CliInputError(error instanceof Error ? error.message : String(error), done.length > 0 ? `Already installed before the failure: ${done.join(", ")}. Fix the error and rerun; installed guides are left as they are.` : "List the bundled guides with: moda skills install --list");
-    }
-  }
-  if (context.outputMode !== "human") {
-    context.output.writeData({ installed: results });
-  } else {
-    for (const result of results) {
-      console.log(`${result.status} ${result.skillId}`);
-      for (const path of result.paths)
-        console.log(`  ${path}`);
-    }
-  }
-  return 0;
-}
-var RESERVED_SKILL_PATHS = new Set(["inbox", "library", "observed", "runs", "sync", "surface", "families", "proposals"]);
-async function runSkillRegistryCommand(sub, positionals, flags, context) {
-  const profileOptions = { profile: context.profile, env: context.env };
-  assertFlags(`skills ${sub}`, flags, sub === "policy" ? ["live", "local", "dry-run"] : []);
-  assertPositionals(`skills ${sub}`, positionals, sub === "list" ? 1 : 2, sub === "list" ? "moda skills list" : `moda skills ${sub} <key>${sub === "policy" ? " --live|--local" : ""}`);
-  if (sub === "list") {
-    context.output.writeData(await callControlAPI("/skills", {}, profileOptions));
-    return 0;
-  }
-  const idOrKey = positionals[1];
-  if (!idOrKey) {
-    throw new CliInputError(`A skill key or id is required for skills ${sub}.`, sub === "show" ? "Usage: moda skills show <key>" : "Usage: moda skills policy <key> --live|--local");
-  }
-  if (RESERVED_SKILL_PATHS.has(idOrKey)) {
-    throw new CliInputError(`'${idOrKey}' is a reserved path, so this skill must be addressed by its id.`, "Find the id (skill_…) with `moda skills list`, then pass that instead of the key.");
-  }
-  if (sub === "show") {
-    context.output.writeData(await callControlAPI(`/skills/${encodeURIComponent(idOrKey)}`, {}, profileOptions));
-    return 0;
-  }
-  const live = flags.live === "true";
-  const local = flags.local === "true";
-  if (live === local) {
-    throw new CliInputError("Pass exactly one of --live or --local.", "Usage: moda skills policy <key> --live|--local");
-  }
-  const surfacePolicy = live ? "include" : "local_only";
-  if (context.dryRun) {
-    writeDryRun(context, { plane: "control", method: "PATCH", path: `/skills/${encodeURIComponent(idOrKey)}/surface-policy`, body: { surfacePolicy } });
-    return 0;
-  }
-  context.output.writeData(await callControlAPI(`/skills/${encodeURIComponent(idOrKey)}/surface-policy`, { method: "PATCH", body: JSON.stringify({ surfacePolicy }) }, profileOptions, { retries: 0 }));
-  return 0;
-}
-
-export { agentsMdProblem, pullSkills, runSkillSync, runSkillsCommand, parseScopeInt };