@synity/bitrix-skills 1.3.0

package/dist/cli.js

@@ -0,0 +1,1510 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/.pnpm/tsup@8.5.1_postcss@8.5.14_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "node_modules/.pnpm/tsup@8.5.1_postcss@8.5.14_typescript@5.9.3/node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/lib/fs-safety.ts
+import { lstat } from "fs/promises";
+import path2 from "path";
+async function assertNotSymlink(destPath) {
+  try {
+    const stat2 = await lstat(destPath);
+    if (stat2.isSymbolicLink()) {
+      throw new Error(
+        `Refusing to overwrite symlink: ${destPath}. Remove it manually then re-run install.`
+      );
+    }
+  } catch (err) {
+    if (err.code === "ENOENT") return;
+    throw err;
+  }
+}
+function assertContainedIn(destAbs, allowedRoot, label) {
+  const root = allowedRoot.endsWith(path2.sep) ? allowedRoot : allowedRoot + path2.sep;
+  if (!destAbs.startsWith(root)) {
+    throw new Error(
+      `"${label}" resolves outside allowed root (${root}). Refusing \u2014 possible path traversal.`
+    );
+  }
+}
+var init_fs_safety = __esm({
+  "src/lib/fs-safety.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/features/task-sync/lib/file-ops.ts
+import { createHash as createHash2 } from "crypto";
+import { readFile, access, mkdir, writeFile, rename, chmod } from "fs/promises";
+import { constants } from "fs";
+import path3 from "path";
+async function sha256File(filePath) {
+  const buf = await readFile(filePath);
+  return createHash2("sha256").update(buf).digest("hex");
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDir(dirPath) {
+  await mkdir(dirPath, { recursive: true });
+}
+async function atomicWrite(filePath, content, mode = 420) {
+  await ensureDir(path3.dirname(filePath));
+  const tmp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile(tmp, content, { mode });
+  await chmod(tmp, mode);
+  await rename(tmp, filePath);
+}
+var init_file_ops = __esm({
+  "src/features/task-sync/lib/file-ops.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/features/task-sync/lib/project-root.ts
+import path4 from "path";
+async function detectProjectRoot(startDir) {
+  let dir = path4.resolve(startDir);
+  const root = path4.parse(dir).root;
+  while (true) {
+    for (const marker of ROOT_MARKERS) {
+      if (await fileExists(path4.join(dir, marker))) {
+        return dir;
+      }
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir || dir === root) {
+      break;
+    }
+    dir = parent;
+  }
+  dir = path4.resolve(startDir);
+  while (true) {
+    if (await fileExists(path4.join(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = path4.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return path4.resolve(startDir);
+}
+async function hasGitDir(rootDir) {
+  return fileExists(path4.join(rootDir, ".git"));
+}
+var ROOT_MARKERS;
+var init_project_root = __esm({
+  "src/features/task-sync/lib/project-root.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_ops();
+    ROOT_MARKERS = [".git", "pnpm-workspace.yaml"];
+  }
+});
+
+// src/features/task-sync/lib/manifest.ts
+var manifest_exports = {};
+__export(manifest_exports, {
+  loadManifest: () => loadManifest,
+  resolveAssetsDir: () => resolveAssetsDir
+});
+import { readFile as readFile2 } from "fs/promises";
+import { existsSync as existsSync3 } from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function resolveAssetsDir() {
+  const candidates = [
+    // From dist/ (cli.js context): ../src/features/task-sync/assets
+    path5.resolve(__dirname2, "../src/features/task-sync/assets"),
+    // From dist/features/task-sync/ (index.js context): ../../../src/features/task-sync/assets
+    path5.resolve(__dirname2, "../../../src/features/task-sync/assets"),
+    // Dev: src/features/task-sync/lib/ → ../assets
+    path5.resolve(__dirname2, "../assets"),
+    // Legacy fallbacks (should not match before correct paths above)
+    path5.resolve(__dirname2, "../../assets"),
+    path5.resolve(__dirname2, "../../../assets"),
+    path5.resolve(__dirname2, "../../../../assets")
+  ];
+  for (const c of candidates) {
+    if (existsSync3(path5.join(c, "manifest.json"))) {
+      return c;
+    }
+  }
+  return candidates[0];
+}
+async function loadManifest() {
+  const dir = resolveAssetsDir();
+  const manifestPath = path5.join(dir, "manifest.json");
+  if (!await fileExists(manifestPath)) {
+    throw new Error(`assets/manifest.json not found at ${manifestPath} (was 'pnpm build' run?)`);
+  }
+  const raw = await readFile2(manifestPath, "utf8");
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`malformed manifest.json: ${err.message}`);
+  }
+  validateManifest(parsed);
+  return parsed;
+}
+function validateManifest(obj) {
+  if (!obj || typeof obj !== "object") throw new Error("manifest must be an object");
+  const m = obj;
+  if (typeof m["version"] !== "string") throw new Error("manifest.version must be string");
+  if (!Array.isArray(m["files"])) throw new Error("manifest.files must be array");
+  for (const f of m["files"]) {
+    if (!f || typeof f !== "object") throw new Error("manifest.files[] entry must be object");
+    const e = f;
+    if (typeof e["src"] !== "string") throw new Error("manifest entry.src must be string");
+    if (typeof e["sha256"] !== "string") throw new Error("manifest entry.sha256 must be string");
+    if (typeof e["size"] !== "number") throw new Error("manifest entry.size must be number");
+    if (typeof e["mode"] !== "number") throw new Error("manifest entry.mode must be number");
+  }
+}
+var __dirname2;
+var init_manifest = __esm({
+  "src/features/task-sync/lib/manifest.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_ops();
+    __dirname2 = path5.dirname(fileURLToPath3(import.meta.url));
+  }
+});
+
+// src/features/task-sync/lib/dest-map.ts
+var dest_map_exports = {};
+__export(dest_map_exports, {
+  buildDestMap: () => buildDestMap
+});
+import path6 from "path";
+import os from "os";
+function buildDestMap(manifest, cwd) {
+  const out = [];
+  const home = os.homedir();
+  const skillsRoot = path6.join(home, ".claude", "skills");
+  for (const entry of manifest.files) {
+    const src = entry.src;
+    if (src.startsWith("scripts/")) {
+      const name = src.slice("scripts/".length);
+      const destRel = path6.posix.join(".claude/scripts", name);
+      out.push({
+        manifestEntry: entry,
+        destAbs: path6.resolve(cwd, destRel),
+        destRel,
+        category: "script"
+      });
+    } else if (src.startsWith("githooks/")) {
+      const name = src.slice("githooks/".length);
+      const destRel = path6.posix.join(".githooks", name);
+      out.push({
+        manifestEntry: entry,
+        destAbs: path6.resolve(cwd, destRel),
+        destRel,
+        category: "githook",
+        optionalFlag: "noGithooks"
+      });
+    } else if (src.startsWith("rules/")) {
+      const name = src.slice("rules/".length);
+      const destRel = path6.posix.join(".claude/rules", name);
+      out.push({
+        manifestEntry: entry,
+        destAbs: path6.resolve(cwd, destRel),
+        destRel,
+        category: "rule"
+      });
+    } else if (src.startsWith("docs/")) {
+      const name = src.slice("docs/".length);
+      const destRel = path6.posix.join("docs", name);
+      out.push({
+        manifestEntry: entry,
+        destAbs: path6.resolve(cwd, destRel),
+        destRel,
+        category: "doc"
+      });
+    } else if (src.startsWith("workflows/")) {
+      const name = src.slice("workflows/".length);
+      const destRel = path6.posix.join(".github/workflows", name);
+      out.push({
+        manifestEntry: entry,
+        destAbs: path6.resolve(cwd, destRel),
+        destRel,
+        category: "workflow",
+        optionalFlag: "noWorkflow"
+      });
+    } else if (src.startsWith("skill/")) {
+      const name = src.slice("skill/".length);
+      const destAbs = path6.resolve(home, ".claude", "skills", "bitrix-sync-install", name);
+      const destRel = path6.posix.join("~/.claude/skills/bitrix-sync-install", name);
+      out.push({
+        manifestEntry: entry,
+        destAbs,
+        destRel,
+        category: "skill",
+        optionalFlag: "noSkill"
+      });
+    }
+  }
+  for (const e of out) {
+    const allowedRoot = e.category === "skill" ? skillsRoot : cwd;
+    assertContainedIn(e.destAbs, allowedRoot, e.manifestEntry.src);
+  }
+  return out;
+}
+var init_dest_map = __esm({
+  "src/features/task-sync/lib/dest-map.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs_safety();
+  }
+});
+
+// src/features/task-sync/lib/settings-merge.ts
+import { readFile as readFile3 } from "fs/promises";
+import deepmerge from "deepmerge";
+function arrayMerge(target, source) {
+  const combined = [...target, ...source];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const item of combined) {
+    const key = JSON.stringify(item);
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(item);
+  }
+  return result;
+}
+function mergeSettings(existing, template) {
+  return deepmerge(existing, template, {
+    arrayMerge,
+    clone: true
+  });
+}
+async function loadSettingsFile(filePath) {
+  if (!await fileExists(filePath)) return {};
+  const raw = await readFile3(filePath, "utf8");
+  if (!raw.trim()) return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("settings.json must be a JSON object");
+    }
+    return parsed;
+  } catch (err) {
+    throw new Error(`malformed settings.json (${filePath}): ${err.message}`);
+  }
+}
+async function writeSettingsFile(filePath, obj) {
+  const json = JSON.stringify(obj, null, 2) + "\n";
+  await atomicWrite(filePath, json, 420);
+}
+function isBitrixHookEntry(entry) {
+  const cmds = (entry.hooks ?? []).map((h) => h.command).filter((c) => typeof c === "string");
+  return cmds.some((c) => /\.claude\/scripts\/bitrix-/.test(c));
+}
+function removeBitrixHooks(settings) {
+  const cloned = JSON.parse(JSON.stringify(settings));
+  const hooks = cloned.hooks;
+  if (!hooks) return cloned;
+  for (const trigger of Object.keys(hooks)) {
+    const list = hooks[trigger];
+    if (!Array.isArray(list)) continue;
+    const filtered = list.filter((entry) => !isBitrixHookEntry(entry));
+    if (filtered.length === 0) {
+      delete hooks[trigger];
+    } else {
+      hooks[trigger] = filtered;
+    }
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete cloned.hooks;
+  }
+  return cloned;
+}
+var BITRIX_HOOKS_TEMPLATE;
+var init_settings_merge = __esm({
+  "src/features/task-sync/lib/settings-merge.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_ops();
+    BITRIX_HOOKS_TEMPLATE = {
+      hooks: {
+        SessionStart: [
+          { hooks: [{ type: "command", command: "bash .claude/scripts/bitrix-session-check.sh" }] }
+        ],
+        PreToolUse: [
+          { matcher: "Skill", hooks: [{ type: "command", command: "bash .claude/scripts/bitrix-skill-start.sh" }] }
+        ],
+        PostToolUse: [
+          { matcher: "Skill", hooks: [{ type: "command", command: "bash .claude/scripts/bitrix-skill-end.sh" }] }
+        ],
+        Stop: [
+          { hooks: [{ type: "command", command: "bash .claude/scripts/bitrix-session-sync.sh" }] }
+        ]
+      }
+    };
+  }
+});
+
+// src/features/task-sync/lib/skill-refs.ts
+import { readFile as readFile4, writeFile as writeFile2, mkdir as mkdir2, rm, access as access2 } from "fs/promises";
+import path7 from "path";
+import os2 from "os";
+function getSkillDir() {
+  return path7.join(os2.homedir(), ".claude/skills/bitrix-sync-install");
+}
+function getRefsFile() {
+  return path7.join(getSkillDir(), ".refs.json");
+}
+async function loadRefs() {
+  try {
+    const raw = await readFile4(getRefsFile(), "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && Array.isArray(parsed.projects)) {
+      return { version: 1, projects: [...parsed.projects] };
+    }
+  } catch {
+  }
+  return { version: 1, projects: [] };
+}
+async function saveRefs(refs) {
+  await mkdir2(getSkillDir(), { recursive: true });
+  await writeFile2(getRefsFile(), JSON.stringify(refs, null, 2) + "\n", "utf8");
+}
+async function addProjectRef(projectPath) {
+  const abs = path7.resolve(projectPath);
+  const refs = await loadRefs();
+  if (!refs.projects.includes(abs)) {
+    refs.projects.push(abs);
+    await saveRefs(refs);
+  }
+  return refs.projects;
+}
+async function removeProjectRef(projectPath) {
+  const abs = path7.resolve(projectPath);
+  const refs = await loadRefs();
+  const before = refs.projects.length;
+  refs.projects = refs.projects.filter((p) => p !== abs);
+  const removed = refs.projects.length < before;
+  if (refs.projects.length === 0) {
+    try {
+      await rm(getRefsFile(), { force: true });
+    } catch {
+    }
+  } else if (removed) {
+    await saveRefs(refs);
+  }
+  return { remaining: refs.projects.length, removed };
+}
+async function getRefs() {
+  const refs = await loadRefs();
+  return refs.projects;
+}
+async function clearAllRefs() {
+  try {
+    await rm(getSkillDir(), { recursive: true, force: true });
+  } catch {
+  }
+}
+var init_skill_refs = __esm({
+  "src/features/task-sync/lib/skill-refs.ts"() {
+    "use strict";
+    init_esm_shims();
+  }
+});
+
+// src/features/task-sync/commands/install.ts
+var install_exports = {};
+__export(install_exports, {
+  installFile: () => installFile,
+  installManifestFiles: () => installManifestFiles,
+  run: () => run
+});
+import { copyFile, chmod as chmod2 } from "fs/promises";
+import path8 from "path";
+import kleur from "kleur";
+import { execa } from "execa";
+async function installFile(entry, ctx) {
+  const srcAbs = path8.join(ctx.assetsDir, entry.manifestEntry.src);
+  const destAbs = entry.destAbs;
+  await assertNotSymlink(destAbs);
+  if (await fileExists(destAbs)) {
+    const destSha = await sha256File(destAbs);
+    if (destSha === entry.manifestEntry.sha256) {
+      return "skipped";
+    }
+    if (!ctx.opts.force) {
+      return "skipped";
+    }
+    if (ctx.opts.dryRun) {
+      console.log(`  ${kleur.yellow("[dry-run]")} overwrite ${entry.destRel}`);
+      return "planned";
+    }
+    await ensureDir(path8.dirname(destAbs));
+    await copyFile(srcAbs, destAbs);
+    await chmod2(destAbs, entry.manifestEntry.mode);
+    return "overwritten";
+  }
+  if (ctx.opts.dryRun) {
+    console.log(`  ${kleur.yellow("[dry-run]")} copy \u2192 ${entry.destRel}`);
+    return "planned";
+  }
+  await ensureDir(path8.dirname(destAbs));
+  await copyFile(srcAbs, destAbs);
+  await chmod2(destAbs, entry.manifestEntry.mode);
+  return "copied";
+}
+async function installManifestFiles(entries, ctx) {
+  const stats = {
+    copied: 0,
+    skipped: 0,
+    overwritten: 0,
+    planned: 0,
+    filtered: 0,
+    warnings: []
+  };
+  for (const entry of entries) {
+    if (entry.optionalFlag && ctx.opts[entry.optionalFlag]) {
+      stats.filtered += 1;
+      continue;
+    }
+    const result = await installFile(entry, ctx);
+    if (result === "skipped") {
+      const destSha = await fileExists(entry.destAbs) ? await sha256File(entry.destAbs) : null;
+      if (destSha && destSha !== entry.manifestEntry.sha256 && !ctx.opts.force) {
+        stats.warnings.push(`skipped (user-modified): ${entry.destRel}`);
+      }
+    }
+    stats[result] += 1;
+  }
+  return stats;
+}
+async function mergeSettingsStep(ctx) {
+  const settingsPath = path8.join(ctx.cwd, ".claude/settings.json");
+  const existing = await loadSettingsFile(settingsPath);
+  const merged = mergeSettings(existing, BITRIX_HOOKS_TEMPLATE);
+  const alreadyMerged = JSON.stringify(existing) === JSON.stringify(merged);
+  if (ctx.opts.dryRun) {
+    if (alreadyMerged) {
+      console.log(`  ${kleur.yellow("[dry-run]")} settings.json: already up-to-date`);
+    } else {
+      console.log(`  ${kleur.yellow("[dry-run]")} settings.json: would merge 4 Bitrix hooks`);
+    }
+    return { added: !alreadyMerged, alreadyMerged };
+  }
+  if (!alreadyMerged) {
+    await writeSettingsFile(settingsPath, merged);
+  }
+  return { added: !alreadyMerged, alreadyMerged };
+}
+async function ensureUfTokensTotal(cwd, stats) {
+  const webhookUrl = process.env["BITRIX_WEBHOOK_URL"];
+  if (!webhookUrl) return;
+  const libPath = path8.join(cwd, ".claude/scripts/bitrix-lib.sh");
+  if (!await fileExists(libPath)) return;
+  const script = `
+    set -e
+    source "$1"
+    result=$(b24_call "task.item.userfield.add"       "$(jq -n '{PARAMS:{USER_TYPE_ID:"double",FIELD_NAME:"UF_AI_TOKENS_TOTAL",XML_ID:"UF_AI_TOKENS_TOTAL",LABEL:"AI Tokens (cumulative)",SORT:500,MULTIPLE:"N",MANDATORY:"N",SETTINGS:{DEFAULT_VALUE:0,PRECISION:0}}}')")
+    err=$(echo "$result" | jq -r '.error // empty')
+    # ERROR_CORE = already exists \u2192 treat as success
+    if [[ -n "$err" && "$err" != "ERROR_CORE" ]]; then
+      echo "warn:$err" >&2
+    fi
+    exit 0
+  `;
+  try {
+    const result = await execa("bash", ["-c", script, "--", libPath], {
+      cwd,
+      reject: false,
+      env: { ...process.env }
+    });
+    if (result.stderr && !result.stderr.includes("ERROR_CORE")) {
+      const warnLine = (result.stderr.match(/warn:(.+)/) ?? [])[1];
+      if (warnLine) stats.warnings.push(`UF_AI_TOKENS_TOTAL: ${warnLine.trim()}`);
+    }
+  } catch {
+    stats.warnings.push("UF_AI_TOKENS_TOTAL: ensure skipped (bash error)");
+  }
+}
+async function runGitHooksInstall(ctx) {
+  const hooksScript = path8.join(ctx.cwd, ".githooks/install.sh");
+  if (!await fileExists(hooksScript)) {
+    return { run: false, warning: "githooks install.sh not found (skipped)" };
+  }
+  if (!await hasGitDir(ctx.cwd)) {
+    return { run: false, warning: "no .git/ in project root \u2014 skipped githooks setup" };
+  }
+  if (ctx.opts.dryRun) {
+    console.log(`  ${kleur.yellow("[dry-run]")} would run: bash .githooks/install.sh`);
+    return { run: false };
+  }
+  try {
+    await chmod2(hooksScript, 493);
+    await execa("bash", [hooksScript], { cwd: ctx.cwd, stdio: "pipe" });
+    return { run: true };
+  } catch (err) {
+    return { run: false, warning: `githooks install failed: ${err.message}` };
+  }
+}
+async function run(opts) {
+  let cwd;
+  try {
+    cwd = await detectProjectRoot(opts.cwd);
+  } catch (err) {
+    console.error(kleur.red(`error: ${err.message}`));
+    return 2;
+  }
+  const assetsDir = resolveAssetsDir();
+  const ctx = { cwd, assetsDir, opts };
+  console.log("");
+  console.log(kleur.bold().cyan("  \u26A1 bitrix-skills task-sync install"));
+  console.log(kleur.gray(`  project root: ${cwd}`));
+  console.log(kleur.gray(`  assets:       ${assetsDir}`));
+  if (opts.dryRun) console.log(kleur.yellow("  mode: --dry-run (no FS changes)"));
+  console.log("");
+  let manifest;
+  try {
+    manifest = await loadManifest();
+  } catch (err) {
+    console.error(kleur.red(`error: ${err.message}`));
+    return 1;
+  }
+  const dests = buildDestMap(manifest, cwd);
+  let stats;
+  try {
+    stats = await installManifestFiles(dests, ctx);
+  } catch (err) {
+    console.error(kleur.red(`copy error: ${err.message}`));
+    return 1;
+  }
+  let settingsResult;
+  try {
+    settingsResult = await mergeSettingsStep(ctx);
+  } catch (err) {
+    console.error(kleur.red(`settings merge error: ${err.message}`));
+    return 3;
+  }
+  if (!opts.noSkill && !opts.dryRun) {
+    await ensureUfTokensTotal(cwd, stats);
+  }
+  const githooksResult = opts.noGithooks ? { run: false, warning: "--no-githooks: skipped" } : await runGitHooksInstall(ctx);
+  let skillRefCount = null;
+  if (!opts.noSkill && !opts.dryRun) {
+    try {
+      const refs = await addProjectRef(cwd);
+      skillRefCount = refs.length;
+    } catch (err) {
+      stats.warnings.push(`skill ref registry: ${err.message}`);
+    }
+  }
+  console.log("");
+  if (opts.dryRun) {
+    const parts = [
+      `${stats.planned} would be copied/overwritten`,
+      `${stats.skipped} skipped`,
+      stats.filtered > 0 ? `${stats.filtered} filtered (--no-* flags)` : null
+    ].filter(Boolean);
+    console.log(kleur.yellow(`  [dry-run] ${parts.join(", ")}`));
+  } else {
+    const parts = [
+      `${stats.copied} copied`,
+      stats.overwritten > 0 ? `${stats.overwritten} overwritten` : null,
+      `${stats.skipped} skipped`,
+      stats.filtered > 0 ? `${stats.filtered} filtered (--no-* flags)` : null
+    ].filter(Boolean);
+    console.log(kleur.green(`  \u2713 files: ${parts.join(", ")}`));
+  }
+  if (settingsResult.alreadyMerged) {
+    console.log(kleur.gray("  \xB7 settings.json: already up-to-date"));
+  } else if (settingsResult.added && !opts.dryRun) {
+    console.log(kleur.green("  \u2713 settings.json: 4 Bitrix hooks merged"));
+  }
+  if (githooksResult.run) {
+    console.log(kleur.green("  \u2713 git hooks: core.hooksPath = .githooks (local)"));
+  } else if (githooksResult.warning) {
+    console.log(kleur.yellow(`  ! ${githooksResult.warning}`));
+  }
+  if (skillRefCount !== null) {
+    const noun = skillRefCount === 1 ? "project" : "projects";
+    console.log(kleur.gray(`  \xB7 skill: shared across ${skillRefCount} ${noun}`));
+  }
+  for (const w of stats.warnings) {
+    console.log(kleur.yellow(`  ! ${w}`));
+  }
+  if (!opts.dryRun) {
+    console.log("");
+    console.log(kleur.bold("  Next steps:"));
+    console.log("    1. Set TASK_ID in CLAUDE.md (see docs/bitrix-task-sync.md \xA72)");
+    console.log("    2. Export BITRIX_WEBHOOK_URL in your shell rc");
+    console.log("    3. Run: npx @synity/bitrix-skills verify");
+    console.log("");
+  }
+  return 0;
+}
+var init_install = __esm({
+  "src/features/task-sync/commands/install.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs_safety();
+    init_project_root();
+    init_manifest();
+    init_dest_map();
+    init_file_ops();
+    init_settings_merge();
+    init_skill_refs();
+  }
+});
+
+// src/features/bx-task/install.ts
+var install_exports2 = {};
+__export(install_exports2, {
+  install: () => install,
+  uninstall: () => uninstall
+});
+import { homedir } from "os";
+import { resolve, join as join3, dirname as dirname2 } from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
+import { mkdir as mkdir3, copyFile as copyFile2, readdir, stat, rm as rm2, access as access3 } from "fs/promises";
+async function getAssetsDir() {
+  const here = dirname2(fileURLToPath4(import.meta.url));
+  const candidates = [
+    // dist/ context (inlined in cli.js): ../src/features/bx-task/assets
+    resolve(here, "../src/features/bx-task/assets"),
+    // dist/features/bx-task/ context: ../../../src/features/bx-task/assets
+    resolve(here, "../../../src/features/bx-task/assets"),
+    // src/features/bx-task/ (dev)
+    resolve(here, "assets")
+  ];
+  for (const c of candidates) {
+    try {
+      await access3(c);
+      return c;
+    } catch {
+    }
+  }
+  return candidates[0];
+}
+function getSkillBase() {
+  return resolve(homedir(), ".claude", "skills");
+}
+async function install(opts) {
+  const skillBase = getSkillBase();
+  const dest = opts._destOverride ?? resolve(skillBase, "bx-task");
+  const resolvedDest = resolve(dest);
+  if (!opts._destOverride && !resolvedDest.startsWith(skillBase)) {
+    throw new Error(`Path traversal detected: ${resolvedDest}`);
+  }
+  const result = {
+    installedFiles: [],
+    skippedFiles: [],
+    warnings: []
+  };
+  await installDir(await getAssetsDir(), resolvedDest, result, opts);
+  result.warnings.push(
+    '[bx-task] Requires MCP server "bitrix-synity-mcp" \u2014 verify it is configured in Claude Code settings.'
+  );
+  return result;
+}
+async function installDir(srcDir, destDir, result, opts) {
+  await mkdir3(destDir, { recursive: true });
+  const entries = await readdir(srcDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = join3(srcDir, entry.name);
+    const destPath = join3(destDir, entry.name);
+    if (entry.isDirectory()) {
+      await installDir(srcPath, destPath, result, opts);
+      continue;
+    }
+    await assertNotSymlink(destPath);
+    const exists = await fileExists2(destPath);
+    if (exists && !opts.force && opts.onConflict === "skip") {
+      result.skippedFiles.push(destPath);
+      continue;
+    }
+    await copyFile2(srcPath, destPath);
+    result.installedFiles.push(destPath);
+  }
+}
+async function fileExists2(filePath) {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function uninstall(opts) {
+  const dest = resolve(opts?._destOverride ?? resolve(homedir(), ".claude", "skills", "bx-task"));
+  if (!opts?._destOverride) {
+    assertContainedIn(dest, getSkillBase(), dest);
+  }
+  await rm2(dest, { recursive: true, force: true });
+}
+var init_install2 = __esm({
+  "src/features/bx-task/install.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_fs_safety();
+  }
+});
+
+// src/features/task-sync/commands/uninstall.ts
+var uninstall_exports = {};
+__export(uninstall_exports, {
+  run: () => run2
+});
+import { unlink } from "fs/promises";
+import path9 from "path";
+import kleur2 from "kleur";
+import { execa as execa2 } from "execa";
+async function run2(opts) {
+  let cwd;
+  try {
+    cwd = await detectProjectRoot(opts.cwd);
+  } catch (err) {
+    console.error(kleur2.red(`error: ${err.message}`));
+    return 2;
+  }
+  console.log("");
+  console.log(kleur2.bold().cyan("  \u26A1 bitrix-skills task-sync uninstall"));
+  console.log(kleur2.gray(`  project root: ${cwd}`));
+  if (opts.dryRun) console.log(kleur2.yellow("  mode: --dry-run (no FS changes)"));
+  console.log("");
+  let manifest;
+  try {
+    manifest = await loadManifest();
+  } catch (err) {
+    console.error(kleur2.red(`error: ${err.message}`));
+    return 1;
+  }
+  const dests = buildDestMap(manifest, cwd);
+  let removed = 0;
+  let preserved = 0;
+  let absent = 0;
+  let filtered = 0;
+  const warnings = [];
+  const cwdAbs = path9.resolve(cwd);
+  const refsBefore = await getRefs();
+  const otherProjects = refsBefore.filter((p) => p !== cwdAbs);
+  const isLastRegisteredReferrer = refsBefore.length > 0 && otherProjects.length === 0;
+  const shouldRemoveSkillFiles = !opts.noSkill && (opts.removeSkill || isLastRegisteredReferrer);
+  for (const d of dests) {
+    if (d.category === "doc" && opts.keepDocs) {
+      filtered += 1;
+      continue;
+    }
+    if (d.category === "skill" && !shouldRemoveSkillFiles) {
+      filtered += 1;
+      continue;
+    }
+    if (d.optionalFlag && opts[d.optionalFlag]) {
+      filtered += 1;
+      continue;
+    }
+    if (!await fileExists(d.destAbs)) {
+      absent += 1;
+      continue;
+    }
+    const actual = await sha256File(d.destAbs);
+    if (actual !== d.manifestEntry.sha256) {
+      preserved += 1;
+      warnings.push(`preserved (user-modified): ${d.destRel}`);
+      continue;
+    }
+    if (opts.dryRun) {
+      console.log(`  ${kleur2.yellow("[dry-run]")} remove ${d.destRel}`);
+      removed += 1;
+      continue;
+    }
+    await unlink(d.destAbs);
+    removed += 1;
+  }
+  const settingsPath = path9.join(cwd, ".claude/settings.json");
+  let settingsChanged = false;
+  if (await fileExists(settingsPath)) {
+    try {
+      const existing = await loadSettingsFile(settingsPath);
+      const cleaned = removeBitrixHooks(existing);
+      const before = JSON.stringify(existing);
+      const after = JSON.stringify(cleaned);
+      if (before !== after) {
+        settingsChanged = true;
+        if (!opts.dryRun) {
+          await writeSettingsFile(settingsPath, cleaned);
+        }
+      }
+    } catch (err) {
+      warnings.push(`settings.json: ${err.message}`);
+    }
+  }
+  let skillRefRemaining = null;
+  if (!opts.noSkill && !opts.dryRun) {
+    try {
+      if (opts.removeSkill) {
+        await clearAllRefs();
+        skillRefRemaining = 0;
+      } else {
+        const result = await removeProjectRef(cwdAbs);
+        skillRefRemaining = result.remaining;
+      }
+    } catch (err) {
+      warnings.push(`skill ref registry: ${err.message}`);
+    }
+  }
+  let hooksPathUnset = false;
+  if (await hasGitDir(cwd)) {
+    try {
+      const { stdout } = await execa2("git", ["config", "--local", "--get", "core.hooksPath"], {
+        cwd,
+        reject: false
+      });
+      if (stdout.trim() === ".githooks") {
+        if (!opts.dryRun) {
+          await execa2("git", ["config", "--local", "--unset", "core.hooksPath"], { cwd, reject: false });
+        }
+        hooksPathUnset = true;
+      }
+    } catch {
+    }
+  }
+  console.log("");
+  const filteredSuffix = filtered > 0 ? `, ${filtered} filtered (--keep-docs / no --remove-skill / --no-*)` : "";
+  if (opts.dryRun) {
+    console.log(kleur2.yellow(`  [dry-run] would remove ${removed} files, preserve ${preserved}, ${absent} already absent${filteredSuffix}`));
+  } else {
+    console.log(kleur2.green(`  \u2713 files: ${removed} removed, ${preserved} preserved, ${absent} already absent${filteredSuffix}`));
+  }
+  if (settingsChanged) {
+    console.log(kleur2.green("  \u2713 settings.json: Bitrix hooks removed"));
+  } else {
+    console.log(kleur2.gray("  \xB7 settings.json: nothing to remove"));
+  }
+  if (hooksPathUnset) {
+    console.log(kleur2.green("  \u2713 git hooks: core.hooksPath unset"));
+  }
+  if (skillRefRemaining !== null) {
+    if (opts.removeSkill) {
+      console.log(kleur2.green("  \u2713 skill: ~/.claude/skills/bitrix-sync-install removed (--remove-skill)"));
+    } else if (skillRefRemaining === 0) {
+      console.log(kleur2.green("  \u2713 skill: last project unlinked, files removed"));
+    } else {
+      const noun = skillRefRemaining === 1 ? "project" : "projects";
+      console.log(
+        kleur2.gray(
+          `  \xB7 skill: preserved (still used by ${skillRefRemaining} other ${noun}); pass --remove-skill to force`
+        )
+      );
+    }
+  }
+  for (const w of warnings) {
+    console.log(kleur2.yellow(`  ! ${w}`));
+  }
+  console.log("");
+  return 0;
+}
+var init_uninstall = __esm({
+  "src/features/task-sync/commands/uninstall.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_project_root();
+    init_manifest();
+    init_dest_map();
+    init_file_ops();
+    init_settings_merge();
+    init_skill_refs();
+  }
+});
+
+// src/cli.ts
+init_esm_shims();
+import { Cli, Builtins } from "clipanion";
+import { createRequire } from "module";
+
+// src/commands/install.ts
+init_esm_shims();
+import { Command, Option } from "clipanion";
+import chalk from "chalk";
+import { existsSync as existsSync4 } from "fs";
+import { join as join4, relative as relative2 } from "path";
+
+// src/lib/feature-registry.ts
+init_esm_shims();
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function defaultFeaturesDir() {
+  const pkgRoot = join(dirname(fileURLToPath2(import.meta.url)), "..");
+  const fromPkg = join(pkgRoot, "src", "features");
+  if (existsSync(fromPkg)) return fromPkg;
+  const fromCwd = join(process.cwd(), "src", "features");
+  if (existsSync(fromCwd)) return fromCwd;
+  return join(pkgRoot, "features");
+}
+function validateFeature(json) {
+  if (!json || typeof json !== "object") return false;
+  const f = json;
+  if (typeof f["name"] !== "string" || !f["name"]) return false;
+  if (typeof f["displayName"] !== "string") return false;
+  if (typeof f["version"] !== "string") return false;
+  if (f["target"] !== "project" && f["target"] !== "global") return false;
+  if (typeof f["description"] !== "string") return false;
+  return true;
+}
+function listFeatures(featuresDir) {
+  const dir = featuresDir ?? defaultFeaturesDir();
+  if (!existsSync(dir)) return [];
+  const features = [];
+  for (const entry of readdirSync(dir)) {
+    const entryPath = join(dir, entry);
+    if (!statSync(entryPath).isDirectory()) continue;
+    const featureJsonPath = join(entryPath, "feature.json");
+    if (!existsSync(featureJsonPath)) continue;
+    try {
+      const raw = JSON.parse(readFileSync(featureJsonPath, "utf8"));
+      if (validateFeature(raw)) {
+        features.push(raw);
+      }
+    } catch {
+    }
+  }
+  return features;
+}
+
+// src/lib/manifest.ts
+init_esm_shims();
+import { createHash } from "crypto";
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2, renameSync } from "fs";
+import { join as join2, relative } from "path";
+function getManifestPath(projectRoot) {
+  return join2(projectRoot, ".bitrix-tools.json");
+}
+function readManifest(projectRoot) {
+  const p = getManifestPath(projectRoot);
+  if (!existsSync2(p)) return null;
+  const raw = readFileSync2(p, "utf8");
+  return JSON.parse(raw);
+}
+function writeManifest(projectRoot, manifest) {
+  const final = getManifestPath(projectRoot);
+  const tmp = `${final}.tmp`;
+  writeFileSync(tmp, JSON.stringify(manifest, null, 2) + "\n", "utf8");
+  renameSync(tmp, final);
+}
+function computeChecksum(filepath) {
+  const buf = readFileSync2(filepath);
+  return createHash("sha256").update(buf).digest("hex");
+}
+
+// src/commands/install.ts
+var DEFAULT_CLI_OPTS = {
+  dryRun: false,
+  force: false,
+  noGithooks: false,
+  noWorkflow: false,
+  noSkill: false,
+  keepDocs: false,
+  quiet: false,
+  removeSkill: false
+};
+function detectLegacyInstall(cwd) {
+  const hasOldModule = existsSync4(join4(cwd, "node_modules", "@synity", "bitrix-task-sync"));
+  const hasLibScript = existsSync4(join4(cwd, ".claude", "scripts", "bitrix-lib.sh"));
+  const hasNewManifest = existsSync4(join4(cwd, ".bitrix-tools.json"));
+  return (hasOldModule || hasLibScript) && !hasNewManifest;
+}
+async function installTaskSync(cwd) {
+  try {
+    const { run: run4 } = await Promise.resolve().then(() => (init_install(), install_exports));
+    const opts = { ...DEFAULT_CLI_OPTS, cwd };
+    const code = await run4(opts);
+    if (code !== 0) return { ok: false, message: `task-sync install exited with code ${code}` };
+    const { loadManifest: loadManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+    const { buildDestMap: buildDestMap2 } = await Promise.resolve().then(() => (init_dest_map(), dest_map_exports));
+    const assetManifest = await loadManifest2();
+    const dests = buildDestMap2(assetManifest, cwd);
+    const installedAbsPaths = dests.map((d) => d.destAbs).filter((p) => existsSync4(p));
+    return { ok: true, message: "task-sync installed", installedAbsPaths };
+  } catch (err) {
+    return { ok: false, message: `task-sync: ${err.message}` };
+  }
+}
+async function installBxTask(cwd) {
+  try {
+    const { install: install2 } = await Promise.resolve().then(() => (init_install2(), install_exports2));
+    const result = await install2({ projectRoot: cwd, onConflict: "skip" });
+    const msg = `bx-task: ${result.installedFiles.length} installed, ${result.skippedFiles.length} skipped`;
+    return { ok: true, message: msg, installPath: result.installedFiles[0], installedAbsPaths: result.installedFiles };
+  } catch (err) {
+    return { ok: false, message: `bx-task: ${err.message}` };
+  }
+}
+function upsertFeature(manifest, entry) {
+  const idx = manifest.features.findIndex((f) => f.name === entry.name);
+  const features = [...manifest.features];
+  if (idx >= 0) {
+    features[idx] = entry;
+  } else {
+    features.push(entry);
+  }
+  return { ...manifest, features };
+}
+var InstallCommand = class extends Command {
+  static paths = [["install"]];
+  static usage = Command.Usage({
+    description: "Install features into the current project",
+    details: `
+      With no arguments, shows an interactive feature picker (TTY required).
+      Use --all to install all available features, or pass feature names directly.
+    `,
+    examples: [
+      ["Install all features", "bitrix-skills install --all"],
+      ["Install specific features", "bitrix-skills install task-sync bx-task"],
+      ["Interactive picker", "bitrix-skills install"]
+    ]
+  });
+  all = Option.Boolean("--all", false, { description: "Install all available features" });
+  featuresFlag = Option.String("--features", { description: "Comma-separated feature names" });
+  featureArgs = Option.Rest({ required: 0 });
+  async execute() {
+    const cwd = process.cwd();
+    const available = listFeatures();
+    if (available.length === 0) {
+      this.context.stderr.write(chalk.red("No features available.\n"));
+      return 1;
+    }
+    if (detectLegacyInstall(cwd)) {
+      this.context.stderr.write(
+        chalk.yellow(
+          "\n  ! Legacy bitrix-task-sync v0.2.x detected.\n    Consider running: bitrix-skills install task-sync\n    to migrate to the new manifest-tracked installation.\n\n"
+        )
+      );
+    }
+    let selectedNames;
+    const installable = available.filter((f) => f.status !== "planned");
+    if (this.all) {
+      selectedNames = installable.map((f) => f.name);
+    } else if (this.featuresFlag) {
+      selectedNames = this.featuresFlag.split(",").map((s) => s.trim()).filter(Boolean);
+    } else if (this.featureArgs.length > 0) {
+      selectedNames = this.featureArgs;
+    } else {
+      if (!process.stdin.isTTY) {
+        this.context.stderr.write(
+          chalk.red("error: no TTY detected. Use --all or specify feature names.\n")
+        );
+        return 1;
+      }
+      const checkbox = (await import("@inquirer/checkbox")).default;
+      const choices = installable.map((f) => ({
+        name: `${f.name} \u2014 ${f.description}`,
+        value: f.name,
+        checked: false
+      }));
+      const picked = await checkbox({
+        message: "Select features to install:",
+        choices
+      });
+      if (picked.length === 0) {
+        this.context.stdout.write(chalk.gray("No features selected.\n"));
+        return 0;
+      }
+      selectedNames = picked;
+    }
+    const availableNames = new Set(available.map((f) => f.name));
+    const invalid = selectedNames.filter((n) => !availableNames.has(n));
+    if (invalid.length > 0) {
+      this.context.stderr.write(chalk.red(`Unknown features: ${invalid.join(", ")}
+`));
+      this.context.stderr.write(chalk.gray(`Available: ${[...availableNames].join(", ")}
+`));
+      return 1;
+    }
+    const existing = readManifest(cwd);
+    let manifest = existing ?? { version: "1", features: [] };
+    let anyFailure = false;
+    for (const name of selectedNames) {
+      const featureInfo = available.find((f) => f.name === name);
+      this.context.stdout.write(`
+Installing ${chalk.bold(name)}...
+`);
+      let ok = false;
+      let message = "";
+      let installPath = cwd;
+      let installedAbsPaths = [];
+      if (name === "task-sync") {
+        const r = await installTaskSync(cwd);
+        ok = r.ok;
+        message = r.message;
+        installPath = cwd;
+        installedAbsPaths = r.installedAbsPaths ?? [];
+      } else if (name === "bx-task") {
+        const r = await installBxTask(cwd);
+        ok = r.ok;
+        message = r.message;
+        if (r.installPath) {
+          const { homedir: homedir2 } = await import("os");
+          installPath = join4(homedir2(), ".claude", "skills", "bx-task");
+        }
+        installedAbsPaths = r.installedAbsPaths ?? [];
+      } else {
+        this.context.stderr.write(chalk.yellow(`  ! No install handler for feature: ${name}
+`));
+        anyFailure = true;
+        continue;
+      }
+      if (ok) {
+        this.context.stdout.write(chalk.green(`  \u2713 ${message}
+`));
+        const checksums = {};
+        for (const absPath of installedAbsPaths) {
+          try {
+            if (existsSync4(absPath)) {
+              const rel = relative2(installPath, absPath);
+              checksums[rel] = computeChecksum(absPath);
+            }
+          } catch {
+          }
+        }
+        const entry = {
+          name,
+          version: featureInfo.version,
+          target: featureInfo.target,
+          installPath,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          checksums
+        };
+        manifest = upsertFeature(manifest, entry);
+        writeManifest(cwd, manifest);
+      } else {
+        this.context.stderr.write(chalk.red(`  \u2717 ${message}
+`));
+        anyFailure = true;
+      }
+    }
+    return anyFailure ? 1 : 0;
+  }
+};
+
+// src/commands/uninstall.ts
+init_esm_shims();
+import { Command as Command2, Option as Option2 } from "clipanion";
+import chalk2 from "chalk";
+var UninstallCommand = class extends Command2 {
+  static paths = [["uninstall"]];
+  static usage = Command2.Usage({
+    description: "Uninstall a feature from the current project",
+    examples: [
+      ["Uninstall task-sync", "bitrix-skills uninstall task-sync"],
+      ["Uninstall bx-task", "bitrix-skills uninstall bx-task"]
+    ]
+  });
+  featureName = Option2.String({ required: true });
+  async execute() {
+    const cwd = process.cwd();
+    const manifest = readManifest(cwd);
+    const name = this.featureName;
+    this.context.stdout.write(`
+Uninstalling ${chalk2.bold(name)}...
+`);
+    if (name === "task-sync") {
+      const { run: run4 } = await Promise.resolve().then(() => (init_uninstall(), uninstall_exports));
+      const opts = {
+        cwd,
+        dryRun: false,
+        force: false,
+        noGithooks: false,
+        noWorkflow: false,
+        noSkill: false,
+        keepDocs: false,
+        quiet: false,
+        removeSkill: false
+      };
+      const code = await run4(opts);
+      if (code !== 0) {
+        this.context.stderr.write(chalk2.red(`task-sync uninstall exited with code ${code}
+`));
+        return code;
+      }
+    } else if (name === "bx-task") {
+      const { uninstall: uninstall2 } = await Promise.resolve().then(() => (init_install2(), install_exports2));
+      try {
+        await uninstall2();
+        this.context.stdout.write(chalk2.green("  \u2713 bx-task skill removed from ~/.claude/skills/\n"));
+      } catch (err) {
+        this.context.stderr.write(chalk2.red(`  \u2717 bx-task: ${err.message}
+`));
+        return 1;
+      }
+    } else {
+      this.context.stderr.write(chalk2.red(`Unknown feature: ${name}
+`));
+      this.context.stderr.write(chalk2.gray("Run: bitrix-skills list\n"));
+      return 1;
+    }
+    if (manifest) {
+      const features = manifest.features.filter((f) => f.name !== name);
+      writeManifest(cwd, { ...manifest, features });
+      this.context.stdout.write(chalk2.green(`  \u2713 removed ${name} from .bitrix-tools.json
+`));
+    }
+    this.context.stdout.write("\n");
+    return 0;
+  }
+};
+
+// src/commands/list.ts
+init_esm_shims();
+import { Command as Command3 } from "clipanion";
+import chalk3 from "chalk";
+var ListCommand = class extends Command3 {
+  static paths = [["list"]];
+  static usage = Command3.Usage({
+    description: "List available features and installation status"
+  });
+  async execute() {
+    const features = listFeatures();
+    const manifest = readManifest(process.cwd());
+    const installed = new Map(manifest?.features.map((f) => [f.name, f]) ?? []);
+    if (features.length === 0) {
+      this.context.stdout.write(chalk3.yellow("No features found.\n"));
+      return 0;
+    }
+    this.context.stdout.write("\nAvailable features:\n");
+    for (const f of features) {
+      const entry = installed.get(f.name);
+      const check = entry ? chalk3.green("\u2713") : chalk3.gray("\u25CB");
+      const name = chalk3.bold(f.name.padEnd(12));
+      const ver = chalk3.cyan(f.version.padEnd(14));
+      const target = chalk3.gray(f.target.padEnd(8));
+      const desc = f.description;
+      const status = entry ? chalk3.green("[installed]") : chalk3.gray("[not installed]");
+      this.context.stdout.write(`  ${check}  ${name} ${ver} ${target} ${desc}  ${status}
+`);
+    }
+    this.context.stdout.write("\n");
+  }
+};
+
+// src/commands/verify.ts
+init_esm_shims();
+import { Command as Command4 } from "clipanion";
+import chalk4 from "chalk";
+import { existsSync as existsSync5 } from "fs";
+import { join as join5 } from "path";
+var VerifyCommand = class extends Command4 {
+  static paths = [["verify"]];
+  static usage = Command4.Usage({
+    description: "Verify installed feature files match their recorded checksums"
+  });
+  async execute() {
+    const cwd = process.cwd();
+    const manifest = readManifest(cwd);
+    if (!manifest || manifest.features.length === 0) {
+      this.context.stderr.write(
+        chalk4.yellow("No features installed. Run: bitrix-skills install\n")
+      );
+      return 1;
+    }
+    this.context.stdout.write("\nVerifying installed features...\n");
+    let anyMismatch = false;
+    for (const feature of manifest.features) {
+      this.context.stdout.write(`
+  ${chalk4.bold(feature.name)} (${feature.version})
+`);
+      this.context.stdout.write(chalk4.gray(`    install path: ${feature.installPath}
+`));
+      if (!existsSync5(feature.installPath)) {
+        this.context.stderr.write(chalk4.red(`    \u2717 install path missing: ${feature.installPath}
+`));
+        anyMismatch = true;
+        continue;
+      }
+      const stored = feature.checksums;
+      if (Object.keys(stored).length === 0) {
+        this.context.stdout.write(chalk4.gray("    \xB7 no checksums recorded (skipping file check)\n"));
+        continue;
+      }
+      for (const [rel, expectedHash] of Object.entries(stored)) {
+        const absPath = join5(feature.installPath, rel);
+        if (!existsSync5(absPath)) {
+          this.context.stderr.write(chalk4.red(`    \u2717 missing: ${rel}
+`));
+          anyMismatch = true;
+        } else {
+          try {
+            const actualHash = computeChecksum(absPath);
+            if (actualHash !== expectedHash) {
+              this.context.stderr.write(chalk4.red(`    \u2717 modified: ${rel}
+`));
+              anyMismatch = true;
+            } else {
+              this.context.stdout.write(chalk4.green(`    \u2713 ${rel}
+`));
+            }
+          } catch (err) {
+            this.context.stderr.write(chalk4.red(`    \u2717 read error: ${rel}: ${err.message}
+`));
+            anyMismatch = true;
+          }
+        }
+      }
+    }
+    this.context.stdout.write("\n");
+    if (anyMismatch) {
+      this.context.stderr.write(
+        chalk4.red("Verification failed \u2014 run: bitrix-skills update\n")
+      );
+      return 1;
+    }
+    this.context.stdout.write(chalk4.green("All features verified OK.\n"));
+    return 0;
+  }
+};
+
+// src/commands/update.ts
+init_esm_shims();
+import { Command as Command5 } from "clipanion";
+import chalk5 from "chalk";
+import { existsSync as existsSync6 } from "fs";
+import { relative as relative3 } from "path";
+var UpdateCommand = class extends Command5 {
+  static paths = [["update"]];
+  static usage = Command5.Usage({
+    description: "Re-install all managed features, forcing overwrite of managed files"
+  });
+  async execute() {
+    const cwd = process.cwd();
+    let manifest = readManifest(cwd);
+    if (!manifest || manifest.features.length === 0) {
+      this.context.stderr.write(
+        chalk5.yellow("No features installed. Run: bitrix-skills install\n")
+      );
+      return 1;
+    }
+    this.context.stdout.write("\nUpdating installed features...\n");
+    let anyFailure = false;
+    for (const feature of manifest.features) {
+      this.context.stdout.write(`
+  Updating ${chalk5.bold(feature.name)}...
+`);
+      let installedAbsPaths = [];
+      if (feature.name === "task-sync") {
+        const { run: run4 } = await Promise.resolve().then(() => (init_install(), install_exports));
+        const opts = {
+          cwd,
+          dryRun: false,
+          force: true,
+          noGithooks: false,
+          noWorkflow: false,
+          noSkill: false,
+          keepDocs: false,
+          quiet: false,
+          removeSkill: false
+        };
+        const code = await run4(opts);
+        if (code !== 0) {
+          this.context.stderr.write(chalk5.red(`  \u2717 task-sync update failed (exit ${code})
+`));
+          anyFailure = true;
+          continue;
+        }
+        try {
+          const { loadManifest: loadManifest2 } = await Promise.resolve().then(() => (init_manifest(), manifest_exports));
+          const { buildDestMap: buildDestMap2 } = await Promise.resolve().then(() => (init_dest_map(), dest_map_exports));
+          const assetManifest = await loadManifest2();
+          const dests = buildDestMap2(assetManifest, cwd);
+          installedAbsPaths = dests.map((d) => d.destAbs).filter((p) => existsSync6(p));
+        } catch {
+        }
+      } else if (feature.name === "bx-task") {
+        const { install: install2 } = await Promise.resolve().then(() => (init_install2(), install_exports2));
+        try {
+          const result = await install2({ projectRoot: cwd, onConflict: "overwrite", force: true });
+          installedAbsPaths = result.installedFiles;
+          this.context.stdout.write(
+            chalk5.green(`  \u2713 bx-task: ${result.installedFiles.length} updated
+`)
+          );
+        } catch (err) {
+          this.context.stderr.write(
+            chalk5.red(`  \u2717 bx-task: ${err.message}
+`)
+          );
+          anyFailure = true;
+          continue;
+        }
+      } else {
+        this.context.stderr.write(chalk5.yellow(`  ! No update handler for: ${feature.name}
+`));
+        anyFailure = true;
+        continue;
+      }
+      const checksums = {};
+      for (const absPath of installedAbsPaths) {
+        try {
+          if (existsSync6(absPath)) {
+            const rel = relative3(feature.installPath, absPath);
+            checksums[rel] = computeChecksum(absPath);
+          }
+        } catch {
+        }
+      }
+      const updatedFeatures = manifest.features.map(
+        (f) => f.name === feature.name ? { ...f, checksums, installedAt: (/* @__PURE__ */ new Date()).toISOString() } : f
+      );
+      const nextManifest = { ...manifest, features: updatedFeatures };
+      writeManifest(cwd, nextManifest);
+      manifest = nextManifest;
+      this.context.stdout.write(chalk5.green(`  \u2713 ${feature.name} updated
+`));
+    }
+    this.context.stdout.write("\n");
+    return anyFailure ? 1 : 0;
+  }
+};
+
+// src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var version = pkg.version ?? "0.0.0";
+var cli = new Cli({
+  binaryLabel: "bitrix-skills",
+  binaryName: "bitrix-skills",
+  binaryVersion: version,
+  enableCapture: false
+});
+cli.register(InstallCommand);
+cli.register(UninstallCommand);
+cli.register(ListCommand);
+cli.register(VerifyCommand);
+cli.register(UpdateCommand);
+cli.register(Builtins.HelpCommand);
+cli.register(Builtins.VersionCommand);
+function run3(args) {
+  return cli.runExit(args);
+}
+export {
+  run3 as run
+};