oh-my-design-cli 1.8.6 → 1.9.0

package/dist/install-skills-ZZFNJ2II.js

@@ -0,0 +1,1120 @@
+#!/usr/bin/env node
+import {
+  CLAUDE_HOOK_PATHS,
+  isKnownLegacyHook,
+  isSelfConsistentManagedHook,
+  renderManagedHook,
+  unsafeManagedPath
+} from "./chunk-UJIHCEYF.js";
+
+// src/cli/install-skills.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import {
+  readFileSync,
+  readdirSync,
+  writeFileSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  cpSync,
+  rmSync,
+  rmdirSync,
+  statSync,
+  renameSync
+} from "fs";
+import { join as join2, dirname, relative } from "path";
+import { homedir } from "os";
+import { createHash } from "crypto";
+import { fileURLToPath } from "url";
+
+// src/core/agent-detect.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function detectInstalledAgents(projectRoot) {
+  return {
+    claudeCode: existsSync(join(projectRoot, ".claude")) || existsSync(join(projectRoot, "CLAUDE.md")),
+    codex: existsSync(join(projectRoot, ".codex")) || existsSync(join(projectRoot, "AGENTS.md")) || existsSync(join(projectRoot, "AGENTS.override.md")),
+    opencode: existsSync(join(projectRoot, ".opencode")) || existsSync(join(projectRoot, "opencode.json")) || existsSync(join(projectRoot, "opencode.jsonc")),
+    cursor: existsSync(join(projectRoot, ".cursor")) || existsSync(join(projectRoot, ".cursorrules"))
+  };
+}
+
+// src/cli/install-skills.ts
+var VALID_SKILL_TARGETS = ["claude-code", "codex", "opencode", "cursor"];
+var DEVELOPMENT_ONLY_SKILLS = /* @__PURE__ */ new Set(["omd-lab-02-design-harness"]);
+function targetsAvailableForScope(targets, scope) {
+  return scope === "global" ? targets.filter((target) => target !== "cursor") : targets;
+}
+function findPackageRoot() {
+  let cur = dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i++) {
+    if (existsSync2(join2(cur, "skills"))) return cur;
+    const parent = dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return null;
+}
+function listShippedSkills(packageRoot) {
+  const skillsDir = join2(packageRoot, "skills");
+  if (!existsSync2(skillsDir)) return [];
+  return readdirSync(skillsDir).filter(
+    (name) => !DEVELOPMENT_ONLY_SKILLS.has(name) && existsSync2(join2(skillsDir, name, "SKILL.md"))
+  ).sort();
+}
+function listCanonicalAgents(packageRoot) {
+  const dir = join2(packageRoot, "agents");
+  if (!existsSync2(dir)) return [];
+  return readdirSync(dir).filter((name) => name.startsWith("omd-") && name.endsWith(".md")).sort();
+}
+function parseCanonicalAgent(packageRoot, filename) {
+  const src = readFileSync(join2(packageRoot, "agents", filename), "utf8");
+  const match = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/.exec(src);
+  if (!match) {
+    throw new Error(`agents/${filename}: missing YAML frontmatter`);
+  }
+  const fm = match[1];
+  const body = match[2];
+  const grab = (key) => {
+    const re = new RegExp(`^${key}:\\s*(.+)$`, "m");
+    const m = re.exec(fm);
+    if (!m) return "";
+    const value = m[1].trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      try {
+        const decoded = JSON.parse(value);
+        if (typeof decoded === "string") return decoded;
+      } catch {
+      }
+    }
+    if (value.startsWith("'") && value.endsWith("'")) {
+      return value.slice(1, -1).replace(/''/g, "'");
+    }
+    return value;
+  };
+  return {
+    name: grab("name") || filename.replace(/\.md$/, ""),
+    description: grab("description"),
+    tools: grab("tools").split(",").map((t) => t.trim()).filter(Boolean),
+    model: grab("model") || "sonnet",
+    body
+  };
+}
+function renderClaudeAgent(a) {
+  const fm = [
+    "---",
+    `name: ${JSON.stringify(a.name)}`,
+    `description: ${JSON.stringify(a.description)}`,
+    `tools: ${JSON.stringify(a.tools)}`,
+    `model: ${JSON.stringify(a.model)}`,
+    `omd_managed: true`,
+    "---",
+    ""
+  ].join("\n");
+  return fm + a.body;
+}
+function nativeAgentBody(body, channel, scope) {
+  const skillRoot = channel === "codex" ? scope === "global" ? "~/.agents/skills" : ".agents/skills" : scope === "global" ? "~/.config/opencode/skills" : ".opencode/skills";
+  const nativeBody = body.replace(/(?:~\/)?\.claude\/skills\//g, `${skillRoot}/`).replace(/You are spawned as a Claude Code subagent/g, "You run as a host-managed subagent").replace(/Claude Code subagent/g, "host-managed subagent").replace(/the Agent tool/g, "the host's native sub-agent mechanism").replace(/Agent tool/g, "host-native sub-agent mechanism").replace(/AskUserQuestion-compatible/g, "host question-interface compatible").replace(
+    /launcher calls AskUserQuestion\(questions_file\)/g,
+    "launcher presents questions from `questions_file` to the user"
+  ).replace(/launcher calls AskUserQuestion/g, "launcher presents the questions to the user").replace(/no AskUserQuestion/g, "without direct user-question tools");
+  return channel === "opencode" ? nativeBody.replace(/\bomd:([a-z0-9-]+)/g, "omd-$1") : nativeBody;
+}
+function nativeSkillRoot(channel, scope) {
+  if (channel === "codex") {
+    return scope === "global" ? "~/.agents/skills" : ".agents/skills";
+  }
+  return scope === "global" ? "~/.config/opencode/skills" : ".opencode/skills";
+}
+function renderOpenCodeAgent(a, scope, dataRoot) {
+  const skillRoot = nativeSkillRoot("opencode", scope);
+  return [
+    "---",
+    `description: ${JSON.stringify(a.description)}`,
+    "mode: subagent",
+    "---",
+    "",
+    "## Installed role runtime contract",
+    "",
+    `- Resolve referenced OmD skills from \`${skillRoot}/<skill>/SKILL.md\`.`,
+    `- Resolve the installed offline catalog from \`${dataRoot}\`.`,
+    "- Use OpenCode's native sub-agent mechanism for specialist handoffs.",
+    "",
+    nativeAgentBody(a.body, "opencode", scope).trimEnd(),
+    "",
+    "<!-- omd:installed-agent \u2014 generated from the canonical OmD role. -->",
+    ""
+  ].join("\n");
+}
+function codexSafeAgentBody(body) {
+  return body.replace(/`omd init prepare`/g, "`omd:init` skill flow").replace(/^omd remember .*$/gm, "Use the `omd:remember` skill directly with the same finding and context.").replace(/`omd remember [^`]+`/g, "the `omd:remember` skill with the same correction details").replace(/\bomd remember\b/g, "omd:remember skill");
+}
+function renderCodexAgent(a, scope, dataRoot) {
+  const name = a.name.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const desc = a.description.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const skillRoot = nativeSkillRoot("codex", scope);
+  const instructions = [
+    "## Codex runtime contract",
+    "",
+    "- Execute the OmD behavior directly from these instructions and the installed skills.",
+    `- Resolve referenced OmD skills from \`${skillRoot}/<skill>/SKILL.md\`.`,
+    `- Resolve the installed offline catalog from \`${dataRoot}\`.`,
+    "- Use Codex's native sub-agent mechanism for specialist handoffs.",
+    "- The OmD CLI exposes installation and diagnostics only. Do not invent or invoke removed helper subcommands.",
+    "",
+    codexSafeAgentBody(nativeAgentBody(a.body, "codex", scope)).trimEnd()
+  ].join("\n");
+  if (instructions.includes("'''")) {
+    throw new Error(`agents/${a.name}.md: cannot encode triple single quote in Codex TOML`);
+  }
+  return [
+    `name = "${name}"`,
+    `description = "${desc}"`,
+    "",
+    `developer_instructions = '''`,
+    instructions,
+    `'''`,
+    ""
+  ].join("\n");
+}
+function planForTarget(projectRoot, target, scope) {
+  switch (target) {
+    case "claude-code":
+      return {
+        target,
+        destDir: join2(projectRoot, ".claude", "skills"),
+        layout: "folder"
+      };
+    case "codex":
+      return {
+        target,
+        destDir: join2(projectRoot, ".agents", "skills"),
+        layout: "folder"
+      };
+    case "opencode":
+      return {
+        target,
+        destDir: scope === "global" ? join2(projectRoot, ".config", "opencode", "skills") : join2(projectRoot, ".opencode", "skills"),
+        layout: "folder"
+      };
+  }
+}
+var CHANNEL_DATA_DIRS = {
+  "claude-code": ".claude",
+  codex: ".codex",
+  opencode: ".opencode",
+  cursor: null
+};
+function dataDirFor(target, targets) {
+  if (target === "cursor") {
+    return targets.includes("claude-code") ? null : ".claude";
+  }
+  return CHANNEL_DATA_DIRS[target];
+}
+function dataDirForScope(target, targets, scope) {
+  if (scope === "global" && target === "opencode") return ".config/opencode";
+  return dataDirFor(target, targets);
+}
+var MANAGED_HEADER = "<!-- omd:installed-skill \u2014 managed by `omd install-skills`. Do not edit; rerun the command to refresh. -->";
+var MANAGED_MARKER_SUBSTR = "omd:installed-skill";
+function withManagedMarker(src) {
+  const fm = /^(---\r?\n[\s\S]*?\r?\n---\r?\n)([\s\S]*)$/.exec(src);
+  if (!fm) {
+    return MANAGED_HEADER + "\n\n" + src;
+  }
+  return fm[1] + MANAGED_HEADER + "\n\n" + fm[2];
+}
+function isManagedSkillFile(content) {
+  if (!content) return false;
+  const head = content.split("\n", 30).join("\n");
+  return head.includes(MANAGED_MARKER_SUBSTR);
+}
+function withGlobalDataHint(src, globalDataRoot) {
+  if (!globalDataRoot) return src;
+  const hint = [
+    `> **Installed global data root (highest priority):** \`${globalDataRoot}\`.`,
+    "> Resolve catalog JSON, references, and helper scripts there before project-relative fallbacks.",
+    ""
+  ].join("\n");
+  const fm = /^(---\r?\n[\s\S]*?\r?\n---\r?\n)([\s\S]*)$/.exec(src);
+  return fm ? fm[1] + hint + fm[2] : hint + src;
+}
+function renderSkillForChannel(src, folderName, target) {
+  const installedName = target === "opencode" ? folderName : folderName.replace(/^omd-/, "omd:");
+  const rendered = src.replace(
+    /^name:\s*[^\r\n]+$/m,
+    `name: ${installedName}`
+  );
+  return target === "opencode" ? rendered.replace(/\bomd:([a-z0-9][a-z0-9-]*)\b/g, "omd-$1") : rendered;
+}
+function removeManagedLegacyCodexSkills(root) {
+  const legacyRoot = join2(root, ".codex", "skills");
+  if (!existsSync2(legacyRoot)) return [];
+  const results = [];
+  for (const entry of readdirSync(legacyRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const skillPath = join2(legacyRoot, entry.name, "SKILL.md");
+    if (!existsSync2(skillPath)) continue;
+    const content = readFileSync(skillPath, "utf8");
+    if (!isManagedSkillFile(content)) continue;
+    rmSync(skillPath, { force: true });
+    const dir = dirname(skillPath);
+    if (readdirSync(dir).length === 0) rmdirSync(dir);
+    results.push({
+      target: "codex",
+      skill: `legacy-skill:${entry.name}`,
+      destPath: skillPath,
+      status: "removed"
+    });
+  }
+  return results;
+}
+var IGNORED_SKILL_ENTRIES = /* @__PURE__ */ new Set([".runtime", "__pycache__", ".DS_Store"]);
+function isIgnoredSkillTreeEntry(name) {
+  return IGNORED_SKILL_ENTRIES.has(name) || name.endsWith(".pyc");
+}
+function shippedSkillTreeMatches(sourceDir, destinationDir) {
+  if (!existsSync2(destinationDir)) return false;
+  for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+    if (entry.name === "SKILL.md" || isIgnoredSkillTreeEntry(entry.name)) continue;
+    const source = join2(sourceDir, entry.name);
+    const destination = join2(destinationDir, entry.name);
+    if (!existsSync2(destination)) return false;
+    try {
+      const destinationStat = statSync(destination);
+      if (entry.isDirectory()) {
+        if (!destinationStat.isDirectory() || !shippedSkillTreeMatches(source, destination)) {
+          return false;
+        }
+      } else if (!destinationStat.isFile() || !readFileSync(source).equals(readFileSync(destination))) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+function parseSkillChannels(skillMd) {
+  const fm = /^---\n([\s\S]*?)\n---/.exec(skillMd);
+  if (!fm) return null;
+  const m = /^x-omd-channels:\s*(.+)$/m.exec(fm[1]);
+  if (!m) return null;
+  const valid = ["claude-code", "codex", "opencode"];
+  const list = m[1].split(/[,\s]+/).map((s) => s.trim()).filter((s) => valid.includes(s));
+  return list.length > 0 ? list : null;
+}
+function skillSupportedChannels(packageRoot, skill) {
+  return parseSkillChannels(readFileSync(join2(packageRoot, "skills", skill, "SKILL.md"), "utf8")) ?? ["claude-code", "codex", "opencode"];
+}
+function installOne(packageRoot, installRoot, plan, skill, force, globalDataRoot) {
+  const skillDir = join2(packageRoot, "skills", skill);
+  const src = readFileSync(join2(skillDir, "SKILL.md"), "utf8");
+  const channelSrc = withGlobalDataHint(
+    renderSkillForChannel(src, skill, plan.target),
+    globalDataRoot
+  );
+  const managed = withManagedMarker(channelSrc);
+  const channels = parseSkillChannels(src);
+  if (channels && !channels.includes(plan.target)) {
+    return {
+      target: plan.target,
+      skill,
+      destPath: join2(plan.destDir, skill + ".md"),
+      status: "skipped-incompat"
+    };
+  }
+  const extras = readdirSync(skillDir).filter(
+    (n) => n !== "SKILL.md" && !IGNORED_SKILL_ENTRIES.has(n)
+  );
+  const isMultiFile = extras.length > 0;
+  if (plan.layout !== "folder" && isMultiFile) {
+    return {
+      target: plan.target,
+      skill,
+      destPath: join2(plan.destDir, skill + ".md"),
+      status: "skipped-incompat"
+    };
+  }
+  const destPath = plan.layout === "folder" ? join2(plan.destDir, skill, "SKILL.md") : join2(plan.destDir, skill + ".md");
+  if (unsafeManagedPath(installRoot, destPath)) {
+    return { target: plan.target, skill, destPath, status: "skipped-drift", reason: "unsafe-path" };
+  }
+  const exists = existsSync2(destPath);
+  const existing = exists ? readFileSync(destPath, "utf8") : "";
+  if (exists && existing === managed) {
+    const extrasCurrent = !isMultiFile || shippedSkillTreeMatches(
+      skillDir,
+      join2(plan.destDir, skill)
+    );
+    if (extrasCurrent) {
+      return { target: plan.target, skill, destPath, status: "unchanged" };
+    }
+  }
+  if (exists && !isManagedSkillFile(existing) && !force) {
+    return { target: plan.target, skill, destPath, status: "skipped-drift" };
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  writeFileSync(destPath, managed, "utf8");
+  if (plan.layout === "folder" && isMultiFile) {
+    const destSkillDir = join2(plan.destDir, skill);
+    for (const entry of extras) {
+      cpSync(join2(skillDir, entry), join2(destSkillDir, entry), {
+        recursive: true,
+        filter: (s) => !/(\/__pycache__|\/\.runtime|\.pyc$|\.DS_Store$)/.test(s)
+      });
+    }
+  }
+  return {
+    target: plan.target,
+    skill,
+    destPath,
+    status: exists ? "updated" : "created"
+  };
+}
+function installHookFile(packageRoot, projectRoot, filename, force) {
+  const target = "claude-code";
+  const skillLabel = `hook:${filename}`;
+  const srcPath = join2(packageRoot, ".claude", "hooks", filename);
+  const destPath = join2(projectRoot, ".claude", "hooks", filename);
+  if (!existsSync2(srcPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  if (unsafeManagedPath(projectRoot, destPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift", reason: "unsafe-path" };
+  }
+  const src = readFileSync(srcPath, "utf8");
+  const managed = renderManagedHook(src);
+  const exists = existsSync2(destPath);
+  const existing = exists ? readFileSync(destPath, "utf8") : "";
+  if (exists && existing === managed) {
+    return { target, skill: skillLabel, destPath, status: "unchanged" };
+  }
+  if (exists && !force && !isSelfConsistentManagedHook(existing) && !isKnownLegacyHook(filename, existing)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  const tempPath = `${destPath}.omd-${process.pid}-${Date.now()}.tmp`;
+  try {
+    writeFileSync(tempPath, managed, { encoding: "utf8", flag: "wx" });
+    renameSync(tempPath, destPath);
+  } catch (error) {
+    rmSync(tempPath, { force: true });
+    throw error;
+  }
+  return { target, skill: skillLabel, destPath, status: exists ? "updated" : "created" };
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonObject(value) {
+  try {
+    const parsed = JSON.parse(value);
+    return isJsonObject(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function isOmdHook(value) {
+  if (!isJsonObject(value) || typeof value.command !== "string") return false;
+  const command = value.command;
+  const ownedHookPaths = [
+    "${CLAUDE_PROJECT_DIR}/.claude/hooks/skill-activation.cjs",
+    "${CLAUDE_PROJECT_DIR}/.claude/hooks/session-state-loader.cjs",
+    "${CLAUDE_PROJECT_DIR}/.claude/hooks/post-edit-watch.cjs",
+    "${CLAUDE_PROJECT_DIR}/.claude/hooks/session-end-foldin.cjs",
+    // Pre-v1.8 installs briefly registered this repository-only helper.
+    "${CLAUDE_PROJECT_DIR}/scripts/context_restore.sh"
+  ];
+  return ownedHookPaths.some((path) => command.includes(path));
+}
+var REPOSITORY_ONLY_CONTEXT_RESTORE_COMMAND = "bash ${CLAUDE_PROJECT_DIR}/scripts/context_restore.sh";
+function isRepositoryOnlySourceHook(value) {
+  return isJsonObject(value) && typeof value.command === "string" && value.command === REPOSITORY_ONLY_CONTEXT_RESTORE_COMMAND;
+}
+function stripHookEntries(groups, shouldStrip) {
+  const retained = [];
+  for (const group of groups) {
+    if (!isJsonObject(group) || !Array.isArray(group.hooks)) {
+      retained.push(group);
+      continue;
+    }
+    const hooks = group.hooks.filter((hook) => !shouldStrip(hook));
+    if (hooks.length > 0) retained.push({ ...group, hooks });
+  }
+  return retained;
+}
+function stripInstalledOmdHooks(groups) {
+  return stripHookEntries(groups, isOmdHook);
+}
+function stripRepositoryOnlySourceHooks(source) {
+  if (!isJsonObject(source.hooks)) return source;
+  const hooks = {};
+  for (const [event, groups] of Object.entries(source.hooks)) {
+    hooks[event] = Array.isArray(groups) ? stripHookEntries(groups, isRepositoryOnlySourceHook) : groups;
+  }
+  return { ...source, hooks };
+}
+function mergeClaudeSettings(existing, source) {
+  const installableSource = stripRepositoryOnlySourceHooks(source);
+  const existingHooks = isJsonObject(existing.hooks) ? existing.hooks : {};
+  const sourceHooks = isJsonObject(installableSource.hooks) ? installableSource.hooks : {};
+  const mergedHooks = { ...existingHooks };
+  for (const event of /* @__PURE__ */ new Set([...Object.keys(existingHooks), ...Object.keys(sourceHooks)])) {
+    const userGroups = Array.isArray(existingHooks[event]) ? existingHooks[event] : [];
+    const omdGroups = Array.isArray(sourceHooks[event]) ? sourceHooks[event] : [];
+    mergedHooks[event] = [...stripInstalledOmdHooks(userGroups), ...omdGroups];
+  }
+  return { ...installableSource, ...existing, hooks: mergedHooks };
+}
+function installSettingsJson(packageRoot, projectRoot, force) {
+  const target = "claude-code";
+  const skillLabel = "settings:.claude/settings.json";
+  const srcPath = join2(packageRoot, ".claude", "settings.json");
+  const destPath = join2(projectRoot, ".claude", "settings.json");
+  if (!existsSync2(srcPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  if (unsafeManagedPath(projectRoot, destPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift", reason: "unsafe-path" };
+  }
+  const src = readFileSync(srcPath, "utf8");
+  const sourceSettings = parseJsonObject(src);
+  if (!sourceSettings) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  const exists = existsSync2(destPath);
+  const existing = exists ? readFileSync(destPath, "utf8") : "";
+  const existingSettings = exists ? parseJsonObject(existing) : {};
+  if (exists && !existingSettings && !force) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  const merged = existingSettings ? mergeClaudeSettings(existingSettings, sourceSettings) : stripRepositoryOnlySourceHooks(sourceSettings);
+  if (exists && existingSettings && JSON.stringify(existingSettings) === JSON.stringify(merged)) {
+    return { target, skill: skillLabel, destPath, status: "unchanged" };
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  writeFileSync(destPath, JSON.stringify(merged, null, 2) + "\n", "utf8");
+  return { target, skill: skillLabel, destPath, status: exists ? "updated" : "created" };
+}
+function installDataFile(packageRoot, projectRoot, channelDir, dataFilename, _force, target) {
+  const skillLabel = `data:${dataFilename}`;
+  const srcPath = join2(packageRoot, "data", dataFilename);
+  const destPath = join2(projectRoot, channelDir, "data", dataFilename);
+  if (!existsSync2(srcPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  if (unsafeManagedPath(projectRoot, destPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift", reason: "unsafe-path" };
+  }
+  const src = readFileSync(srcPath, "utf8");
+  const exists = existsSync2(destPath);
+  const existing = exists ? readFileSync(destPath, "utf8") : "";
+  if (exists && existing === src) {
+    return { target, skill: skillLabel, destPath, status: "unchanged" };
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  writeFileSync(destPath, src, "utf8");
+  return {
+    target,
+    skill: skillLabel,
+    destPath,
+    status: exists ? "updated" : "created"
+  };
+}
+function installAgentFile(packageRoot, projectRoot, channel, filename, force, scope) {
+  const target = channel === "claude" ? "claude-code" : channel === "codex" ? "codex" : "opencode";
+  const skillLabel = `agent:${filename}`;
+  const parsed = parseCanonicalAgent(packageRoot, filename);
+  const nativeDataRoot = scope === "global" ? channel === "codex" ? join2(projectRoot, ".codex", "data") : join2(projectRoot, ".config", "opencode", "data") : channel === "codex" ? ".codex/data" : ".opencode/data";
+  const rendered = channel === "claude" ? renderClaudeAgent(parsed) : channel === "codex" ? renderCodexAgent(parsed, scope, nativeDataRoot) : renderOpenCodeAgent(parsed, scope, nativeDataRoot);
+  const destFilename = channel === "codex" ? filename.replace(/\.md$/, ".toml") : filename;
+  const channelRoot = channel === "claude" ? ".claude" : channel === "codex" ? ".codex" : scope === "global" ? join2(".config", "opencode") : ".opencode";
+  const destPath = join2(
+    projectRoot,
+    channelRoot,
+    "agents",
+    destFilename
+  );
+  const managed = channel === "claude" || channel === "opencode" ? rendered : "# omd:installed-agent \u2014 generated from agents/" + filename + " by `omd install-skills`. Do not edit; rerun the command to refresh.\n\n" + rendered;
+  if (unsafeManagedPath(projectRoot, destPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift", reason: "unsafe-path" };
+  }
+  const exists = existsSync2(destPath);
+  const existing = exists ? readFileSync(destPath, "utf8") : "";
+  if (exists && existing === managed) {
+    return { target, skill: skillLabel, destPath, status: "unchanged" };
+  }
+  const isManaged = channel === "claude" ? /\nomd_managed:\s*true\b/.test(existing) : channel === "codex" ? existing.startsWith("# omd:installed-agent") : existing.includes("<!-- omd:installed-agent");
+  if (exists && !isManaged && !force) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  writeFileSync(destPath, managed, "utf8");
+  return {
+    target,
+    skill: skillLabel,
+    destPath,
+    status: exists ? "updated" : "created"
+  };
+}
+function installReferenceCatalog(packageRoot, installRoot, channelDir, force) {
+  const srcRoot = join2(packageRoot, "web", "references");
+  if (!existsSync2(srcRoot)) return 0;
+  const destRoot = join2(installRoot, channelDir, "data", "references");
+  if (unsafeManagedPath(installRoot, destRoot)) return 0;
+  const manifestPath = join2(destRoot, ".omd-managed.json");
+  let previouslyManaged = /* @__PURE__ */ new Set();
+  let previousHashes = /* @__PURE__ */ new Map();
+  if (existsSync2(manifestPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(manifestPath, "utf8"));
+      if (isJsonObject(parsed) && Array.isArray(parsed.managedIds) && parsed.managedIds.every((id) => typeof id === "string")) {
+        previouslyManaged = new Set(parsed.managedIds);
+        if (isJsonObject(parsed.managedDesignHashes)) {
+          previousHashes = new Map(
+            Object.entries(parsed.managedDesignHashes).filter((entry) => typeof entry[1] === "string")
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  let available = 0;
+  const sourceIds = /* @__PURE__ */ new Set();
+  const managedDesignHashes = {};
+  for (const id of readdirSync(srcRoot)) {
+    const srcDesign = join2(srcRoot, id, "DESIGN.md");
+    if (!existsSync2(srcDesign)) continue;
+    sourceIds.add(id);
+    available++;
+    const destDesign = join2(destRoot, id, "DESIGN.md");
+    const src = readFileSync(srcDesign, "utf8");
+    const srcHash = createHash("sha256").update(src).digest("hex");
+    if (existsSync2(destDesign)) {
+      const existing = readFileSync(destDesign, "utf8");
+      if (existing === src) {
+        managedDesignHashes[id] = srcHash;
+        continue;
+      }
+      const previousHash = previousHashes.get(id);
+      const unchangedSinceLastInstall = previousHash !== void 0 && createHash("sha256").update(existing).digest("hex") === previousHash;
+      if (!force && !unchangedSinceLastInstall) {
+        continue;
+      }
+    }
+    mkdirSync(dirname(destDesign), { recursive: true });
+    writeFileSync(destDesign, src, "utf8");
+    managedDesignHashes[id] = srcHash;
+  }
+  if (existsSync2(destRoot)) {
+    for (const id of readdirSync(destRoot)) {
+      if (previouslyManaged.has(id) && !sourceIds.has(id)) {
+        const retiredRoot = join2(destRoot, id);
+        const retiredDesign = join2(retiredRoot, "DESIGN.md");
+        const previousHash = previousHashes.get(id);
+        const safeToRemove = existsSync2(retiredDesign) && (force || previousHash !== void 0 && createHash("sha256").update(readFileSync(retiredDesign, "utf8")).digest("hex") === previousHash);
+        if (safeToRemove) rmSync(retiredDesign, { force: true });
+        if (existsSync2(retiredRoot) && readdirSync(retiredRoot).length === 0) {
+          rmdirSync(retiredRoot);
+        }
+      }
+    }
+  }
+  mkdirSync(destRoot, { recursive: true });
+  writeFileSync(
+    manifestPath,
+    JSON.stringify({
+      schemaVersion: 2,
+      managedIds: Object.keys(managedDesignHashes).sort(),
+      managedDesignHashes
+    }, null, 2) + "\n",
+    "utf8"
+  );
+  return available;
+}
+var CURSOR_RULE_BODY = [
+  "The authoritative design spec lives at `@DESIGN.md` (repo root). Open and read before generating/modifying UI.",
+  "",
+  "Pending preference corrections: `@.omd/preferences.md`.",
+  "",
+  "Precedence: DESIGN.md > preferences.md > framework defaults.",
+  "",
+  "If DESIGN.md is missing and the user asks to establish a design system:",
+  "1. Inspect the existing product, routes, and constraints.",
+  "2. Read `.claude/data/reference-fingerprints.json` and only recommend ids present there.",
+  "3. Load the chosen `.claude/data/references/<id>/DESIGN.md`, explain the project-specific delta, and ask before writing root DESIGN.md.",
+  "4. Unknown reference fields stay absent; never substitute a system font, generic component, or guessed token as a brand fact.",
+  "",
+  "When applying DESIGN.md, preserve existing behavior and user copy unless asked, then verify the actual product route and accessibility before reporting completion.",
+  "Cursor receives this rule and the catalog, not OmD named skills or sub-agents; execute the contract directly from natural-language requests."
+].join("\n");
+function renderCursorRule() {
+  const hash = createHash("sha256").update(CURSOR_RULE_BODY).digest("hex").slice(0, 12);
+  return [
+    "---",
+    "description: Authoritative brand & UI design system. Read DESIGN.md before UI work.",
+    "globs:",
+    '  - "**/*.tsx"',
+    '  - "**/*.jsx"',
+    '  - "**/*.vue"',
+    '  - "**/*.svelte"',
+    '  - "**/*.css"',
+    '  - "**/*.scss"',
+    '  - "**/tailwind.config.*"',
+    '  - "**/components/**"',
+    '  - "**/app/**/page.*"',
+    "alwaysApply: false",
+    "---",
+    "",
+    `<!-- omd:start v=1 hash=${hash} -->`,
+    CURSOR_RULE_BODY,
+    "<!-- omd:end -->",
+    ""
+  ].join("\n");
+}
+function installCursorRule(installRoot, force) {
+  const target = "cursor";
+  const skillLabel = "rule:omd-design.mdc";
+  const destPath = join2(installRoot, ".cursor", "rules", "omd-design.mdc");
+  const rendered = renderCursorRule();
+  if (unsafeManagedPath(installRoot, destPath)) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift", reason: "unsafe-path" };
+  }
+  const exists = existsSync2(destPath);
+  const existing = exists ? readFileSync(destPath, "utf8") : "";
+  if (exists && existing === rendered) {
+    return { target, skill: skillLabel, destPath, status: "unchanged" };
+  }
+  if (exists && !existing.includes("<!-- omd:start") && !force) {
+    return { target, skill: skillLabel, destPath, status: "skipped-drift" };
+  }
+  mkdirSync(dirname(destPath), { recursive: true });
+  writeFileSync(destPath, rendered, "utf8");
+  return { target, skill: skillLabel, destPath, status: exists ? "updated" : "created" };
+}
+var STATUS_LABEL = {
+  created: pc.green("created"),
+  updated: pc.cyan("updated"),
+  removed: pc.magenta("removed"),
+  unchanged: pc.dim("unchanged"),
+  "skipped-drift": pc.yellow("skipped"),
+  "skipped-incompat": pc.yellow("skipped (claude-code only)")
+};
+function autoDetectTargets(projectRoot) {
+  const presence = detectInstalledAgents(projectRoot);
+  const targets = [];
+  if (presence.claudeCode) targets.push("claude-code");
+  if (presence.codex) targets.push("codex");
+  if (presence.opencode) targets.push("opencode");
+  if (presence.cursor) targets.push("cursor");
+  if (targets.length === 0) {
+    return ["claude-code", "codex", "opencode"];
+  }
+  return targets;
+}
+async function runInstallSkills(opts = {}) {
+  const projectRoot = opts.dir ?? process.cwd();
+  const packageRoot = findPackageRoot();
+  if (!packageRoot) {
+    console.error(pc.red("omd install-skills: package data not found"));
+    return 1;
+  }
+  const allSkills = listShippedSkills(packageRoot);
+  if (allSkills.length === 0) {
+    console.error(pc.red("omd install-skills: no skills found in package"));
+    return 1;
+  }
+  const allAgents = listCanonicalAgents(packageRoot);
+  if (opts.agents) {
+    const invalidTargets = opts.agents.filter(
+      (target) => !VALID_SKILL_TARGETS.includes(target)
+    );
+    if (invalidTargets.length > 0) {
+      console.error(
+        pc.red(
+          `omd install-skills: invalid agent channel(s): ${invalidTargets.join(", ")}. Choose from ${VALID_SKILL_TARGETS.join(", ")}.`
+        )
+      );
+      return 1;
+    }
+    if (opts.agents.length === 0) {
+      console.error(pc.red("omd install-skills: no agent channel selected"));
+      return 1;
+    }
+  }
+  if (opts.skillsFilter) {
+    const unknownSkills = opts.skillsFilter.filter((skill) => !allSkills.includes(skill));
+    if (unknownSkills.length > 0) {
+      console.error(
+        pc.red(`omd install-skills: unknown skill(s): ${unknownSkills.join(", ")}`)
+      );
+      return 1;
+    }
+    if (opts.skillsFilter.length === 0) {
+      console.error(pc.red("omd install-skills: no skill selected"));
+      return 1;
+    }
+  }
+  if (opts.agentsFilter) {
+    const availableAgentIds = new Set(allAgents.map((name) => name.replace(/\.md$/, "")));
+    const unknownAgents = opts.agentsFilter.filter((agent) => !availableAgentIds.has(agent));
+    if (unknownAgents.length > 0) {
+      console.error(
+        pc.red(`omd install-skills: unknown sub-agent(s): ${unknownAgents.join(", ")}`)
+      );
+      return 1;
+    }
+  }
+  const force = opts.force ?? false;
+  const minimal = opts.skillsOnly === true;
+  let scope = opts.global ? "global" : "project";
+  p.intro(
+    pc.bold("omd install-skills") + pc.dim(`  (${relative(process.cwd(), projectRoot) || "."})`)
+  );
+  const isTTY = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  const interactive = isTTY && !opts.all;
+  const detected = autoDetectTargets(projectRoot);
+  const presence = detectInstalledAgents(projectRoot);
+  const actuallyDetected = [
+    presence.claudeCode ? "claude-code" : null,
+    presence.codex ? "codex" : null,
+    presence.opencode ? "opencode" : null,
+    presence.cursor ? "cursor" : null
+  ].filter((x) => x !== null);
+  if (!opts.global && interactive) {
+    const scopeResult = await p.select({
+      message: "Install scope \xB7 \uC5B4\uB514\uC5D0 \uC124\uCE58\uD560\uAE4C\uC694?",
+      options: [
+        { value: "project", label: "Project", hint: `${relative(process.cwd(), projectRoot) || "."} \xB7 \uC774 \uD504\uB85C\uC81D\uD2B8\uB9CC` },
+        { value: "global", label: "Global", hint: "~/.claude \xB7 ~/.agents \xB7 ~/.config/opencode (hooks/settings \uC81C\uC678)" }
+      ],
+      initialValue: "project"
+    });
+    if (p.isCancel(scopeResult)) {
+      p.cancel("Install cancelled.");
+      return 130;
+    }
+    scope = scopeResult;
+  }
+  let skills;
+  if (opts.skillsFilter) {
+    skills = allSkills.filter((s) => opts.skillsFilter.includes(s));
+  } else if (interactive) {
+    const skillResult = await p.multiselect({
+      message: "Skills \xB7 space = \uD1A0\uAE00 \xB7 a = \uC804\uCCB4 \xB7 enter = \uD655\uC778 (default ALL)",
+      options: allSkills.map((s) => ({ value: s, label: s, hint: "omd skill" })),
+      initialValues: allSkills,
+      required: true
+    });
+    if (p.isCancel(skillResult)) {
+      p.cancel("Install cancelled.");
+      return 130;
+    }
+    skills = skillResult;
+  } else {
+    skills = allSkills;
+  }
+  let canonicalAgents;
+  if (minimal) {
+    canonicalAgents = [];
+  } else if (opts.agentsFilter) {
+    canonicalAgents = allAgents.filter((a) => opts.agentsFilter.includes(a.replace(/\.md$/, "")));
+  } else if (interactive && allAgents.length > 0) {
+    const agentResult = await p.multiselect({
+      message: "Sub-agents \xB7 space = \uD1A0\uAE00 \xB7 a = \uC804\uCCB4 \xB7 enter = \uD655\uC778 (default ALL)",
+      options: allAgents.map((a) => ({ value: a, label: a.replace(/\.md$/, ""), hint: "subagent" })),
+      initialValues: allAgents,
+      required: false
+    });
+    if (p.isCancel(agentResult)) {
+      p.cancel("Install cancelled.");
+      return 130;
+    }
+    canonicalAgents = agentResult;
+  } else {
+    canonicalAgents = allAgents;
+  }
+  const supportedTargets = (() => {
+    const set = new Set(skills.flatMap((s) => skillSupportedChannels(packageRoot, s)));
+    set.add("cursor");
+    return targetsAvailableForScope(
+      ["claude-code", "codex", "opencode", "cursor"].filter((t) => set.has(t)),
+      scope
+    );
+  })();
+  const channelLabel = {
+    "claude-code": "Claude Code",
+    codex: "Codex",
+    opencode: "OpenCode",
+    cursor: "Cursor"
+  };
+  const channelDir = {
+    "claude-code": ".claude",
+    codex: ".codex",
+    opencode: ".opencode",
+    cursor: ".cursor"
+  };
+  let targets;
+  if (opts.agents) {
+    targets = opts.agents;
+  } else if (interactive) {
+    const defaults = actuallyDetected.filter((t) => supportedTargets.includes(t));
+    const targetResult = await p.multiselect({
+      message: "Agent channels \xB7 \uC5B4\uB514\uC5D0 \uC124\uCE58\uD560\uAE4C\uC694? \xB7 space = \uD1A0\uAE00 \xB7 enter = \uD655\uC778",
+      options: supportedTargets.map((t) => ({
+        value: t,
+        label: channelLabel[t],
+        hint: actuallyDetected.includes(t) ? `${channelDir[t]}/ detected` : ""
+      })),
+      initialValues: defaults.length > 0 ? defaults : supportedTargets,
+      required: true
+    });
+    if (p.isCancel(targetResult)) {
+      p.cancel("Install cancelled.");
+      return 130;
+    }
+    targets = targetResult;
+  } else {
+    targets = opts.all ? ["claude-code", "codex", "opencode"] : minimal ? actuallyDetected.length > 0 ? actuallyDetected : ["claude-code"] : detected;
+    const narrowed = targets.filter((t) => supportedTargets.includes(t));
+    if (narrowed.length > 0) targets = narrowed;
+  }
+  if (targets.length === 0) {
+    console.error(pc.red("omd install-skills: no compatible agent channel selected"));
+    return 1;
+  }
+  if (scope === "global" && targets.includes("cursor")) {
+    console.error(
+      pc.red("omd install-skills: Cursor rules are project-scoped. Run the Cursor install from the project root without --global.")
+    );
+    return 1;
+  }
+  if (opts.repairHooks && (scope !== "project" || minimal || !targets.includes("claude-code"))) {
+    console.error(
+      pc.red("omd install-skills: --repair-hooks requires a project-scoped Claude Code target and cannot be combined with --skills-only.")
+    );
+    return 1;
+  }
+  const installRoot = scope === "global" ? homedir() : projectRoot;
+  const skillChannelTargets = targets.filter(
+    (t) => t !== "cursor"
+  );
+  const plans = skillChannelTargets.map((t) => planForTarget(installRoot, t, scope));
+  p.log.message(
+    pc.bold("Scope: ") + pc.cyan(scope) + pc.dim(scope === "global" ? "  (channel user directories)" : `  (${relative(process.cwd(), projectRoot) || "."})`)
+  );
+  p.log.message(
+    pc.bold(`Skills (${skills.length}): `) + skills.map((s) => pc.cyan(s)).join(", ")
+  );
+  if (minimal) {
+    canonicalAgents = [];
+    p.log.message(pc.bold("Agents: ") + pc.dim("skipped (--skills-only)"));
+  } else if (canonicalAgents.length > 0) {
+    p.log.message(
+      pc.bold(`Agents (${canonicalAgents.length}): `) + canonicalAgents.map((a) => pc.cyan(a.replace(/\.md$/, ""))).join(", ")
+    );
+  }
+  p.log.message(
+    pc.bold("Targets: ") + targets.map((t) => pc.cyan(t)).join(", ")
+  );
+  const results = [];
+  let catalogCount = 0;
+  const catalogDestinations = /* @__PURE__ */ new Set();
+  for (const plan of plans) {
+    const dataDir = dataDirForScope(plan.target, targets, scope);
+    const globalDataRoot = scope === "global" && dataDir ? join2(installRoot, dataDir, "data") : null;
+    for (const skill of skills) {
+      results.push(installOne(packageRoot, installRoot, plan, skill, force, globalDataRoot));
+    }
+  }
+  if (targets.includes("codex")) {
+    results.push(...removeManagedLegacyCodexSkills(installRoot));
+  }
+  for (const target of targets) {
+    if (target === "claude-code") {
+      for (const filename of canonicalAgents) {
+        results.push(installAgentFile(packageRoot, installRoot, "claude", filename, force, scope));
+      }
+    } else if (target === "codex") {
+      for (const filename of canonicalAgents) {
+        results.push(installAgentFile(packageRoot, installRoot, "codex", filename, force, scope));
+      }
+    } else if (target === "opencode") {
+      for (const filename of canonicalAgents) {
+        results.push(installAgentFile(packageRoot, installRoot, "opencode", filename, force, scope));
+      }
+    }
+  }
+  if (!minimal) {
+    if (targets.includes("cursor")) {
+      results.push(installCursorRule(installRoot, force));
+    }
+    const dataFiles = [
+      "reference-fingerprints.json",
+      "reference-tags.md",
+      "vocabulary.json",
+      "synonyms.json",
+      "opt-out-corpus.json"
+    ];
+    for (const target of targets) {
+      const dataDir = dataDirForScope(target, targets, scope);
+      if (!dataDir) continue;
+      for (const dataFile of dataFiles) {
+        results.push(installDataFile(packageRoot, installRoot, dataDir, dataFile, force, target));
+      }
+    }
+    for (const target of targets) {
+      const dataDir = dataDirForScope(target, targets, scope);
+      if (dataDir) {
+        const catalogRoot = join2(installRoot, dataDir, "data", "references");
+        if (unsafeManagedPath(installRoot, catalogRoot)) {
+          results.push({
+            target,
+            skill: "data:references",
+            destPath: catalogRoot,
+            status: "skipped-drift",
+            reason: "unsafe-path"
+          });
+          continue;
+        }
+        const count = installReferenceCatalog(packageRoot, installRoot, dataDir, force);
+        catalogCount = Math.max(catalogCount, count);
+        if (count > 0) {
+          catalogDestinations.add(`${dataDir}/data/references/<id>/DESIGN.md`);
+        }
+      }
+    }
+    for (const target of targets) {
+      if (target === "cursor") continue;
+      const cd = dataDirForScope(target, targets, scope);
+      if (!cd) continue;
+      for (const helper of ["ctx-prime.cjs", "context.cjs"]) {
+        const srcHelper = join2(packageRoot, "scripts", helper);
+        if (!existsSync2(srcHelper)) continue;
+        const destHelper = join2(installRoot, cd, "data", "scripts", helper);
+        if (unsafeManagedPath(installRoot, destHelper)) {
+          results.push({
+            target,
+            skill: `data-script:${helper}`,
+            destPath: destHelper,
+            status: "skipped-drift",
+            reason: "unsafe-path"
+          });
+          continue;
+        }
+        const srcTxt = readFileSync(srcHelper, "utf8");
+        if (existsSync2(destHelper) && readFileSync(destHelper, "utf8") === srcTxt) continue;
+        mkdirSync(dirname(destHelper), { recursive: true });
+        writeFileSync(destHelper, srcTxt, "utf8");
+      }
+    }
+    if (scope === "project" && targets.includes("claude-code")) {
+      for (const hookFile of CLAUDE_HOOK_PATHS) {
+        results.push(
+          installHookFile(
+            packageRoot,
+            installRoot,
+            hookFile,
+            force || opts.repairHooks === true
+          )
+        );
+      }
+      results.push(installSettingsJson(packageRoot, installRoot, force));
+    }
+  }
+  p.log.message(pc.bold("\nResults:"));
+  for (const r of results) {
+    const rel = relative(installRoot, r.destPath);
+    p.log.message(
+      `  ${STATUS_LABEL[r.status]}  ${pc.dim(r.target.padEnd(12))} ${rel}`
+    );
+  }
+  const driftCount = results.filter((r) => r.status === "skipped-drift").length;
+  const changedCount = results.filter(
+    (r) => r.status === "created" || r.status === "updated" || r.status === "removed"
+  ).length;
+  const currentCount = results.filter((r) => r.status === "unchanged").length;
+  if (driftCount > 0) {
+    const unsafeCount = results.filter(
+      (result) => result.status === "skipped-drift" && result.reason === "unsafe-path"
+    ).length;
+    const hookDrift = results.some(
+      (result) => result.status === "skipped-drift" && result.skill.startsWith("hook:")
+    );
+    const repairHint = unsafeCount > 0 ? ` ${unsafeCount} unsafe symlinked managed path(s) were refused; replace them with project-local files and run doctor. --force will not bypass this safety check.` : hookDrift ? " Use --repair-hooks for Claude hooks only, or --force to overwrite all unmarked files." : " Rerun with --force to overwrite.";
+    p.outro(
+      pc.yellow(
+        `${changedCount} changed, ${currentCount} already current, ${driftCount} skipped (existing files lack a valid omd ownership marker).${repairHint}`
+      )
+    );
+    return 2;
+  }
+  if (minimal) {
+    for (const r of results.filter((x) => x.status === "skipped-incompat")) {
+      p.log.warn(
+        `${pc.bold(r.skill)} ${pc.dim("skipped for ")}${pc.cyan(r.target)}${pc.dim(" \u2014 declares x-omd-channels (channel not supported).")}`
+      );
+    }
+    const installed = results.filter(
+      (r) => r.status === "created" || r.status === "updated" || r.status === "unchanged"
+    );
+    if (installed.length === 0) {
+      p.outro(pc.yellow("Nothing installed \u2014 no compatible skill/channel match."));
+      return 0;
+    }
+    p.outro(
+      pc.green(
+        `Done. Installed ${skills.map((s) => pc.bold(s)).join(", ")} ${scope === "global" ? `globally for ${targets.join(", ")}` : `for ${targets.join(", ")}`}.`
+      ) + pc.dim("  \u2192  restart your agent, then use the skill (e.g. ") + pc.cyan("/claude-design") + pc.dim(").")
+    );
+    return 0;
+  }
+  const cursorOnly = targets.length === 1 && targets[0] === "cursor";
+  const nextSteps = cursorOnly ? [
+    `${pc.bold("Restart Cursor, then establish or apply DESIGN.md:")}`,
+    "",
+    `  ${pc.cyan("EN")}  ${pc.dim("Set up our design system \u2014 Toss-style, for a family meal-tracking app. Ask before writing DESIGN.md.")}`,
+    `  ${pc.cyan("KR")}  ${pc.dim("\uD1A0\uC2A4 \uC2A4\uD0C0\uC77C\uB85C \uAC00\uC871 \uC2DD\uB2E8 \uACF5\uC720 \uC571 \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C\uC744 \uC81C\uC548\uD558\uACE0 DESIGN.md \uC791\uC131 \uC804\uC5D0 \uD655\uC778\uD574\uC918")}`,
+    "",
+    `${pc.dim("Cursor uses the installed rule + local catalog directly. It does not receive OmD named skills or sub-agents.")}`,
+    `${pc.dim("You can also choose a reference in the Builder and download DESIGN.md before asking Cursor to build.")}`,
+    "",
+    `${pc.yellow("\u26A0 Already-running session?")} ${pc.dim("Restart Cursor so it reloads the project rule.")}`
+  ].join("\n") : [
+    `${pc.bold("Restart your agent, then type your first prompt:")}`,
+    "",
+    `  ${pc.cyan("EN")}  ${pc.dim("Set up our design system \u2014 Toss-style, for a family meal-tracking app.")}`,
+    `  ${pc.cyan("KR")}  ${pc.dim("\uD1A0\uC2A4 \uC2A4\uD0C0\uC77C\uB85C \uAC00\uC871 \uC2DD\uB2E8 \uACF5\uC720 \uC571 \uB514\uC790\uC778 \uC2DC\uC2A4\uD15C \uC7A1\uC544\uC918")}`,
+    "",
+    `${pc.dim("Your agent routes through omd:init and writes DESIGN.md after confirmation. Then build against it:")}`,
+    `  ${pc.cyan("EN")}  ${pc.dim("Design the home screen.")}   ${pc.cyan("KR")}  ${pc.dim("\uD648 \uD654\uBA74 \uB514\uC790\uC778\uD574\uC918")}`,
+    "",
+    `${pc.dim('Full walkthrough \u2192 "Your first 60 seconds" in the README. Routing is automatic \u2014 no slash command needed.')}`,
+    `${pc.dim("Power user: ")}${pc.cyan("/omd-harness <task>")}${pc.dim(" \u2014 jump straight into the pipeline.")}`,
+    "",
+    `${pc.yellow("\u26A0 Already-running session?")} ${pc.dim("Restart the coding agent after install. Codex must also trust the project before it loads project-local .codex/agents roles.")}`
+  ].join("\n");
+  p.note(nextSteps, "Next");
+  const hookCount = scope === "project" && targets.includes("claude-code") ? 4 : 0;
+  if (catalogCount > 0) {
+    p.log.message(
+      pc.bold("Reference catalog: ") + pc.cyan(`${catalogCount}`) + pc.dim(` DESIGN.md synced \u2192 ${[...catalogDestinations].join(" + ")}`)
+    );
+  }
+  const reportedSkillCount = skillChannelTargets.length > 0 ? skills.length : 0;
+  const reportedAgentCount = skillChannelTargets.length > 0 ? canonicalAgents.length : 0;
+  p.outro(
+    pc.green(
+      `Done. ${reportedSkillCount} skills \xB7 ${reportedAgentCount} sub-agents \xB7 ${hookCount} hooks \xB7 ${catalogCount} catalog refs ready (${changedCount} changed \xB7 ${currentCount} already current)${scope === "global" ? " globally (channel user directories)" : ""}.`
+    )
+  );
+  return 0;
+}
+export {
+  dataDirFor,
+  runInstallSkills,
+  targetsAvailableForScope
+};
+//# sourceMappingURL=install-skills-ZZFNJ2II.js.map