@csark0812/skeleton 4.0.2 → 5.0.0

package/dist/cli.js

@@ -15968,8 +15968,7 @@ var require_extend = __commonJS((exports, module) => {
 });
 
 // src/cli.ts
-import { readFileSync as readFileSync24 } from "node:fs";
-import process6 from "node:process";
+import process5 from "node:process";
 
 // src/audit/config/load.ts
 var import_ajv = __toESM(require_ajv(), 1);
@@ -16903,7 +16902,6 @@ var $visitAsync = visit.visitAsync;
 
 // src/audit/core/shared.ts
 var CATALOG_REL_PATH = ".skeleton/catalog.md";
-var REGISTRY_DIR_REL = ".skeleton";
 var EXTERNAL_LINK_RE = /^(https?:|mailto:|#)/;
 var DOC_META_RE = /<!--\s*doc-meta:\s*owner=[^|]+\|\s*last-reviewed=\d{4}-\d{2}-\d{2}\s*-->/;
 var DOC_META_LAST_REVIEWED_RE = /last-reviewed=(\d{4}-\d{2}-\d{2})/;
@@ -17002,8 +17000,7 @@ function isDraftPlacementAllowed(relPath, draftPathPrefixes) {
 // src/audit/config/load.ts
 var SCHEMA_CANDIDATES = [
   join(dirname(fileURLToPath(import.meta.url)), "../../../schemas/config.schema.json"),
-  join(dirname(fileURLToPath(import.meta.url)), "../schemas/config.schema.json"),
-  join(dirname(fileURLToPath(import.meta.url)), "../../schemas/config.schema.json")
+  join(dirname(fileURLToPath(import.meta.url)), "../schemas/config.schema.json")
 ];
 var ROOT_CONFIG_TOML = "skeleton.toml";
 var LEGACY_CONFIG_YAML = join(".skeleton", "config.yaml");
@@ -18226,7 +18223,6 @@ function listOwnedSkillSlugs(index) {
 
 // src/audit/core/collect.ts
 var MARKDOWN_GLOBS = ["**/*.md", "**/*.mdc"];
-var BUILTIN_INCLUDE_PATTERNS = [".skeleton/customize/**"];
 function isMarkdownFile(absPath) {
   return absPath.endsWith(".md") || absPath.endsWith(".mdc");
 }
@@ -18268,7 +18264,7 @@ function expandPatterns(root, patterns, exclude) {
 }
 function collectScanFiles(config, root, skillIndex) {
   const exclude = mergedExcludes(config);
-  const includePatterns = [...BUILTIN_INCLUDE_PATTERNS, ...config.scan.include];
+  const includePatterns = [...config.scan.include];
   if (skillIndex) {
     includePatterns.push(...skillCollectAugments(skillIndex));
   }
@@ -18606,8 +18602,7 @@ import { basename as basename2, dirname as dirname4, extname, join as join6 } fr
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var SCHEMA_CANDIDATES2 = [
   join6(dirname4(fileURLToPath2(import.meta.url)), "../../../schemas/policy-file.schema.json"),
-  join6(dirname4(fileURLToPath2(import.meta.url)), "../schemas/policy-file.schema.json"),
-  join6(dirname4(fileURLToPath2(import.meta.url)), "../../schemas/policy-file.schema.json")
+  join6(dirname4(fileURLToPath2(import.meta.url)), "../schemas/policy-file.schema.json")
 ];
 function resolvePolicySchemaPath() {
   for (const candidate of SCHEMA_CANDIDATES2) {
@@ -31952,9 +31947,10 @@ var DEFAULT_REVIEW_COVERAGE_EXCLUDE = [
   "**/*.spec.*",
   "**/fixtures/**",
   "templates/**",
-  "dist/**",
-  "node_modules/**",
-  ".git/**",
+  "**/dist/**",
+  "**/node_modules/**",
+  "**/.venv/**",
+  "**/.git/**",
   ".skeleton/plugins/**"
 ];
 function reviewCoveragePatterns(config) {
@@ -32604,489 +32600,39 @@ async function runAudit(options) {
   return printAuditResult(await evaluateAudit(options), options.json);
 }
 
-// src/customize/resolve.ts
-import { existsSync as existsSync18, readFileSync as readFileSync18 } from "node:fs";
-import { basename as basename3, join as join16, relative as relative8 } from "node:path";
-function customizeDir(root2) {
-  return join16(root2, REGISTRY_DIR_REL, "customize");
-}
-function customizePathForSlug(root2, slug2) {
-  return join16(customizeDir(root2), `${slug2}.md`);
-}
-function resolveSlugFile(root2, slug2) {
-  const direct = customizePathForSlug(root2, slug2);
-  if (existsSync18(direct)) {
-    return {
-      content: readFileSync18(direct, "utf8"),
-      path: normalizeRelPath(relative8(root2, direct))
-    };
-  }
-  return { content: null, path: null };
-}
-function alwaysIncludeBasenames(root2) {
-  try {
-    const config = loadConfig(root2);
-    return config.customize?.alwaysInclude ?? [];
-  } catch {
-    return [];
-  }
-}
-function readAlwaysInclude(root2, basenames, skipBasename) {
-  const parts = [];
-  const paths = [];
-  const dir = customizeDir(root2);
-  for (const name of basenames) {
-    const file = basename3(name);
-    if (skipBasename && file === skipBasename)
-      continue;
-    const abs = join16(dir, file);
-    if (!existsSync18(abs))
-      continue;
-    parts.push(readFileSync18(abs, "utf8").trimEnd());
-    paths.push(normalizeRelPath(relative8(root2, abs)));
-  }
-  return { parts, paths };
-}
-function resolveCustomize(root2, slug2) {
-  const slugFile = resolveSlugFile(root2, slug2);
-  const alwaysNames = alwaysIncludeBasenames(root2);
-  const skip = slugFile.path !== null && slugFile.path !== undefined ? basename3(slugFile.path) : null;
-  const always = readAlwaysInclude(root2, alwaysNames, skip);
-  const parts = [];
-  const included = [];
-  if (slugFile.content !== null && slugFile.content !== undefined && slugFile.content.trim().length > 0) {
-    parts.push(slugFile.content.trimEnd());
-    if (slugFile.path)
-      included.push(slugFile.path);
-  }
-  parts.push(...always.parts);
-  included.push(...always.paths);
-  if (parts.length === 0) {
-    return { slug: slug2, content: null, path: slugFile.path, included: [] };
-  }
-  return {
-    slug: slug2,
-    content: `${parts.join(`
-
----
-
-`)}
-`,
-    path: slugFile.path ?? always.paths[0] ?? null,
-    included
-  };
-}
-function resolveCustomizeFromRoot(slug2, startDir) {
-  const root2 = findRepoRoot(startDir);
-  return resolveCustomize(root2, slug2);
-}
-
-// src/hooks/run.ts
-import process4 from "node:process";
-function parsePayload(raw) {
-  if (!raw.trim())
-    return {};
-  return JSON.parse(raw);
-}
-function extractPath(payload) {
-  const input = payload.tool_input ?? payload.toolInput ?? {};
-  const candidates = [
-    input.path,
-    input.file_path,
-    input.filePath,
-    input.target_file,
-    input.targetFile
-  ];
-  for (const value of candidates) {
-    if (typeof value === "string" && value.trim())
-      return normalizeRelPath(value.trim());
-  }
-  return null;
-}
-function extractSkillSlug(payload) {
-  const tool = payload.tool_name ?? payload.toolName ?? "";
-  if (tool === "Skill" || tool === "skill") {
-    const input = payload.tool_input ?? payload.toolInput ?? {};
-    const slug2 = input.skill ?? input.slug ?? input.name;
-    if (typeof slug2 === "string" && slug2.trim())
-      return slug2.trim();
-  }
-  const path3 = extractPath(payload);
-  if (path3)
-    return slugFromPath(path3, process4.cwd());
-  return null;
-}
-function cursorResponse(content3) {
-  return JSON.stringify({ additional_context: content3 });
-}
-function claudeResponse(content3) {
-  return JSON.stringify({
-    hookSpecificOutput: {
-      additionalContext: content3
-    }
-  });
-}
-function codexResponse(content3) {
-  return JSON.stringify({ additionalContext: content3 });
-}
-function formatResponse(payload, content3) {
-  const tool = payload.tool_name ?? payload.toolName ?? "";
-  if (tool === "read_file")
-    return codexResponse(content3);
-  if (payload.hook_event_name?.toLowerCase().includes("claude"))
-    return claudeResponse(content3);
-  if (tool === "Read" && payload.hook_event_name === "postToolUse")
-    return cursorResponse(content3);
-  if (tool === "Read" || tool === "Skill")
-    return claudeResponse(content3);
-  return cursorResponse(content3);
-}
-function runCustomizeHook(raw) {
-  try {
-    const payload = parsePayload(raw);
-    const slug2 = extractSkillSlug(payload);
-    if (!slug2)
-      return "{}";
-    const resolved = resolveCustomizeFromRoot(slug2);
-    if (!resolved.content)
-      return "{}";
-    const from = resolved.included.length > 0 ? resolved.included.join(", ") : resolved.path ?? ".skeleton/customize";
-    const prefix = `
-
----
-Customize override for /${slug2} (from ${from}):
-
-`;
-    return formatResponse(payload, prefix + resolved.content);
-  } catch (error) {
-    console.error(`customize hook error: ${error}`);
-    return "{}";
-  }
-}
-
 // src/init/init.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
-import { copyFileSync, existsSync as existsSync23, mkdirSync as mkdirSync4, readFileSync as readFileSync21 } from "node:fs";
-import { join as join21 } from "node:path";
-import process5 from "node:process";
+import { copyFileSync, existsSync as existsSync21, mkdirSync as mkdirSync3, readFileSync as readFileSync20 } from "node:fs";
+import { join as join19 } from "node:path";
+import process4 from "node:process";
 
-// src/init/merge-hooks.ts
-import { existsSync as existsSync21, mkdirSync as mkdirSync3, readFileSync as readFileSync19, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname12, join as join19 } from "node:path";
+// src/init/merge-precommit.ts
+import { existsSync as existsSync19, readFileSync as readFileSync18, writeFileSync as writeFileSync4 } from "node:fs";
+import { join as join17 } from "node:path";
 
 // src/init/package-paths.ts
-import { existsSync as existsSync19 } from "node:fs";
-import { dirname as dirname10, join as join17 } from "node:path";
+import { existsSync as existsSync18 } from "node:fs";
+import { dirname as dirname10, join as join16 } from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 var MODULE_DIR = dirname10(fileURLToPath4(import.meta.url));
-var PACKAGE_ROOT_CANDIDATES = [join17(MODULE_DIR, "../.."), join17(MODULE_DIR, "..")];
+var PACKAGE_ROOT_CANDIDATES = [join16(MODULE_DIR, "../.."), join16(MODULE_DIR, "..")];
 function resolvePackageRoot() {
   for (const candidate of PACKAGE_ROOT_CANDIDATES) {
-    if (existsSync19(join17(candidate, "package.json")))
+    if (existsSync18(join16(candidate, "package.json")))
       return candidate;
   }
   throw new Error("Could not resolve @csark0812/skeleton package root");
 }
 function resolveTemplatesDir() {
-  const dir = join17(resolvePackageRoot(), "templates/skeleton-init");
-  if (!existsSync19(dir)) {
+  const dir = join16(resolvePackageRoot(), "templates/skeleton-init");
+  if (!existsSync18(dir)) {
     throw new Error("Missing templates/skeleton-init in package");
   }
   return dir;
 }
 
-// src/init/resolve-hook-command.ts
-import { existsSync as existsSync20, realpathSync as realpathSync5 } from "node:fs";
-import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname11, join as join18, relative as relative9, resolve as resolve6 } from "node:path";
-var PACKAGE_NAME = "@csark0812/skeleton";
-var CLI_DIST = "dist/cli.js";
-var PACKAGE_ROOT = resolvePackageRoot();
-var DEV_HOOK_COMMAND = "bun src/cli.ts hook customize";
-var FALLBACK_HOOK_COMMAND = `node node_modules/${PACKAGE_NAME}/${CLI_DIST} hook customize`;
-function safeRealpath2(path3) {
-  try {
-    return realpathSync5(path3);
-  } catch {
-    return path3;
-  }
-}
-function toRepoRelative(cwd, absPath) {
-  const rel = relative9(safeRealpath2(cwd), safeRealpath2(absPath)).replace(/\\/g, "/");
-  return rel.startsWith("..") ? absPath.replace(/\\/g, "/") : rel;
-}
-function tryResolvePublishedCli(cwd) {
-  try {
-    const req = createRequire3(join18(cwd, "package.json"));
-    return req.resolve(`${PACKAGE_NAME}/${CLI_DIST}`);
-  } catch {
-    return null;
-  }
-}
-function walkNodeModulesCli(cwd) {
-  let dir = cwd;
-  while (true) {
-    const candidate = join18(dir, "node_modules", PACKAGE_NAME, CLI_DIST);
-    if (existsSync20(candidate))
-      return candidate;
-    const parent = dirname11(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
-  }
-  return null;
-}
-function isInsidePackageRoot(cwd) {
-  const rel = relative9(PACKAGE_ROOT, resolve6(cwd)).replace(/\\/g, "/");
-  return rel === "" || !(rel.startsWith("..") || rel.startsWith("/"));
-}
-function nodeCliHookCommand(cliPath) {
-  return `node ${cliPath} hook customize`;
-}
-function resolveHookCommand(cwd) {
-  if (isInsidePackageRoot(cwd))
-    return DEV_HOOK_COMMAND;
-  const published = tryResolvePublishedCli(cwd);
-  if (published)
-    return nodeCliHookCommand(toRepoRelative(cwd, published));
-  const hoisted = walkNodeModulesCli(cwd);
-  if (hoisted)
-    return nodeCliHookCommand(toRepoRelative(cwd, hoisted));
-  return FALLBACK_HOOK_COMMAND;
-}
-function isSkeletonHookCommand(command) {
-  if (!command)
-    return false;
-  if (/\bhook\s+customize\b/.test(command))
-    return true;
-  return /customize-on-skill-read\.(js|ts)\b/.test(command);
-}
-
-// src/init/merge-hooks.ts
-var TEMPLATES_DIR = resolveTemplatesDir();
-function identityKey(platform, event, matcher) {
-  return `skeleton:customize:${platform}:${event}:${matcher}`;
-}
-function loadFragment(name, hookCommand) {
-  const raw = readFileSync19(join19(TEMPLATES_DIR, name), "utf8");
-  return JSON.parse(raw.replaceAll("{{HOOK_COMMAND}}", hookCommand));
-}
-function readJson(path3) {
-  if (!existsSync21(path3))
-    return null;
-  try {
-    return JSON.parse(readFileSync19(path3, "utf8"));
-  } catch (error) {
-    throw new Error(`Invalid JSON in ${path3}: ${error}`);
-  }
-}
-function writeJson(path3, value) {
-  mkdirSync3(dirname12(path3), { recursive: true });
-  writeFileSync4(path3, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-function deepEqual(a, b) {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-function mergeExistingCursorHook(input) {
-  const { postToolUse, skeletonIdx, canonical, opts } = input;
-  const current = postToolUse[skeletonIdx];
-  const userEdited = current && !opts.forceHooks && (current.matcher !== canonical.matcher || !isSkeletonHookCommand(current.command));
-  if (userEdited) {
-    return {
-      platform: "cursor",
-      action: "conflict",
-      message: identityKey("cursor", "postToolUse", String(current.matcher ?? "Read"))
-    };
-  }
-  const extras = Object.fromEntries(Object.entries(current ?? {}).filter(([key]) => !["command", "matcher"].includes(key)));
-  const merged = { ...extras, ...canonical };
-  if (deepEqual(current, merged))
-    return { platform: "cursor", action: "skipped" };
-  postToolUse[skeletonIdx] = merged;
-  return null;
-}
-function persistCursorHooks(input) {
-  const { targetPath, existing, hooks, postToolUse, skeletonIdx } = input;
-  const next = {
-    ...existing,
-    version: existing.version ?? 1,
-    hooks: { ...hooks, postToolUse }
-  };
-  if (deepEqual(existing, next))
-    return { platform: "cursor", action: "skipped" };
-  writeJson(targetPath, next);
-  return { platform: "cursor", action: skeletonIdx >= 0 ? "updated" : "added" };
-}
-function mergeCursorHooks(targetPath, fragment, opts) {
-  const existing = readJson(targetPath) ?? {};
-  const hooks = existing.hooks ?? {};
-  const postToolUse = [...hooks.postToolUse ?? []];
-  const incoming = fragment.hooks?.postToolUse?.[0];
-  if (!incoming)
-    return { platform: "cursor", action: "skipped" };
-  const skeletonIdx = postToolUse.findIndex((entry) => isSkeletonHookCommand(entry.command));
-  const canonical = { ...incoming, matcher: incoming.matcher ?? "Read" };
-  if (skeletonIdx >= 0) {
-    const conflict = mergeExistingCursorHook({ postToolUse, skeletonIdx, canonical, opts });
-    if (conflict)
-      return conflict;
-  } else {
-    postToolUse.push(canonical);
-  }
-  return persistCursorHooks({ targetPath, existing, hooks, postToolUse, skeletonIdx });
-}
-function mergeExistingNestedSkeletonHook(input) {
-  const { hooks, skeletonIdx, incomingHook, opts, platform, eventName, matcher } = input;
-  const current = hooks[skeletonIdx];
-  const userEdited = current && !opts.forceHooks && (current.type !== incomingHook.type || !isSkeletonHookCommand(current.command));
-  if (userEdited) {
-    return {
-      changed: false,
-      conflict: {
-        platform,
-        action: "conflict",
-        message: identityKey(platform, eventName, matcher)
-      }
-    };
-  }
-  const extras = Object.fromEntries(Object.entries(current ?? {}).filter(([key]) => !["type", "command"].includes(key)));
-  const merged = { ...extras, ...incomingHook };
-  if (!deepEqual(current, merged)) {
-    hooks[skeletonIdx] = merged;
-    return { changed: true };
-  }
-  return { changed: false };
-}
-function mergeIncomingHookGroup(args) {
-  const { group, incomingHook, eventHooks, opts, platform, eventName } = args;
-  const matcher = group.matcher ?? "";
-  const groupIdx = eventHooks.findIndex((g) => g.matcher === matcher);
-  if (groupIdx < 0) {
-    eventHooks.push({ ...group, hooks: [{ ...incomingHook }] });
-    return { changed: true };
-  }
-  const existingGroup = eventHooks[groupIdx];
-  const hooks = [...existingGroup?.hooks ?? []];
-  const skeletonIdx = hooks.findIndex((entry) => isSkeletonHookCommand(entry.command));
-  if (skeletonIdx >= 0) {
-    const result = mergeExistingNestedSkeletonHook({
-      hooks,
-      skeletonIdx,
-      incomingHook,
-      opts,
-      platform,
-      eventName,
-      matcher
-    });
-    if (result.conflict)
-      return { changed: false, conflict: result.conflict };
-    eventHooks[groupIdx] = { ...existingGroup, matcher, hooks };
-    return { changed: result.changed };
-  }
-  hooks.push({ ...incomingHook });
-  eventHooks[groupIdx] = { ...existingGroup, matcher, hooks };
-  return { changed: true };
-}
-function mergeIncomingGroups(args) {
-  let changed = false;
-  for (const incomingGroup of args.incomingGroups) {
-    const incomingHook = incomingGroup.hooks?.[0];
-    if (!incomingHook)
-      continue;
-    const result = mergeIncomingHookGroup({
-      group: incomingGroup,
-      incomingHook,
-      eventHooks: args.eventHooks,
-      opts: args.opts,
-      platform: args.platform,
-      eventName: args.eventName
-    });
-    if (result.conflict)
-      return { changed: false, conflict: result.conflict };
-    if (result.changed)
-      changed = true;
-  }
-  return { changed };
-}
-function mergeNestedHooks(args) {
-  const { platform, targetPath, eventName } = args;
-  const existing = readJson(targetPath) ?? {};
-  const rootHooks = existing.hooks ?? {};
-  const eventHooks = [...rootHooks[eventName] ?? []];
-  const incomingGroups = args.fragment.hooks?.[eventName] ?? [];
-  const result = mergeIncomingGroups({
-    incomingGroups,
-    eventHooks,
-    opts: args.opts,
-    platform,
-    eventName
-  });
-  if (result.conflict)
-    return result.conflict;
-  if (!result.changed)
-    return { platform, action: "skipped" };
-  const next = {
-    ...existing,
-    hooks: { ...rootHooks, [eventName]: eventHooks }
-  };
-  writeJson(targetPath, next);
-  return { platform, action: "updated" };
-}
-function mergeHookConfigs(opts) {
-  const results = [];
-  const cursorPath = join19(opts.cwd, ".cursor/hooks.json");
-  const cursorFragment = loadFragment("cursor-hooks.fragment.json", opts.hookCommand);
-  results.push(mergeCursorHooks(cursorPath, cursorFragment, opts));
-  const claudePath = join19(opts.cwd, ".claude/settings.json");
-  const claudeFragment = loadFragment("claude-settings.fragment.json", opts.hookCommand);
-  results.push(mergeNestedHooks({
-    platform: "claude",
-    targetPath: claudePath,
-    fragment: claudeFragment,
-    eventName: "PostToolUse",
-    opts
-  }));
-  const codexPath = join19(opts.cwd, ".codex/hooks.json");
-  if (existsSync21(join19(opts.cwd, ".codex"))) {
-    const codexFragment = loadFragment("codex-hooks.fragment.json", opts.hookCommand);
-    results.push(mergeNestedHooks({
-      platform: "codex",
-      targetPath: codexPath,
-      fragment: codexFragment,
-      eventName: "PostToolUse",
-      opts
-    }));
-  } else {
-    results.push({ platform: "codex", action: "skipped", message: "missing .codex directory" });
-  }
-  return results;
-}
-function mergePackageJsonScripts(cwd) {
-  const pkgPath = join19(cwd, "package.json");
-  if (!existsSync21(pkgPath))
-    return "skipped";
-  const fragment = JSON.parse(readFileSync19(join19(TEMPLATES_DIR, "package.json.scripts.fragment.json"), "utf8"));
-  const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
-  pkg.scripts ??= {};
-  let changed = false;
-  for (const [key, value] of Object.entries(fragment)) {
-    if (pkg.scripts[key] !== value) {
-      pkg.scripts[key] = value;
-      changed = true;
-    }
-  }
-  if (!changed)
-    return "skipped";
-  writeFileSync4(pkgPath, `${JSON.stringify(pkg, null, 2)}
-`, "utf8");
-  return "updated";
-}
-
 // src/init/merge-precommit.ts
-import { existsSync as existsSync22, readFileSync as readFileSync20, writeFileSync as writeFileSync5 } from "node:fs";
-import { join as join20 } from "node:path";
-var TEMPLATES_DIR2 = resolveTemplatesDir();
+var TEMPLATES_DIR = resolveTemplatesDir();
 var PRECOMMIT_NAME = ".pre-commit-config.yaml";
 var HOOK_ID = "id: skeleton-validate-staged";
 var LOCAL_HOOK_BLOCK = `  - repo: local
@@ -33098,19 +32644,44 @@ var LOCAL_HOOK_BLOCK = `  - repo: local
         pass_filenames: false
 `;
 function mergePrecommitConfig(cwd) {
-  const target = join20(cwd, PRECOMMIT_NAME);
-  const template = readFileSync20(join20(TEMPLATES_DIR2, "pre-commit-config.yaml"), "utf8");
-  if (!existsSync22(target)) {
-    writeFileSync5(target, template, "utf8");
+  const target = join17(cwd, PRECOMMIT_NAME);
+  const template = readFileSync18(join17(TEMPLATES_DIR, "pre-commit-config.yaml"), "utf8");
+  if (!existsSync19(target)) {
+    writeFileSync4(target, template, "utf8");
     return "added";
   }
-  const existing = readFileSync20(target, "utf8");
+  const existing = readFileSync18(target, "utf8");
   if (existing.includes(HOOK_ID))
     return "skipped";
   const suffix = existing.includes("repos:") ? `
 ${LOCAL_HOOK_BLOCK}` : `
 ${template}`;
-  writeFileSync5(target, `${existing.trimEnd()}${suffix}`, "utf8");
+  writeFileSync4(target, `${existing.trimEnd()}${suffix}`, "utf8");
+  return "updated";
+}
+
+// src/init/merge-scripts.ts
+import { existsSync as existsSync20, readFileSync as readFileSync19, writeFileSync as writeFileSync5 } from "node:fs";
+import { join as join18 } from "node:path";
+var TEMPLATES_DIR2 = resolveTemplatesDir();
+function mergePackageJsonScripts(cwd) {
+  const pkgPath = join18(cwd, "package.json");
+  if (!existsSync20(pkgPath))
+    return "skipped";
+  const fragment = JSON.parse(readFileSync19(join18(TEMPLATES_DIR2, "package.json.scripts.fragment.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync19(pkgPath, "utf8"));
+  pkg.scripts ??= {};
+  let changed = false;
+  for (const [key, value] of Object.entries(fragment)) {
+    if (pkg.scripts[key] !== value) {
+      pkg.scripts[key] = value;
+      changed = true;
+    }
+  }
+  if (!changed)
+    return "skipped";
+  writeFileSync5(pkgPath, `${JSON.stringify(pkg, null, 2)}
+`, "utf8");
   return "updated";
 }
 
@@ -33154,23 +32725,22 @@ function skillsAddArgs(options = {}) {
 // src/init/init.ts
 var TEMPLATES_DIR3 = resolveTemplatesDir();
 function writeScaffold(cwd) {
-  const skeletonDir2 = join21(cwd, ".skeleton");
-  mkdirSync4(skeletonDir2, { recursive: true });
+  const skeletonDir2 = join19(cwd, ".skeleton");
+  mkdirSync3(skeletonDir2, { recursive: true });
   let created = false;
-  const tomlPath = join21(cwd, "skeleton.toml");
-  const legacyYaml = join21(skeletonDir2, "config.yaml");
-  if (!(existsSync23(tomlPath) || existsSync23(legacyYaml))) {
-    copyFileSync(join21(TEMPLATES_DIR3, "skeleton.toml"), tomlPath);
+  const tomlPath = join19(cwd, "skeleton.toml");
+  const legacyYaml = join19(skeletonDir2, "config.yaml");
+  if (!(existsSync21(tomlPath) || existsSync21(legacyYaml))) {
+    copyFileSync(join19(TEMPLATES_DIR3, "skeleton.toml"), tomlPath);
     created = true;
   }
-  mkdirSync4(join21(skeletonDir2, "customize"), { recursive: true });
   return created ? "created" : "skipped";
 }
 function assertPackageResolvable(cwd) {
-  const pkgPath = join21(cwd, "package.json");
-  if (!existsSync23(pkgPath))
+  const pkgPath = join19(cwd, "package.json");
+  if (!existsSync21(pkgPath))
     return;
-  const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
+  const pkg = JSON.parse(readFileSync20(pkgPath, "utf8"));
   const hasDep = pkg.devDependencies?.["@csark0812/skeleton"] || pkg.dependencies?.["@csark0812/skeleton"];
   if (!hasDep) {
     try {
@@ -33188,16 +32758,6 @@ function runSkillsAdd(args, cwd) {
   });
   return result.status ?? 1;
 }
-function logHookMergeResult(result) {
-  if (result.action === "conflict") {
-    console.error(`init: skipped ${result.platform} hook (user-edited) — re-run with --force-hooks to restore`);
-    return;
-  }
-  if (result.action === "added")
-    console.log(`init: added ${result.platform} customize hook`);
-  if (result.action === "updated")
-    console.log(`init: updated ${result.platform} customize hook`);
-}
 function installSkillsIfRequested(options, cwd) {
   if (!(options.skills && !options.noSkills))
     return "skipped";
@@ -33210,17 +32770,13 @@ function installSkillsIfRequested(options, cwd) {
   return "installed";
 }
 function runInit(options = {}) {
-  const cwd = options.cwd ?? process5.cwd();
+  const cwd = options.cwd ?? process4.cwd();
   assertPackageResolvable(cwd);
   const scaffold = writeScaffold(cwd);
-  const hookCommand = resolveHookCommand(cwd);
-  const hooks = mergeHookConfigs({ cwd, hookCommand, forceHooks: options.forceHooks });
   const scripts = mergePackageJsonScripts(cwd);
   const precommit = mergePrecommitConfig(cwd);
-  for (const result of hooks)
-    logHookMergeResult(result);
   if (scaffold === "created") {
-    console.log("init: wrote skeleton.toml (IDE customize hooks optional)");
+    console.log("init: wrote skeleton.toml");
   } else {
     console.log("init: skeleton.toml or .skeleton/ already present — skipped scaffold write");
   }
@@ -33233,13 +32789,15 @@ function runInit(options = {}) {
     console.log("init: added skeleton validate hook to .pre-commit-config.yaml");
   }
   const skills = installSkillsIfRequested(options, cwd);
-  return { scaffold, hooks, scripts, skills, precommit };
+  return { scaffold, scripts, skills, precommit };
 }
 
 // src/init/parse-args.ts
-var SKELETON_INIT_FLAGS = new Set(["--force-hooks", "--skills", "--no-skills"]);
+var SKELETON_INIT_FLAGS = new Set(["--skills", "--no-skills"]);
 function parseInitArgs(argv) {
-  const forceHooks = argv.includes("--force-hooks");
+  if (argv.includes("--force-hooks")) {
+    throw new Error("init: --force-hooks was removed with customize hooks");
+  }
   const noSkills = argv.includes("--no-skills");
   const skills = argv.includes("--skills");
   const skillsFlags = [];
@@ -33254,14 +32812,14 @@ function parseInitArgs(argv) {
     if (skills)
       skillsFlags.push(arg);
   }
-  return { forceHooks, skills, noSkills, skillsFlags };
+  return { skills, noSkills, skillsFlags };
 }
 
 // src/plugins/build.ts
 import { spawnSync as spawnSync4 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync6 } from "node:fs";
-import { basename as basename4, dirname as dirname13, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync21, writeFileSync as writeFileSync6 } from "node:fs";
+import { basename as basename3, dirname as dirname11, resolve as resolve6 } from "node:path";
 function parseBuildPluginArgs(argv) {
   let check = false;
   let entry;
@@ -33286,7 +32844,7 @@ function collectPluginEntries(root2, config, entry) {
   return (config.plugins ?? []).map((e) => resolvePluginTsPath(root2, e));
 }
 function localImportPaths(tsAbs, content3) {
-  const dir = dirname13(tsAbs);
+  const dir = dirname11(tsAbs);
   const deps = [];
   const re = /(?:from\s+|import\s*\(\s*|import\s+)["'](\.[^"']+)["']/g;
   for (const match of content3.matchAll(re)) {
@@ -33296,12 +32854,12 @@ function localImportPaths(tsAbs, content3) {
     const candidates = [];
     if (spec.endsWith(".js")) {
       const withoutJs = spec.slice(0, -".js".length);
-      candidates.push(resolve7(dir, `${withoutJs}.ts`), resolve7(dir, spec), resolve7(dir, withoutJs, "index.ts"));
+      candidates.push(resolve6(dir, `${withoutJs}.ts`), resolve6(dir, spec), resolve6(dir, withoutJs, "index.ts"));
     } else {
-      candidates.push(resolve7(dir, spec), resolve7(dir, `${spec}.ts`), resolve7(dir, `${spec}.js`), resolve7(dir, spec, "index.ts"));
+      candidates.push(resolve6(dir, spec), resolve6(dir, `${spec}.ts`), resolve6(dir, `${spec}.js`), resolve6(dir, spec, "index.ts"));
     }
     for (const candidate of candidates) {
-      if (existsSync24(candidate) && candidate.endsWith(".ts")) {
+      if (existsSync22(candidate) && candidate.endsWith(".ts")) {
         deps.push(candidate);
         break;
       }
@@ -33318,8 +32876,8 @@ function sourceFingerprint(tsAbs, seen = new Set) {
     if (seen.has(abs))
       return;
     seen.add(abs);
-    const content3 = readFileSync22(abs, "utf8");
-    hash2.update(basename4(abs));
+    const content3 = readFileSync21(abs, "utf8");
+    hash2.update(basename3(abs));
     hash2.update("\x00");
     hash2.update(content3);
     hash2.update("\x00");
@@ -33336,7 +32894,7 @@ function writeStamp(tsAbs, mjsAbs) {
 }
 async function buildOne(tsAbs) {
   const mjsAbs = mjsPathForTs(tsAbs);
-  if (!existsSync24(tsAbs)) {
+  if (!existsSync22(tsAbs)) {
     throw new Error(`Plugin source not found: ${tsAbs}`);
   }
   const proc = spawnSync4("bun", ["build", tsAbs, "--target=node", "--format=esm", `--outfile=${mjsAbs}`, "--packages=external"], { encoding: "utf8" });
@@ -33356,17 +32914,17 @@ ${proc.stderr || proc.stdout || `exit ${proc.status}`}`);
 }
 function checkOne(tsAbs) {
   const mjsAbs = mjsPathForTs(tsAbs);
-  if (!existsSync24(mjsAbs)) {
+  if (!existsSync22(mjsAbs)) {
     throw new Error(`Plugin not built: ${tsAbs} (missing ${mjsAbs}). Run: skeleton build-plugin`);
   }
-  if (!existsSync24(tsAbs)) {
+  if (!existsSync22(tsAbs)) {
     throw new Error(`Plugin source not found: ${tsAbs}`);
   }
   const stampAbs = stampPathForMjs(mjsAbs);
-  if (!existsSync24(stampAbs)) {
+  if (!existsSync22(stampAbs)) {
     throw new Error(`Plugin stale: ${mjsAbs} has no fingerprint stamp. Run: skeleton build-plugin`);
   }
-  const expected = readFileSync22(stampAbs, "utf8").trim();
+  const expected = readFileSync21(stampAbs, "utf8").trim();
   const actual = sourceFingerprint(tsAbs);
   if (expected !== actual) {
     throw new Error(`Plugin stale: ${mjsAbs} does not match ${tsAbs} (or local imports). Run: skeleton build-plugin`);
@@ -33396,8 +32954,8 @@ async function runBuildPlugin(options = {}) {
 
 // src/validate/changed.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync25, readFileSync as readFileSync23 } from "node:fs";
-import { basename as basename5, extname as extname2, join as join22 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync22 } from "node:fs";
+import { basename as basename4, extname as extname2, join as join20 } from "node:path";
 
 // src/validate/git-diff.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
@@ -33477,7 +33035,7 @@ function isSkeletonYamlCandidate(normalized, ext) {
   if (!(normalized.startsWith(".skeleton/") || normalized.startsWith(".skeleton\\"))) {
     return false;
   }
-  const name = basename5(normalized).toLowerCase();
+  const name = basename4(normalized).toLowerCase();
   if (name === "config.yaml" || name === "config.yml")
     return false;
   return true;
@@ -33502,7 +33060,7 @@ function bucketForDocPath(normalized, ctx) {
 function bucketFor(relPath2, ctx) {
   const normalized = normalizeRelPath(relPath2);
   const ext = extname2(normalized).toLowerCase();
-  const name = basename5(normalized);
+  const name = basename4(normalized);
   if (CODE_EXTENSIONS.has(ext))
     return "code";
   if (COMMAND_CONFIG_NAMES.has(name))
@@ -33564,7 +33122,7 @@ function validatePolicy(relPath2, root2, fileSource) {
   if (content3 === null)
     return validationIssue("invalid-policy", relPath2, "path not found");
   try {
-    loadPolicyFile(join22(root2, relPath2), content3);
+    loadPolicyFile(join20(root2, relPath2), content3);
     return null;
   } catch (error) {
     return validationIssue("invalid-policy", relPath2, `invalid policy: ${error}`);
@@ -33580,7 +33138,7 @@ function validateShell(relPath2, root2, fileSource) {
       return null;
     return validationIssue("invalid-shell", relPath2, `shell syntax check failed: ${bash2.stderr}`);
   }
-  const abs = join22(root2, relPath2);
+  const abs = join20(root2, relPath2);
   const shellcheck = spawnSync6("shellcheck", [abs], { encoding: "utf8" });
   if (shellcheck.status === 0)
     return null;
@@ -33604,11 +33162,11 @@ function resolvePaths(options) {
   };
 }
 function packageManagerFromPackageJson(root2) {
-  const pkgPath = join22(root2, "package.json");
-  if (!existsSync25(pkgPath))
+  const pkgPath = join20(root2, "package.json");
+  if (!existsSync23(pkgPath))
     return null;
   try {
-    const pkg = JSON.parse(readFileSync23(pkgPath, "utf8"));
+    const pkg = JSON.parse(readFileSync22(pkgPath, "utf8"));
     const raw = pkg.packageManager?.split("@")[0];
     if (raw === "bun" || raw === "npm" || raw === "pnpm" || raw === "yarn")
       return raw;
@@ -33616,13 +33174,13 @@ function packageManagerFromPackageJson(root2) {
   return null;
 }
 function packageManagerFromLockfiles(root2) {
-  if (existsSync25(join22(root2, "bun.lock")) || existsSync25(join22(root2, "bun.lockb")))
+  if (existsSync23(join20(root2, "bun.lock")) || existsSync23(join20(root2, "bun.lockb")))
     return "bun";
-  if (existsSync25(join22(root2, "pnpm-lock.yaml")))
+  if (existsSync23(join20(root2, "pnpm-lock.yaml")))
     return "pnpm";
-  if (existsSync25(join22(root2, "yarn.lock")))
+  if (existsSync23(join20(root2, "yarn.lock")))
     return "yarn";
-  if (existsSync25(join22(root2, "package-lock.json")))
+  if (existsSync23(join20(root2, "package-lock.json")))
     return "npm";
   return null;
 }
@@ -33648,8 +33206,8 @@ function emptyBuckets() {
 function classifySinglePath(input) {
   const { relPath: relPath2, ctx, state, bucketCtx } = input;
   const normalized = normalizeRelPath(relPath2);
-  const abs = join22(ctx.root, normalized);
-  if (!existsSync25(abs)) {
+  const abs = join20(ctx.root, normalized);
+  if (!existsSync23(abs)) {
     state.missing.push(normalized);
     return;
   }
@@ -33950,7 +33508,8 @@ async function evaluateValidateChanged(options = {}) {
     skillIndex,
     fileSource
   });
-  const coverageCandidateCount = relPaths.filter((path3) => pathRequiresReviewCoverage(path3, config)).length;
+  const livePaths = relPaths.filter((path3) => !resolvedPaths.deleted.has(path3));
+  const coverageCandidateCount = livePaths.filter((path3) => pathRequiresReviewCoverage(path3, config)).length;
   const diagnostics = [
     ...classificationDiagnostics({
       classification,
@@ -33958,7 +33517,7 @@ async function evaluateValidateChanged(options = {}) {
       base: options.base,
       coverageCandidateCount
     }),
-    ...uncoveredChangedPathDiagnostics(relPaths, config, ownerPatterns),
+    ...uncoveredChangedPathDiagnostics(livePaths, config, ownerPatterns),
     ...stageRequiredDiagnostics({
       staged: options.staged ?? false,
       stagedPaths: relPaths,
@@ -34033,16 +33592,14 @@ function usage() {
   console.error(`Usage: skeleton <command>
 
 Commands:
-  init [--force-hooks] [--skills] [--no-skills] [skills add flags…]
+  init [--skills] [--no-skills] [skills add flags…]
   audit docs|self|skills [--strict] [--json] [--paths=a,b] [--only=rule]
                          [--fix[=doc-meta|anchors|ssot]] [--dry-run]
                          [--confirm-reviewed (doc-meta only; requires --paths)]
   build-plugin [path] [--check]
   validate changed [paths…] [--staged] [--base <ref>]
   catalog [--check] [--strict]  write or check .skeleton/catalog.md (gitignored)
-  customize resolve <slug> [--json]
-  hook customize            (reads a host hook payload on stdin)
-Note: \`register\` was removed — add a source-of-truth marker to the file and run \`skeleton catalog\`.`);
+Note: \`register\`, \`customize\`, and \`hook\` were removed.`);
 }
 function parseValidateChangedArgs(rest) {
   const paths = [];
@@ -34105,28 +33662,9 @@ function handleCatalog(argv) {
   }
   return runCatalogCli({ check: argv.includes("--check"), strict: argv.includes("--strict") });
 }
-function handleCustomizeResolve(argv) {
-  const slug2 = argv[0];
-  const json = argv.includes("--json");
-  if (!slug2) {
-    console.error("customize resolve: slug required");
-    return 1;
-  }
-  const result = resolveCustomizeFromRoot(slug2);
-  if (json) {
-    console.log(JSON.stringify(result, null, 2));
-  } else if (result.content) {
-    process6.stdout.write(result.content);
-  }
-  return 0;
-}
-function handleHook(argv) {
-  if (argv[0] !== "customize") {
-    usage();
-    return 1;
-  }
-  process6.stdout.write(runCustomizeHook(readFileSync24(0, "utf8")));
-  return 0;
+function handleRemovedOverlay(command) {
+  console.error(`${command}: removed — overlay inject is gone. Edit the skill in its owning repo.`);
+  return 1;
 }
 function handleInit(argv) {
   runInit(parseInitArgs(argv));
@@ -34147,9 +33685,8 @@ async function dispatchCommand(argv) {
     case "catalog":
       return handleCatalog(rest);
     case "customize":
-      return rest[0] === "resolve" ? handleCustomizeResolve(rest.slice(1)) : null;
     case "hook":
-      return handleHook(rest);
+      return handleRemovedOverlay(command);
     case "init":
       return handleInit(rest);
     default:
@@ -34157,22 +33694,22 @@ async function dispatchCommand(argv) {
   }
 }
 async function main() {
-  const argv = process6.argv.slice(2);
+  const argv = process5.argv.slice(2);
   const command = argv[0];
   if (!command || command === "--help" || command === "-h") {
     usage();
-    process6.exit(command ? 0 : 1);
+    process5.exit(command ? 0 : 1);
   }
   try {
     const exitCode = await dispatchCommand(argv);
     if (exitCode === null) {
       usage();
-      process6.exit(1);
+      process5.exit(1);
     }
-    process6.exit(exitCode);
+    process5.exit(exitCode);
   } catch (error) {
     console.error(String(error));
-    process6.exit(1);
+    process5.exit(1);
   }
 }
 main();