@kurokeita/add-skill 2.2.1 → 2.3.0

package/README.md

@@ -103,6 +103,8 @@ pnpm dev import https://github.com/owner/repo/tree/main/skills/skill-name
 
 Skills go under `skills`, agents under `agents`, and workflows under `commands`. After copying, `add` can optionally wire each platform you select: it installs a session-start hook (under `.agents/hooks/`) and registers it in that platform's config. On each new session the hook symlinks the canonical `.agents/` entries back into the platform's own directories, so every tool sees the same set of items from one source of truth.
 
+A skill can also ship Claude Code hooks in a `hooks/` dir. `hooks/hooks.json` holds the `hooks` object of `.claude/settings.json`, and `${HOOKS_DIR}` in its commands resolves to `.claude/hooks`. When `add` installs a skill that has this manifest, it offers to copy the other files in `hooks/` to `.claude/hooks/` and merge the entries into `.claude/settings.json` (global or project, matching the install scope). `git-commit` uses this to install its `commit-gate.py` hook.
+
 `list` and `remove` operate on the canonical `.agents/` dir. Removing an entry also prunes any platform symlink left pointing at it.
 
 ## Supported Platforms

package/dist/bin/cli.js

@@ -6,20 +6,21 @@ import { Command } from "commander";
 import pc6 from "picocolors";
 
 // src/commands/add.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import {
   autocompleteMultiselect,
   cancel,
   confirm,
   intro,
   isCancel as isCancel2,
+  log,
   multiselect,
   note as note2,
   outro,
   select as select2,
   spinner
 } from "@clack/prompts";
-import fs4 from "fs-extra";
+import fs5 from "fs-extra";
 import pc2 from "picocolors";
 
 // src/utils/agent-setup.ts
@@ -773,6 +774,120 @@ async function chooseListRemoveScope(options) {
   };
 }
 
