@synity/bitrix-skills 1.3.0

package/dist/features/task-sync/index.js

@@ -0,0 +1,1053 @@
+#!/usr/bin/env node
+
+// src/features/task-sync/index.ts
+import { parseArgs } from "util";
+import kleur4 from "kleur";
+
+// src/features/task-sync/lib/version.ts
+import { readFile } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var __dirname = path.dirname(fileURLToPath(import.meta.url));
+var cached = null;
+async function getVersion() {
+  if (cached) return cached;
+  const candidates = [
+    path.resolve(__dirname, "../package.json"),
+    path.resolve(__dirname, "../../package.json"),
+    path.resolve(__dirname, "../../../package.json"),
+    path.resolve(__dirname, "../../../../package.json")
+  ];
+  for (const p of candidates) {
+    try {
+      const raw = await readFile(p, "utf8");
+      const pkg = JSON.parse(raw);
+      if (pkg && typeof pkg.version === "string" && pkg.name?.includes("bitrix-skills")) {
+        const v = pkg.version;
+        cached = v;
+        return v;
+      }
+    } catch {
+    }
+  }
+  const fallback = "0.0.0-unknown";
+  cached = fallback;
+  return fallback;
+}
+
+// src/features/task-sync/commands/install.ts
+import { copyFile, chmod as chmod2 } from "fs/promises";
+
+// src/lib/fs-safety.ts
+import { lstat } from "fs/promises";
+import path2 from "path";
+async function assertNotSymlink(destPath) {
+  try {
+    const stat = await lstat(destPath);
+    if (stat.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.`
+    );
+  }
+}
+
+// src/features/task-sync/commands/install.ts
+import path8 from "path";
+import kleur from "kleur";
+import { execa } from "execa";
+
+// src/features/task-sync/lib/project-root.ts
+import path4 from "path";
+
+// src/features/task-sync/lib/file-ops.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, access, mkdir, writeFile, rename, chmod } from "fs/promises";
+import { constants } from "fs";
+import path3 from "path";
+async function sha256File(filePath) {
+  const buf = await readFile2(filePath);
+  return createHash("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);
+}
+
+// src/features/task-sync/lib/project-root.ts
+var ROOT_MARKERS = [".git", "pnpm-workspace.yaml"];
+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"));
+}
+
+// src/features/task-sync/lib/manifest.ts
+import { readFile as readFile3 } from "fs/promises";
+import { existsSync } from "fs";
+import path5 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __dirname3 = path5.dirname(fileURLToPath2(import.meta.url));
+function resolveAssetsDir() {
+  const candidates = [
+    // From dist/ (cli.js context): ../src/features/task-sync/assets
+    path5.resolve(__dirname3, "../src/features/task-sync/assets"),
+    // From dist/features/task-sync/ (index.js context): ../../../src/features/task-sync/assets
+    path5.resolve(__dirname3, "../../../src/features/task-sync/assets"),
+    // Dev: src/features/task-sync/lib/ → ../assets
+    path5.resolve(__dirname3, "../assets"),
+    // Legacy fallbacks (should not match before correct paths above)
+    path5.resolve(__dirname3, "../../assets"),
+    path5.resolve(__dirname3, "../../../assets"),
+    path5.resolve(__dirname3, "../../../../assets")
+  ];
+  for (const c of candidates) {
+    if (existsSync(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 readFile3(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");
+  }
+}
+
+// src/features/task-sync/lib/dest-map.ts
+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;
+}
+
+// src/features/task-sync/lib/settings-merge.ts
+import { readFile as readFile4 } from "fs/promises";
+import deepmerge from "deepmerge";
+var 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" }] }
+    ]
+  }
+};
+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 readFile4(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;
+}
+
+// src/features/task-sync/lib/skill-refs.ts
+import { readFile as readFile5, 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 readFile5(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 {
+  }
+}
+
+// src/features/task-sync/commands/install.ts
+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;
+}
+
+// src/features/task-sync/commands/uninstall.ts
+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;
+}
+
+// src/features/task-sync/commands/verify.ts
+import path11 from "path";
+import kleur3 from "kleur";
+import { execa as execa3 } from "execa";
+
+// src/features/task-sync/lib/drift-check.ts
+async function checkDrift(manifest, cwd, opts = {}) {
+  const drifted = [];
+  const dests = buildDestMap(manifest, cwd);
+  for (const d of dests) {
+    if (d.optionalFlag && opts[d.optionalFlag]) continue;
+    if (!await fileExists(d.destAbs)) {
+      drifted.push({
+        path: d.destRel,
+        reason: "missing",
+        expected: d.manifestEntry.sha256,
+        actual: null
+      });
+      continue;
+    }
+    const actual = await sha256File(d.destAbs);
+    if (actual !== d.manifestEntry.sha256) {
+      drifted.push({
+        path: d.destRel,
+        reason: "modified",
+        expected: d.manifestEntry.sha256,
+        actual
+      });
+    }
+  }
+  return drifted;
+}
+
+// src/features/task-sync/lib/task-id-finder.ts
+import { readFile as readFile6 } from "fs/promises";
+import path10 from "path";
+async function findTaskId(startDir) {
+  let dir = path10.resolve(startDir);
+  const root = path10.parse(dir).root;
+  while (true) {
+    const md = path10.join(dir, "CLAUDE.md");
+    if (await fileExists(md)) {
+      const content = await readFile6(md, "utf8");
+      const match = content.match(/^TASK_ID:\s*(\S+)/m);
+      if (match && match[1]) {
+        return match[1].replace(/\r$/, "");
+      }
+    }
+    const parent = path10.dirname(dir);
+    if (parent === dir || dir === root) break;
+    dir = parent;
+  }
+  return null;
+}
+function isValidTaskId(taskId) {
+  return /^\d+$/.test(taskId);
+}
+
+// src/features/task-sync/commands/verify.ts
+function redactWebhook(text) {
+  let out = text;
+  const url = process.env["BITRIX_WEBHOOK_URL"];
+  if (url) {
+    out = out.split(url).join("<BITRIX_WEBHOOK_URL>");
+    out = out.replace(/\/rest\/\d+\/[A-Za-z0-9]+/g, "/rest/<redacted>");
+  }
+  return out;
+}
+async function run3(opts) {
+  let cwd;
+  try {
+    cwd = await detectProjectRoot(opts.cwd);
+  } catch (err) {
+    console.error(kleur3.red(`error: ${err.message}`));
+    return 2;
+  }
+  console.log("");
+  console.log(kleur3.bold().cyan("  \u26A1 bitrix-skills task-sync verify"));
+  console.log(kleur3.gray(`  project root: ${cwd}`));
+  console.log("");
+  let manifest;
+  try {
+    manifest = await loadManifest();
+  } catch (err) {
+    console.error(kleur3.red(`error: ${err.message}`));
+    return 1;
+  }
+  const drift = await checkDrift(manifest, cwd, {
+    noGithooks: opts.noGithooks,
+    noWorkflow: opts.noWorkflow,
+    noSkill: opts.noSkill
+  });
+  if (drift.length > 0) {
+    console.error(kleur3.red("  \u2717 drift detected \u2014 run `bitrix-skills update` to fix:"));
+    for (const d of drift) {
+      console.error(`    - ${d.path} (${d.reason})`);
+    }
+    return 4;
+  }
+  console.log(kleur3.green("  \u2713 manifest: all managed files match expected sha256"));
+  const taskId = await findTaskId(cwd);
+  if (!taskId) {
+    console.error(kleur3.red("  \u2717 TASK_ID not found in any CLAUDE.md (walk-up from project root)"));
+    console.error(kleur3.gray("     add to root or feature CLAUDE.md:\n       ## Bitrix Task\n       TASK_ID: 12345"));
+    return 1;
+  }
+  if (!isValidTaskId(taskId)) {
+    console.error(kleur3.red(`  \u2717 TASK_ID "${taskId}" is not a valid numeric Bitrix task ID`));
+    console.error(kleur3.gray("     expected digits only (e.g. TASK_ID: 12345)"));
+    return 1;
+  }
+  console.log(kleur3.green(`  \u2713 TASK_ID found: ${taskId}`));
+  if (!process.env["BITRIX_WEBHOOK_URL"]) {
+    console.error(kleur3.red("  \u2717 BITRIX_WEBHOOK_URL not set in env"));
+    console.error(kleur3.gray('     export BITRIX_WEBHOOK_URL="https://your.bitrix24.com/rest/USER_ID/TOKEN/"'));
+    return 2;
+  }
+  console.log(kleur3.green("  \u2713 BITRIX_WEBHOOK_URL is set"));
+  if (opts.quiet) {
+    console.log(kleur3.gray("  \xB7 --quiet: skipping live webhook test"));
+    console.log("");
+    return 0;
+  }
+  const libPath = path11.join(cwd, ".claude/scripts/bitrix-lib.sh");
+  if (!await fileExists(libPath)) {
+    console.error(kleur3.red(`  \u2717 ${libPath} missing \u2014 run install first`));
+    return 1;
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString();
+  const message = `\u{1F527} [bitrix-skills verify] ${stamp}`;
+  const script = 'set -e; source "$1"; b24_comment "$2" "$3"';
+  const result = await execa3("bash", ["-c", script, "--", libPath, taskId, message], {
+    cwd,
+    reject: false
+  });
+  if (result.exitCode !== 0 || !/"result"/.test(result.stdout || "")) {
+    console.error(kleur3.red("  \u2717 webhook call failed"));
+    if (result.stderr) console.error(kleur3.gray(`     stderr: ${redactWebhook(result.stderr).slice(0, 500)}`));
+    if (result.stdout) console.error(kleur3.gray(`     stdout: ${redactWebhook(result.stdout).slice(0, 500)}`));
+    return 3;
+  }
+  console.log(kleur3.green(`  \u2713 live webhook OK \u2014 comment posted to TASK_ID=${taskId}`));
+  const diskScript = `
+    set -e
+    source "$1"
+    result=$(b24_call "disk.storage.getlist" '{}')
+    err=$(echo "$result" | jq -r '.error // empty')
+    if [[ "$err" == *"insufficient_scope"* || "$err" == *"ACCESS_DENIED"* ]]; then
+      echo "missing_scope"
+    else
+      echo "ok"
+    fi
+  `;
+  const diskResult = await execa3("bash", ["-c", diskScript, "--", libPath], {
+    cwd,
+    reject: false
+  });
+  if ((diskResult.stdout || "").trim() === "missing_scope") {
+    console.log(kleur3.yellow("  ! disk scope missing \u2014 file-attach feature degraded"));
+    console.log(kleur3.gray('     add "disk" to webhook permissions to enable plan/brainstorm file sync'));
+  } else {
+    console.log(kleur3.green("  \u2713 disk scope OK \u2014 file-attach feature available"));
+  }
+  console.log("");
+  return 0;
+}
+
+// src/features/task-sync/commands/update.ts
+async function run4(opts) {
+  return run({ ...opts, force: true });
+}
+
+// src/features/task-sync/index.ts
+var USAGE = `
+  ${kleur4.bold("bitrix-skills")} \u2014 Synity Bitrix24 tooling CLI
+
+  ${kleur4.bold("Usage:")}
+    npx @synity/bitrix-skills <command> [options]
+
+  ${kleur4.bold("Commands:")}
+    install      Copy hooks/scripts/docs + merge .claude/settings.json
+    uninstall    Reverse install (removes managed files, cleans settings)
+    verify       Smoke test live Bitrix webhook (requires TASK_ID + BITRIX_WEBHOOK_URL)
+    update       Re-install managed files only (force overwrite, preserves user files)
+
+  ${kleur4.bold("Options:")}
+    --cwd=<path>      Project root (default: auto-detect via .git/ or pnpm-workspace.yaml)
+    --dry-run         Print planned actions, no FS changes
+    --force           Overwrite user-modified managed files (install/update)
+    --no-githooks     Skip .githooks/ + commit-msg setup (install)
+    --no-workflow     Skip .github/workflows/bitrix-sync.yml (install)
+    --no-skill        Skip ~/.claude/skills/bitrix-sync-install (install)
+    --keep-docs       Preserve docs/bitrix-task-*.md (uninstall)
+    --remove-skill    Also remove ~/.claude/skills/bitrix-sync-install (uninstall, default: preserve)
+    --quiet           Skip live webhook call (verify \u2014 env + manifest only)
+    --version, -v     Print version
+    --help, -h        Print this help
+
+  ${kleur4.bold("Examples:")}
+    npx @synity/bitrix-skills install
+    npx @synity/bitrix-skills install --dry-run
+    npx @synity/bitrix-skills verify
+    npx @synity/bitrix-skills uninstall
+`;
+function parseCli() {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true,
+    options: {
+      cwd: { type: "string" },
+      "dry-run": { type: "boolean", default: false },
+      force: { type: "boolean", default: false },
+      "no-githooks": { type: "boolean", default: false },
+      "no-workflow": { type: "boolean", default: false },
+      "no-skill": { type: "boolean", default: false },
+      "keep-docs": { type: "boolean", default: false },
+      "remove-skill": { type: "boolean", default: false },
+      quiet: { type: "boolean", default: false },
+      version: { type: "boolean", short: "v", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  const opts = {
+    cwd: values["cwd"] ?? process.cwd(),
+    dryRun: values["dry-run"],
+    force: values["force"],
+    noGithooks: values["no-githooks"],
+    noWorkflow: values["no-workflow"],
+    noSkill: values["no-skill"],
+    keepDocs: values["keep-docs"],
+    removeSkill: values["remove-skill"],
+    quiet: values["quiet"]
+  };
+  return {
+    command: positionals[0],
+    opts,
+    help: values["help"],
+    version: values["version"]
+  };
+}
+async function main() {
+  const { command, opts, help, version } = parseCli();
+  if (version) {
+    const v = await getVersion();
+    console.log(v);
+    return 0;
+  }
+  if (help) {
+    console.log(USAGE);
+    return 0;
+  }
+  if (!command) {
+    console.log(USAGE);
+    return 2;
+  }
+  switch (command) {
+    case "install":
+      return run(opts);
+    case "uninstall":
+      return run2(opts);
+    case "verify":
+      return run3(opts);
+    case "update":
+      return run4(opts);
+    default:
+      console.error(kleur4.red(`unknown command: ${command}`));
+      console.log(USAGE);
+      return 2;
+  }
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  console.error(kleur4.red(`
+  fatal: ${err instanceof Error ? err.message : String(err)}
+`));
+  process.exit(1);
+});