@moda-ai/cli 1.55.10 → 1.55.12

package/dist/cli-y8gbbe9k.js

@@ -0,0 +1,946 @@
+import {
+  createCommandContext
+} from "./cli-4x9w6ey7.js";
+import {
+  assertFlags,
+  assertPositionals
+} from "./cli-k7vwt56h.js";
+import {
+  callControlAPI
+} from "./cli-ryd7nzke.js";
+import {
+  CliInputError,
+  recordApiRequest,
+  resolveApiKey,
+  resolveIngestUrl,
+  resolveTenantId
+} from "./cli-kwz900s4.js";
+import {
+  SKILL_SOURCE_HARNESS,
+  SKILL_SOURCE_INTEGRATION_BUNDLED,
+  claudeSkillToCursorRule,
+  detectAgents,
+  pruneManagedSkillPaths,
+  readSkillsManifest,
+  writeSkillsManifest
+} from "./cli-ssfq84k5.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,
+  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, 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.",
+    "",
+    "- 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 problem <problem_id>` (dossier),",
+    "  `moda problem <problem_id> --evidence` (attribution rationales and anchors),",
+    "  `moda problem <problem_id> --traces` (affected traces),",
+    "  `moda tool-failure-detail <tool_name>` (failing calls in context), and",
+    "  `moda context <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 problem-feedback <problem_id> --action=mark_fixed`; if the issue",
+    "  is detected again, the Problem comes back.",
+    FIXES_BLOCK_END
+  ].join(`
+`);
+}
+function upsertManagedBlock(existing, block) {
+  if (existing === null) {
+    return `${block}
+`;
+  }
+  const beginIdx = existing.indexOf(FIXES_BLOCK_BEGIN);
+  const endIdx = existing.indexOf(FIXES_BLOCK_END);
+  if (beginIdx !== -1 && endIdx !== -1 && endIdx >= beginIdx) {
+    const before = existing.slice(0, beginIdx);
+    const after = existing.slice(endIdx + FIXES_BLOCK_END.length);
+    return `${before}${block}${after}`;
+  }
+  const separator = existing === "" || existing.endsWith(`
+
+`) ? "" : existing.endsWith(`
+`) ? `
+` : `
+
+`;
+  return `${existing}${separator}${block}
+`;
+}
+function writeFileIfChanged(filePath, content) {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    if (existsSync(filePath)) {
+      const current = readFileSync(filePath, "utf8");
+      if (current === content)
+        return "unchanged";
+      writeFileSync(filePath, content);
+      return "updated";
+    }
+    writeFileSync(filePath, content);
+    return "wrote";
+  } catch {
+    return "failed";
+  }
+}
+function upsertFixesAgentsBlock(cwd) {
+  const filePath = join(cwd, AGENTS_MD_FILENAME);
+  let existing = null;
+  if (existsSync(filePath)) {
+    try {
+      existing = readFileSync(filePath, "utf8");
+    } catch {
+      return { path: AGENTS_MD_FILENAME, status: "failed" };
+    }
+  }
+  const next = upsertManagedBlock(existing, renderFixesBlock());
+  return { path: AGENTS_MD_FILENAME, status: writeFileIfChanged(filePath, next) };
+}
+
+// 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 = lstatSync(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: [
+    "replay",
+    "source",
+    "wait",
+    "clustering-poll-seconds",
+    "clustering-run-id",
+    "clustering-timeout-seconds",
+    "end-at",
+    "eval-set-id",
+    "force-reprocess",
+    "harness-url",
+    "improve-candidates",
+    "improvement-rounds",
+    "lookback-hours",
+    "max-cluster-pct",
+    "max-sessions",
+    "max-traces",
+    "no-clustering",
+    "no-replay",
+    "replay-set-id",
+    "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 ${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 });
+    context.output.writeData({
+      synced: result.synced,
+      dryRun: result.dryRun,
+      ...result.agentsMd ? { agentsMd: result.agentsMd } : {}
+    });
+    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] [--improvement-rounds=1-3] [--start-at=ISO] [--end-at=ISO] [--replay] [--replay-set-id=ID] [--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 sync [--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);
+  if (source === "coding_agent") {
+    console.error("Note: --source=coding-agent is deprecated for skills gen (SDK-only). The run will find no coding-agent sessions; use --source=all or --source=sdk.");
+  }
+  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,
+    replay_set_id: flags["replay-set-id"] || flags["eval-set-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,
+    run_replay: flags.replay === "true" && flags["no-replay"] !== "true",
+    max_traces: parseScopeInt(flags["max-traces"], "max-traces"),
+    improve_candidates: flags["improve-candidates"] === "true",
+    improvement_rounds: parseScopeInt(flags["improvement-rounds"], "improvement-rounds", MAX_IMPROVEMENT_ROUNDS) ?? 2,
+    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();
+}
+var MAX_IMPROVEMENT_ROUNDS = 3;
+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().replace(/-/g, "_");
+  if (["all", "sdk", "coding_agent"].includes(normalized))
+    return normalized;
+  return "all";
+}
+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");
+}
+async function runSkillsInstall(context, ids) {
+  const { installIntegrationSkill, readBundledIndex, readBundledSkillMd } = await import("./skills-bundled-mdmhzfsr.js");
+  const index = readBundledIndex();
+  if (context.flags.list === "true" || ids.length === 0) {
+    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 = 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;
+  }
+  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) {
+    context.output.writeData({ dryRun: true, planned: { method: "PATCH", endpoint: `/api/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 { pullSkills, runSkillSync, runSkillsCommand, parseScopeInt };