+// src/utils/skill-hooks.ts
+import os5 from "node:os";
+import path4 from "node:path";
+import fs4 from "fs-extra";
+var MANIFEST = "hooks.json";
+async function hasSkillHooks(skillDir) {
+  return fs4.pathExists(path4.join(skillDir, "hooks", MANIFEST));
+}
+var UNSAFE = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+function isUnsafe(char) {
+  return UNSAFE.test(char);
+}
+function escapeChar(char) {
+  const code = char.codePointAt(0) ?? 0;
+  return code <= 255 ? `\\x${code.toString(16).padStart(2, "0")}` : `\\u{${code.toString(16)}}`;
+}
+function printable(text2) {
+  return [...text2].map((char) => isUnsafe(char) ? escapeChar(char) : char).join("");
+}
+function isText(value) {
+  return typeof value === "string" && ![...value].some(isUnsafe);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys) {
+  return Object.keys(value).every((key) => keys.includes(key));
+}
+function isHook(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["type", "command", "timeout"]) && value.type === "command" && isText(value.command) && (value.timeout === void 0 || typeof value.timeout === "number");
+}
+function isHookEntry(value) {
+  return isRecord(value) && hasOnlyKeys(value, ["matcher", "hooks"]) && (value.matcher === void 0 || isText(value.matcher)) && Array.isArray(value.hooks) && value.hooks.every(isHook);
+}
+function hookTarget(scope, root) {
+  const base = scope === "project" ? root : os5.homedir();
+  const hooksDir = path4.join(base, ".claude", "hooks");
+  const token = scope === "project" ? '"$CLAUDE_PROJECT_DIR"/.claude/hooks' : hooksDir;
+  return { base, hooksDir, token };
+}
+async function hookFiles(srcDir) {
+  const files = (await fs4.readdir(srcDir)).filter((file) => file !== MANIFEST);
+  for (const file of files) {
+    if (!isText(file) || !(await fs4.lstat(path4.join(srcDir, file))).isFile()) {
+      throw new Error(
+        `hooks/${printable(file)} must be a regular file with a printable name`
+      );
+    }
+  }
+  return files;
+}
+async function readManifest(srcDir, token) {
+  const raw = await fs4.readFile(path4.join(srcDir, MANIFEST), "utf-8");
+  const manifest = JSON.parse(
+    raw.replaceAll(`\${HOOKS_DIR}`, JSON.stringify(token).slice(1, -1))
+  );
+  const hooks = isRecord(manifest) ? manifest.hooks ?? {} : void 0;
+  if (!isRecord(hooks)) {
+    throw new Error(`hooks/${MANIFEST} must be an object with a "hooks" object`);
+  }
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!isText(event) || !Array.isArray(entries) || !entries.every(isHookEntry)) {
+      throw new Error(
+        `hooks/${MANIFEST}: "${printable(event)}" must list { matcher?, hooks: [{ type: "command", command, timeout? }] }`
+      );
+    }
+  }
+  return hooks;
+}
+async function planSkillHooks(skillDir, scope, root) {
+  const { hooksDir, token } = hookTarget(scope, root);
+  const srcDir = path4.join(skillDir, "hooks");
+  const replaces = [];
+  for (const file of await hookFiles(srcDir)) {
+    const dest = path4.join(hooksDir, file);
+    if (!await fs4.pathExists(dest)) continue;
+    const [src, existing] = await Promise.all([
+      fs4.readFile(path4.join(srcDir, file)),
+      fs4.readFile(dest)
+    ]);
+    if (!src.equals(existing)) replaces.push(dest);
+  }
+  const commands = [];
+  for (const [event, entries] of Object.entries(
+    await readManifest(srcDir, token)
+  )) {
+    for (const entry of entries) {
+      const matcher = entry.matcher ? ` [${entry.matcher}]` : "";
+      for (const hook of entry.hooks) {
+        commands.push(`${event}${matcher}: ${hook.command}`);
+      }
+    }
+  }
+  return { commands, replaces };
+}
+async function installSkillHooks(skillDir, scope, root) {
+  const { base, hooksDir, token } = hookTarget(scope, root);
+  const srcDir = path4.join(skillDir, "hooks");
+  const files = await hookFiles(srcDir);
+  const manifest = await readManifest(srcDir, token);
+  for (const file of files) {
+    await fs4.copy(path4.join(srcDir, file), path4.join(hooksDir, file), {
+      overwrite: true
+    });
+  }
+  const settings = path4.join(base, ".claude", "settings.json");
+  for (const [event, entries] of Object.entries(manifest)) {
+    for (const entry of entries) {
+      await mergeJsonHookFile(settings, event, entry);
+    }
+  }
+  return files.map((file) => path4.join(hooksDir, file));
+}
+
 // src/commands/add.ts
 enableAutocompleteMultiSelectShiftAToggle();
 async function add(type, url, options) {
@@ -822,12 +937,12 @@ async function add(type, url, options) {
         }
       } else {
         const sourceDir = TYPE_DIRS[normalizedType];
-        if (!await fs4.pathExists(sourceDir)) {
+        if (!await fs5.pathExists(sourceDir)) {
           cancel(`${normalizedType} directory not found!`);
           process.exit(1);
           return;
         }
-        const entries = await fs4.readdir(sourceDir, { withFileTypes: true });
+        const entries = await fs5.readdir(sourceDir, { withFileTypes: true });
         const availableItems = entries.filter(
           (entry) => entry.isDirectory() || (normalizedType === "workflow" || normalizedType === "agent") && entry.isFile() && entry.name.endsWith(".md")
         ).map((entry) => ({ label: entry.name, value: entry.name })).sort((a, b) => a.label.localeCompare(b.label));
@@ -850,7 +965,7 @@ async function add(type, url, options) {
       }
       const scopeChoice = await chooseInstallScope({ flag: options?.scope });
       if ("rejected" in scopeChoice) {
-        if (tempDir) await fs4.remove(tempDir);
+        if (tempDir) await fs5.remove(tempDir);
         cancel(
           `Scope --scope=${options?.scope} unavailable: ${scopeChoice.reason}`
         );
@@ -858,7 +973,7 @@ async function add(type, url, options) {
         return;
       }
       if (scopeChoice.cancelled) {
-        if (tempDir) await fs4.remove(tempDir);
+        if (tempDir) await fs5.remove(tempDir);
         if (isSingleShot) break;
         currentType = void 0;
         continue;
@@ -866,14 +981,14 @@ async function add(type, url, options) {
       const { scope: chosenScope, root: scopeRoot } = scopeChoice;
       const agentsBase = getAgentsBase(chosenScope, scopeRoot);
       const subdir = TYPE_SUBDIRS[normalizedType] ?? "skills";
-      const targetBase = path4.join(agentsBase, subdir);
+      const targetBase = path5.join(agentsBase, subdir);
       if (chosenScope === "project") {
         const proceed = await confirm({
           message: `Install to project scope at ${pc2.cyan(scopeRoot)}?`,
           initialValue: true
         });
         if (isCancel2(proceed) || !proceed) {
-          if (tempDir) await fs4.remove(tempDir);
+          if (tempDir) await fs5.remove(tempDir);
           if (isSingleShot) break;
           currentType = void 0;
           continue;
@@ -882,8 +997,8 @@ async function add(type, url, options) {
       const subdirName = subdir;
       const preExisting = [];
       for (const item of selectedItems) {
-        const targetName = normalizedType === "skill" ? path4.parse(item).name : item;
-        if (await fs4.pathExists(path4.join(targetBase, targetName))) {
+        const targetName = normalizedType === "skill" ? path5.parse(item).name : item;
+        if (await fs5.pathExists(path5.join(targetBase, targetName))) {
           preExisting.push({ entry: targetName, subdir: subdirName });
         }
       }
@@ -895,7 +1010,7 @@ async function add(type, url, options) {
           required: false
         });
         if (isCancel2(toOverwrite)) {
-          if (tempDir) await fs4.remove(tempDir);
+          if (tempDir) await fs5.remove(tempDir);
           if (isSingleShot) break;
           currentType = void 0;
           continue;
@@ -912,33 +1027,33 @@ async function add(type, url, options) {
       const s = spinner();
       s.start("Installing...");
       const errors = [];
-      let installedCount = 0;
-      await fs4.ensureDir(targetBase);
+      const installed = [];
+      await fs5.ensureDir(targetBase);
       for (const item of selectedItems) {
-        const targetName = normalizedType === "skill" ? path4.parse(item).name : item;
+        const targetName = normalizedType === "skill" ? path5.parse(item).name : item;
         if (skipEntries.has(targetName)) continue;
         s.message(`Installing ${pc2.bold(item)}...`);
         try {
-          const sourcePath = url && tempDir ? isGitHubFile ? path4.join(tempDir, item) : tempDir : path4.join(TYPE_DIRS[normalizedType], item);
-          if (!await fs4.pathExists(sourcePath)) {
+          const sourcePath = url && tempDir ? isGitHubFile ? path5.join(tempDir, item) : tempDir : path5.join(TYPE_DIRS[normalizedType], item);
+          if (!await fs5.pathExists(sourcePath)) {
             throw new Error(`Item '${item}' not found at ${sourcePath}`);
           }
-          const targetPath = path4.join(targetBase, targetName);
-          await fs4.copy(sourcePath, targetPath, { overwrite: true });
-          installedCount++;
+          const targetPath = path5.join(targetBase, targetName);
+          await fs5.copy(sourcePath, targetPath, { overwrite: true });
+          installed.push(targetPath);
         } catch (err) {
           const errorMessage = err instanceof Error ? err.message : String(err);
           errors.push(`${item}: ${errorMessage}`);
         }
       }
       if (tempDir) {
-        await fs4.remove(tempDir);
+        await fs5.remove(tempDir);
         tempDir = null;
       }
       if (errors.length > 0) {
         s.stop(
           pc2.yellow(
-            `Completed with errors. Installed: ${installedCount}, Errors: ${errors.length}`
+            `Completed with errors. Installed: ${installed.length}, Errors: ${errors.length}`
           )
         );
         console.error(pc2.red("\nErrors encountered:"));
@@ -948,15 +1063,18 @@ async function add(type, url, options) {
       } else {
         s.stop(
           pc2.green(
-            `Successfully installed ${installedCount} ${normalizedType}s.`
+            `Successfully installed ${installed.length} ${normalizedType}s.`
           )
         );
       }
-      if (installedCount > 0) {
+      if (installed.length > 0) {
         await maybeWireAgentSetup(agentsBase, chosenScope, scopeRoot);
+        if (normalizedType === "skill") {
+          await maybeInstallSkillHooks(installed, chosenScope, scopeRoot, !!url);
+        }
       }
     } catch (error) {
-      if (tempDir) await fs4.remove(tempDir);
+      if (tempDir) await fs5.remove(tempDir);
       cancel(`An error occurred: ${error}`);
       process.exit(1);
       return;
@@ -1006,6 +1124,29 @@ async function maybeWireAgentSetup(agentsBase, scope, root) {
     s.error(`Failed to wire agent-setup hook: ${errorMessage}`);
   }
 }
+async function maybeInstallSkillHooks(skillDirs, scope, root, fromUrl) {
+  for (const dir of skillDirs) {
+    if (!await hasSkillHooks(dir)) continue;
+    const name = printable(path5.basename(dir));
+    try {
+      const { commands, replaces } = await planSkillHooks(dir, scope, root);
+      note2(
+        [...commands, ...replaces.map((file) => `Replaces ${file}`)].map(printable).join("\n"),
+        `Claude Code hooks in ${name}`
+      );
+      const install = await confirm({
+        message: `Install the Claude Code hooks bundled with ${name}?`,
+        initialValue: !fromUrl && replaces.length === 0
+      });
+      if (isCancel2(install) || !install) continue;
+      const files = await installSkillHooks(dir, scope, root);
+      log.success(`Installed ${name} hooks: ${printable(files.join(", "))}.`);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      log.error(`Failed to install ${name} hooks: ${printable(errorMessage)}`);
+    }
+  }
+}
 async function resolveConflicts(agentsBase, platforms, scope, root) {
   const conflicts = await detectConflicts(agentsBase, platforms, scope, root);
   if (conflicts.length === 0) return "ok";
@@ -1027,7 +1168,7 @@ async function resolveConflicts(agentsBase, platforms, scope, root) {
 }
 
 // src/commands/import.ts
-import path5 from "node:path";
+import path6 from "node:path";
 import {
   cancel as cancel2,
   confirm as confirm2,
@@ -1038,7 +1179,7 @@ import {
   spinner as spinner2,
   text
 } from "@clack/prompts";
-import fs5 from "fs-extra";
+import fs6 from "fs-extra";
 import pc3 from "picocolors";
 async function importItem(type, url, options) {
   if (!options?.skipIntro) {
@@ -1096,12 +1237,12 @@ async function importItem(type, url, options) {
       throw e;
     }
     const shouldFlatten = (normalizedType === "agent" || normalizedType === "workflow") && !isFile;
-    const targetPath = shouldFlatten ? targetBaseDir : path5.join(targetBaseDir, itemName);
+    const targetPath = shouldFlatten ? targetBaseDir : path6.join(targetBaseDir, itemName);
     if (shouldFlatten) {
-      const srcFiles = await fs5.readdir(tempDir);
+      const srcFiles = await fs6.readdir(tempDir);
       const conflicts = [];
       for (const file of srcFiles) {
-        if (await fs5.pathExists(path5.join(targetBaseDir, file))) {
+        if (await fs6.pathExists(path6.join(targetBaseDir, file))) {
           conflicts.push(file);
         }
       }
@@ -1115,40 +1256,40 @@ async function importItem(type, url, options) {
           initialValue: false
         });
         if (isCancel3(shouldOverwrite) || !shouldOverwrite) {
-          await fs5.remove(tempDir);
+          await fs6.remove(tempDir);
           return;
         }
       }
-    } else if (await fs5.pathExists(targetPath)) {
+    } else if (await fs6.pathExists(targetPath)) {
       const shouldOverwrite = await confirm2({
         message: `${normalizedType} '${itemName}' already exists in the repo. Overwrite?`,
         initialValue: false
       });
       if (isCancel3(shouldOverwrite) || !shouldOverwrite) {
-        await fs5.remove(tempDir);
+        await fs6.remove(tempDir);
         return;
       }
     }
     s.start(`Importing ${itemName} to ${targetBaseDir}...`);
-    await fs5.ensureDir(targetBaseDir);
+    await fs6.ensureDir(targetBaseDir);
     if (isFile) {
-      await fs5.copy(path5.join(tempDir, itemName), targetPath, {
+      await fs6.copy(path6.join(tempDir, itemName), targetPath, {
         overwrite: true
       });
     } else {
       if (shouldFlatten) {
-        await fs5.copy(tempDir, targetBaseDir, { overwrite: true });
+        await fs6.copy(tempDir, targetBaseDir, { overwrite: true });
       } else {
-        await fs5.copy(tempDir, targetPath, { overwrite: true });
+        await fs6.copy(tempDir, targetPath, { overwrite: true });
       }
     }
     s.stop(pc3.green(`Successfully imported ${itemName}!`));
-    await fs5.remove(tempDir);
+    await fs6.remove(tempDir);
     if (!options?.skipIntro) {
       outro2(`${normalizedType} available at: ${targetPath}`);
     }
   } catch (error) {
-    if (tempDir) await fs5.remove(tempDir);
+    if (tempDir) await fs6.remove(tempDir);
     cancel2(`An error occurred: ${error}`);
     process.exit(1);
     return;
@@ -1156,19 +1297,19 @@ async function importItem(type, url, options) {
 }
 
 // src/commands/list.ts
-import os5 from "node:os";
-import path6 from "node:path";
+import os6 from "node:os";
+import path7 from "node:path";
 import { cancel as cancel3, intro as intro3, isCancel as isCancel4, outro as outro3, select as select4 } from "@clack/prompts";
-import fs6 from "fs-extra";
+import fs7 from "fs-extra";
 import pc4 from "picocolors";
 async function collectEntries(subdirPath) {
-  const entries = await fs6.readdir(subdirPath, { withFileTypes: true });
+  const entries = await fs7.readdir(subdirPath, { withFileTypes: true });
   return entries.filter(
     (entry) => entry.isDirectory() || entry.isFile() && entry.name.endsWith(".md")
   ).map((entry) => entry.name).sort();
 }
 function displayBase(base, scope) {
-  if (scope === "global") return base.replace(os5.homedir(), "~");
+  if (scope === "global") return base.replace(os6.homedir(), "~");
   return base;
 }
 async function listLocalForScopes(normalizedType, sections) {
@@ -1176,8 +1317,8 @@ async function listLocalForScopes(normalizedType, sections) {
   console.log(pc4.bold(pc4.blue(`Installed ${normalizedType}s (Local):`)));
   let foundAny = false;
   for (const section of sections) {
-    const subdirPath = path6.join(section.base, subdir);
-    if (!await fs6.pathExists(subdirPath)) continue;
+    const subdirPath = path7.join(section.base, subdir);
+    if (!await fs7.pathExists(subdirPath)) continue;
     const items = await collectEntries(subdirPath);
     if (items.length === 0) continue;
     foundAny = true;
@@ -1221,13 +1362,13 @@ async function performListing(type) {
     return;
   }
   const dirPath = TYPE_DIRS[normalizedType];
-  if (!await fs6.pathExists(dirPath)) {
+  if (!await fs7.pathExists(dirPath)) {
     console.log(
       pc4.yellow(`No ${normalizedType} directory found at: ${dirPath}`)
     );
     return;
   }
-  const entries = await fs6.readdir(dirPath, { withFileTypes: true });
+  const entries = await fs7.readdir(dirPath, { withFileTypes: true });
   const items = entries.filter(
     (entry) => entry.isDirectory() || normalizedType !== "skill" && entry.isFile() && entry.name.endsWith(".md")
   ).map((entry) => entry.name).sort();
@@ -1317,7 +1458,7 @@ async function list(type, options) {
 }
 
 // src/commands/remove.ts
-import path7 from "node:path";
+import path8 from "node:path";
 import {
   autocompleteMultiselect as autocompleteMultiselect2,
   cancel as cancel4,
@@ -1329,7 +1470,7 @@ import {
   select as select5,
   spinner as spinner3
 } from "@clack/prompts";
-import fs7 from "fs-extra";
+import fs8 from "fs-extra";
 import pc5 from "picocolors";
 enableAutocompleteMultiSelectShiftAToggle();
 function buildScopedBases(scope, homedir, projectRoot) {
@@ -1355,9 +1496,9 @@ async function scanInstalledItems(scopedBases, subdir, normalizedType) {
   const items = [];
   const showScopePrefix = scopedBases.length > 1;
   for (const { scope, base } of scopedBases) {
-    const subdirPath = path7.join(base, subdir);
-    if (!await fs7.pathExists(subdirPath)) continue;
-    const entries = await fs7.readdir(subdirPath, { withFileTypes: true });
+    const subdirPath = path8.join(base, subdir);
+    if (!await fs8.pathExists(subdirPath)) continue;
+    const entries = await fs8.readdir(subdirPath, { withFileTypes: true });
     for (const entry of entries) {
       const qualifies = entry.isDirectory() || normalizedType !== "skill" && entry.isFile() && entry.name.endsWith(".md");
       if (!qualifies) continue;
@@ -1397,13 +1538,13 @@ function getPlatformDirs(scope, root, normalizedType) {
 async function pruneDanglingLinks(platformDirs, entry, removedAgentsPath) {
   for (const dir of Object.values(platformDirs)) {
     if (!dir) continue;
-    const link = path7.join(dir, entry);
+    const link = path8.join(dir, entry);
     try {
-      const stat = await fs7.lstat(link);
+      const stat = await fs8.lstat(link);
       if (!stat.isSymbolicLink()) continue;
-      const resolved = await fs7.realpath(link).catch(() => "");
+      const resolved = await fs8.realpath(link).catch(() => "");
       if (resolved === removedAgentsPath || resolved === "") {
-        await fs7.remove(link);
+        await fs8.remove(link);
       }
     } catch {
     }
@@ -1503,11 +1644,11 @@ async function remove(type, options) {
     for (const item of selectedScannedItems) {
       const scoped = basesByScope.get(item.scope);
       if (!scoped) continue;
-      const agentsPath = path7.join(scoped.base, subdir, item.name);
-      if (await fs7.pathExists(agentsPath)) {
+      const agentsPath = path8.join(scoped.base, subdir, item.name);
+      if (await fs8.pathExists(agentsPath)) {
         sDel.message(`Removing ${pc5.bold(item.label)} from .agents...`);
         try {
-          await fs7.remove(agentsPath);
+          await fs8.remove(agentsPath);
           removedCount++;
           const platformDirs = getPlatformDirs(
             item.scope,
@@ -1549,7 +1690,7 @@ async function remove(type, options) {
 }
 
 // package.json
-var version = "2.2.1";
+var version = "2.3.0";
 
 // bin/cli.ts
 var program = new Command();

package/dist/skills/git-commit/SKILL.md

@@ -29,11 +29,11 @@ The `permissions.ask` rule in `~/.claude/settings.json` will surface a permissio
 
 Every gated command, every time. No exceptions for "tiny" or "obvious" changes. Each commit gets its own gate even within the same session. Plan approval, prior "go ahead" signals, and approvals of earlier commits do NOT carry over.
 
-### Step 1 — STOP
+### Step 1: STOP
 
 Do not retry the command yet. The first attempt is your trigger, not your green light.
 
-### Step 2 — Emit a detailed technical summary
+### Step 2: Emit a detailed technical summary
 
 ```bash
 ### Technical summary
@@ -46,11 +46,11 @@ Do not retry the command yet. The first attempt is your trigger, not your green
 
 Fill every bullet. "None" is a valid answer; an omitted bullet is not.
 
-### Step 3 — Propose a commit message
+### Step 3: Propose a commit message
 
 Format per the Conventional Commits section below. No `Co-Authored-By: Claude` trailer. Imperative present tense, no trailing period in the subject. When a body is included, it explains the why.
 
-**Match the message size to the change.** For small commits — single file, trivial scope, narrow type change, doc tweak, small revert, one-line config flip, renamed prop — propose a title-only message. No body, no bullets. The subject alone conveys intent and a body adds friction without value.
+**Match the message size to the change.** For small commits (single file, trivial scope, narrow type change, doc tweak, small revert, one-line config flip, renamed prop), propose a title-only message. No body, no bullets. The subject alone conveys intent and a body adds friction without value.
 
 ```bash
 ### Proposed commit message
@@ -69,11 +69,13 @@ Reserve the full proposal format (body + bullets) for commits that touch multipl
 - bullet of notable change
 ```
 
-### Step 4 — Ask the user verbatim
+### Step 4: Ask the user verbatim
 
 Print exactly: **"Commit as-is, edit the message, or skip?"**
 
-### Step 5 — Wait for explicit approval
+Steps 2 and 3 are your final chat message, using the exact headings and bullet labels above. Put the commit message in a code fence directly under its heading. The fence is the message's only boundary, so any note after the fence stays out of the approved message. End the turn there, with no tool call after the proposal. The `~/.claude/hooks/commit-gate.py` Stop hook checks the message and either lists what is missing or records the proposal and sends you back. Then ask through AskUserQuestion with that text as the question and "Commit as-is" as the first option. The preview can hold just the commit message. The same hook denies a commit question with no recorded proposal, and denies `git commit` until the user picks "Commit as-is". Each approval covers one commit. Commit with the approved message verbatim in a quoted heredoc (`-m "$(cat <<'EOF' ... EOF)"`), with no attribution trailers: the hook denies a changed message, `-F`, the editor, `--amend` without `-m`, and any `Co-Authored-By` or "Generated with Claude Code" line.
+
+### Step 5: Wait for explicit approval
 
 Only after the user replies with an affirmative answer may you re-attempt the command. The OS permission prompt will then surface for final confirmation.
 

package/dist/skills/git-commit/examples/commit-messages.txt

@@ -1,34 +1,41 @@
 # Example Commit Messages
 
 ## Features
+
 - `feat(ui): add progress bar component`
 - `feat(auth): implement oauth2 login with google`
 - `feat!: change default api version to v2`
 
 ## Bug Fixes
+
 - `fix(parser): handle empty input string gracefully`
 - `fix: resolve race condition in database connection pool`
 - `fix(styles): fix padding issues on mobile devices`
 
 ## Documentation
+
 - `docs: update readme with installation instructions`
 - `docs(api): document the new /user/profile endpoint`
 - `docs: add contributing guide`
 
 ## Refactoring
+
 - `refactor(core): simplify the request handling logic`
 - `refactor: move utility functions to a separate module`
 - `refactor(tests): reduce duplication in integration tests`
 
 ## Performance
+
 - `perf(image): optimize image loading speed using lazy-loading`
 - `perf: add caching layer for frequently accessed data`
 
 ## Tests
+
 - `test(auth): add unit tests for jwt validation`
 - `test: increase coverage for the math module`
 
 ## Chore
+
 - `chore: update dependencies`
 - `chore(deps): bump vite from 4.0 to 5.0`
 - `chore: remove unused log statements`

package/dist/skills/git-commit/hooks/commit-gate.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+# Protocol guard, not a sandbox. It reads Bash command text to keep the model from
+# committing without an approved proposal. Shell expansions ($'...', $VAR, backticks),
+# git options it does not know, xargs, or a script file can still run a commit it
+# never sees; only a hook inside git itself could close that.
+import json
+import os
+import re
+import shlex
+import sys
+
+ASK = "Commit as-is, edit the message, or skip?"
+BULLETS = ["Scope", "Behavior change", "Architecture/contract impact", "Tests", "Risk notes"]
+SUBJECT = re.compile(r"^[a-z]+(\([^)]+\))?!?: \S")
+STATE_DIR = os.path.expanduser("~/.cache/commit-gate")
+SHELLS = {"sh", "bash", "zsh", "dash"}
+OPERATORS = set(";&|()")
+GIT_VALUE_OPTIONS = {"-C", "-c", "--git-dir", "--work-tree", "--namespace", "--super-prefix", "--config-env"}
+HOW = (
+    "Write the proposal (### Technical summary with the five bullets, then ### Proposed commit message with the message in a ``` code fence) "
+    "as your final chat message and end the turn. The Stop hook records it and sends you back to ask "
+    f'with AskUserQuestion: question "{ASK}", first option "Commit as-is".'
+)
+
+
+def proposal_problems(text):
+    missing = []
+
+    if "### Technical summary" not in text:
+        missing.append('"### Technical summary" heading')
+
+    for bullet in BULLETS:
+        if not re.search(rf"^- {re.escape(bullet)}:[ \t]*(\S|\n[ \t]+\S)", text, re.M):
+            missing.append(f'filled "- {bullet}:" bullet')
+
+    message = proposed_message(text).splitlines()
+
+    if not message or not SUBJECT.match(message[0]):
+        missing.append('"### Proposed commit message" followed by a ``` code fence whose first line is "<type>(<scope>): <subject>"')
+
+    return missing
+
+
+def proposed_message(text):
+    after = text.partition("### Proposed commit message")[2].lstrip("\n")
+    fenced = re.match(r"```[^\n]*\n(.*?)\n```", after, re.S)
+
+    return fenced.group(1).strip() if fenced else ""
+
+
+def normalize(text):
+    return " ".join(text.split())
+
+
+def commit_command_problems(command, message):
+    if re.search(r"co-authored-by|generated with claude code", command, re.I):
+        return "Remove the Co-Authored-By and 'Generated with Claude Code' lines; the user's rules forbid attribution."
+
+    if re.search(r"(?:^|\s)(?:-[a-zA-Z]*F|--file)(?:[\s=]|$)", command) or not re.search(r"(?:^|\s)(?:-[a-zA-Z]*m|--message)(?:[\s=]|$)", command):
+        return "Pass the message with -m, using a quoted heredoc: -m \"$(cat <<'EOF' ... EOF)\". The hook cannot check -F, the editor, or --amend without -m."
+
+    if normalize(message) not in normalize(command):
+        return "The commit message differs from the approved proposal. Use the approved message verbatim, or propose the new one and ask again."
+
+    return None
+
+
+def is_commit_question(question):
+    labels = [o.get("label", "") for o in question.get("options", [])]
+
+    return any(re.match(r"\s*commit as-is\b", label, re.I) for label in labels) or "commit" in question.get("header", "").lower()
+
+
+def git_commit_count(command):
+    command = command.replace("\\\n", "")
+
+    try:
+        lexer = shlex.shlex(command, posix=True, punctuation_chars=";&|()")
+        lexer.whitespace_split = True
+        tokens = list(lexer)
+    except ValueError:
+        unquoted = re.sub(r"[\"'\\\\]", "", command)
+
+        return len(re.findall(r"(?<![\w-])git(?![\w-])\s.*?\bcommit\b", unquoted, re.S))
+
+    count = 0
+
+    for i, token in enumerate(tokens):
+        name = os.path.basename(token)
+        rest = tokens[i + 1:]
+        words = []
+
+        for word in rest:
+            if set(word) <= OPERATORS:
+                break
+
+            words.append(word)
+
+        if name == "eval" and words:
+            count += git_commit_count(" ".join(words))
+        elif name in SHELLS and len(words) > 1 and words[0] == "-c":
+            count += git_commit_count(words[1])
+
+        if name != "git":
+            continue
+
+        while rest and rest[0].startswith("-"):
+            rest = rest[2:] if rest[0] in GIT_VALUE_OPTIONS else rest[1:]
+
+        if rest and rest[0] == "commit":
+            count += 1
+
+    return count
+
+
+def load(path):
+    try:
+        return json.load(open(path))
+    except (OSError, ValueError):
+        return None
+
+
+def save(path, state):
+    os.makedirs(STATE_DIR, exist_ok=True)
+    json.dump(state, open(path, "w"))
+
+
+def drop(path):
+    if os.path.exists(path):
+        os.remove(path)
+
+
+def decide(payload, path):
+    event = payload.get("hook_event_name")
+    state = load(path)
+
+    if event == "Stop":
+        text = payload.get("last_assistant_message") or ""
+
+        if not re.search(r"^### (Technical summary|Proposed commit message)\s*$", text, re.M):
+            return None
+
+        missing = proposal_problems(text)
+
+        if payload.get("stop_hook_active") and (missing or state):
+            return None
+
+        if missing:
+            return {"decision": "block", "reason": "Commit proposal incomplete. Missing: " + "; ".join(missing) + ". " + HOW}
+
+        save(path, {"approved": False, "message": proposed_message(text)})
+
+        return {"decision": "block", "reason": f'Proposal recorded. Now call AskUserQuestion with question "{ASK}" and first option "Commit as-is".'}
+
+    tool_input = payload.get("tool_input") or {}
+    questions = [q for q in tool_input.get("questions", []) if is_commit_question(q)]
+
+    if event == "PreToolUse" and payload.get("tool_name") == "AskUserQuestion" and questions:
+        if not state or state.get("approved"):
+            return deny("No recorded commit proposal. " + HOW)
+
+        if not all(ASK in q.get("question", "") for q in questions):
+            return deny(f'The commit question text must include "{ASK}".')
+
+        return None
+
+    if event == "PostToolUse" and payload.get("tool_name") == "AskUserQuestion" and questions:
+        answers = (payload.get("tool_response") or {}).get("answers", {})
+        approved = all(re.match(r"\s*commit as-is\b", answers.get(q.get("question"), ""), re.I) for q in questions)
+
+        if approved:
+            save(path, {**state, "approved": True})
+        else:
+            drop(path)
+
+        return None
+
+    commits = git_commit_count(tool_input.get("command", "")) if payload.get("tool_name") == "Bash" else 0
+
+    if event == "PreToolUse" and commits:
+        if not state or not state.get("approved"):
+            return deny("git commit needs an approved proposal. " + HOW)
+
+        if commits > 1:
+            return deny("Run exactly one git commit per command; each approval covers one commit.")
+
+        problem = commit_command_problems(tool_input["command"], state.get("message", ""))
+
+        if problem:
+            return deny(problem)
+
+        drop(path)
+
+    return None
+
+
+def deny(reason):
+    return {"hookSpecificOutput": {"hookEventName": "PreToolUse", "permissionDecision": "deny", "permissionDecisionReason": reason}}
+
+
+def main():
+    payload = json.load(sys.stdin)
+    path = os.path.join(STATE_DIR, f"{payload.get('session_id', 'unknown')}.json")
+    result = decide(payload, path)
+
+    if result:
+        print(json.dumps(result))
+
+
+def self_test():
+    global STATE_DIR
+    import tempfile
+
+    STATE_DIR = tempfile.mkdtemp()
+    path = os.path.join(STATE_DIR, "s.json")
+    good = (
+        "### Technical summary\n- Scope:\n  - a.ts: loader gate\n- Behavior change: 403 for viewers\n"
+        "- Architecture/contract impact: none\n- Tests: 101 pass\n- Risk notes: none\n\n"
+        "### Proposed commit message\n```\nfix(api-access): gate the MCPs page loader\n\nViewers without manage rights\nnow get a 403.\n```\n\n" + ASK
+    )
+    question = {"question": ASK, "header": "Commit 1", "options": [{"label": "Commit as-is"}, {"label": "Skip"}]}
+    ask = {"hook_event_name": "PreToolUse", "tool_name": "AskUserQuestion", "tool_input": {"questions": [question]}}
+    heredoc = "git -C /repo commit -m \"$(cat <<'EOF'\nfix(api-access): gate the MCPs page loader\n\nViewers without manage rights now get a 403.\nEOF\n)\""
+    commit = {"hook_event_name": "PreToolUse", "tool_name": "Bash", "tool_input": {"command": heredoc}}
+
+    def run(command):
+        return decide({**commit, "tool_input": {"command": command}}, path)
+
+    def answered(label):
+        return {**ask, "hook_event_name": "PostToolUse", "tool_response": {"answers": {ASK: label}}}
+
+    assert decide(ask, path), "popup without a recorded proposal is denied"
+    assert decide(commit, path), "commit without approval is denied"
+    assert "incomplete" in decide({"hook_event_name": "Stop", "last_assistant_message": good.replace("- Tests: 101 pass", "- Tests:")}, path)["reason"]
+    assert "recorded" in decide({"hook_event_name": "Stop", "last_assistant_message": good}, path)["reason"]
+    assert decide({"hook_event_name": "Stop", "last_assistant_message": good, "stop_hook_active": True}, path) is None
+    assert decide(ask, path) is None
+    assert decide(answered("Commit as-is (Recommended)"), path) is None
+    assert "differs" in run('git commit -m "fix(api-access): something else"')["hookSpecificOutput"]["permissionDecisionReason"]
+    assert "attribution" in run(heredoc.replace("\nEOF", "\n\nCo-Authored-By: Claude <noreply@anthropic.com>\nEOF"))["hookSpecificOutput"]["permissionDecisionReason"]
+    assert "-F" in run("git commit -F msg.txt")["hookSpecificOutput"]["permissionDecisionReason"]
+    assert run("git commit --amend --no-edit"), "bare amend is denied"
+    assert "exactly one" in run(heredoc + ' && git commit --allow-empty -m "other"')["hookSpecificOutput"]["permissionDecisionReason"]
+    assert decide(commit, path) is None, "approved commit with the proposed message runs"
+    assert decide(commit, path), "approval is single use"
+    unfenced = good.replace("```\nfix(api-access)", "fix(api-access)").replace("403.\n```", "403.")
+    assert "fence" in decide({"hook_event_name": "Stop", "last_assistant_message": unfenced}, path)["reason"]
+    decide({"hook_event_name": "Stop", "last_assistant_message": good.replace("\n\n" + ASK, "\n\nNote: trailers left out.\n\n" + ASK)}, path)
+    assert "trailers" not in load(path)["message"], "prose after the fence is not part of the message"
+    drop(path)
+    assert decide({"hook_event_name": "Stop", "last_assistant_message": "All done."}, path) is None
+    assert decide({"hook_event_name": "Stop", "last_assistant_message": "End with `### Technical summary` and `### Proposed commit message`."}, path) is None
+    assert decide({"hook_event_name": "Stop", "last_assistant_message": "### Technical summary\n- Scope:", "stop_hook_active": True}, path) is None
+    assert "recorded" in decide({"hook_event_name": "Stop", "last_assistant_message": good, "stop_hook_active": True}, path)["reason"]
+    drop(path)
+    decide({"hook_event_name": "Stop", "last_assistant_message": good}, path)
+    decide(answered("Skip"), path)
+    assert decide(commit, path), "skip cancels the proposal"
+    assert git_commit_count("git log --grep commit") == 0
+    assert git_commit_count("cd x && git commit --amend") == 1
+    assert git_commit_count('sh -c "git commit -m x"') == 1
+    assert git_commit_count("bash -c 'git -C /r commit -m x'") == 1
+    assert git_commit_count('eval "git commit -m x"; echo done') == 1
+    assert git_commit_count("echo it's the git-commit skill") == 0, "unparseable text naming git-commit is not a commit"
+    assert git_commit_count("echo it's; git -C /r commit -m x") == 1, "unparseable fallback still sees a real commit"
+    assert git_commit_count("echo it's; \"git\" commit -m x") == 1, "unparseable fallback ignores quotes"
+    assert git_commit_count("git --git-dir /r/.git commit -m x") == 1
+    assert git_commit_count("git --work-tree /r commit -m x") == 1
+    assert git_commit_count("git \\\ncommit -m x") == 1, "line continuation is joined"
+    assert decide({**ask, "tool_input": {"questions": [{"question": "Which branch?", "header": "Branch", "options": [{"label": "Commit to current branch"}]}]}}, path) is None
+    print("ok")
+
+
+if __name__ == "__main__":
+    self_test() if sys.argv[1:] == ["--self-test"] else main()

package/dist/skills/git-commit/hooks/hooks.json

@@ -0,0 +1,39 @@
+{
+	"hooks": {
+		"PreToolUse": [
+			{
+				"matcher": "AskUserQuestion|Bash",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${HOOKS_DIR}/commit-gate.py",
+						"timeout": 10
+					}
+				]
+			}
+		],
+		"Stop": [
+			{
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${HOOKS_DIR}/commit-gate.py",
+						"timeout": 10
+					}
+				]
+			}
+		],
+		"PostToolUse": [
+			{
+				"matcher": "AskUserQuestion",
+				"hooks": [
+					{
+						"type": "command",
+						"command": "python3 ${HOOKS_DIR}/commit-gate.py",
+						"timeout": 10
+					}
+				]
+			}
+		]
+	}
+}

package/dist/skills/statusline-setup/SKILL.md

@@ -121,6 +121,8 @@ Read **all** git state from a single `git -C "$cwd" status -b --porcelain` call,
 
 The last-commit row needs one further call: `git -C "$cwd" log -1 --format='%h %s'`.
 
+Every git call must skip optional locks: export `GIT_OPTIONAL_LOCKS=0` once at the top of the script. A plain `git status` takes `.git/index.lock` to refresh stat info, and the statusline re-runs on every turn, so it races the user's own `git add`/`commit` and makes them fail with `Unable to create '.git/index.lock': File exists`.
+
 ## Quota Colors (by REMAINING quota = 100 - used%)
 
 | Remaining | Color | 24-bit ANSI |
@@ -195,6 +197,10 @@ JSON parsing rules:
 
 set -u
 
+# The statusline re-runs on every Claude turn. A plain `git status` grabs
+# .git/index.lock to refresh stat info, racing the user's own git writes.
+export GIT_OPTIONAL_LOCKS=0
+
 if ! command -v jq >/dev/null 2>&1; then
   printf '%s' "statusline: jq not installed"
   exit 0
@@ -532,6 +538,9 @@ Write `statusline-command.ps1` to the targeted platform directory. Use `ConvertF
 
 ```powershell
 $ErrorActionPreference = 'SilentlyContinue'
+# The statusline re-runs on every Claude turn. A plain `git status` grabs
+# .git/index.lock to refresh stat info, racing the user's own git writes.
+$env:GIT_OPTIONAL_LOCKS = '0'
 [Console]::OutputEncoding = [System.Text.Encoding]::UTF8
 $OutputEncoding = [System.Text.Encoding]::UTF8
 $ESC = [char]27

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@kurokeita/add-skill",
-	"version": "2.2.1",
+	"version": "2.3.0",
 	"description": "CLI to install AI agent skills to various platforms",
 	"type": "module",
 	"bin": {