@outerlayer/cli 0.1.1 → 0.4.0

package/dist/chunk-WO2BXCTQ.js

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+import { splitRawFile } from './chunk-EMY4I27X.js';
+import { resolvePackageVersion } from './chunk-RA3O54FC.js';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+createRequire(import.meta.url);
+var TEMPLATE_SKILLS = ["spec", "writing-specs", "build"];
+var MAINTAINED_SKILLS = ["emitting-evidence", "amend", "reporting-findings", "outerlayer"];
+var TEMPLATE_CLASS_LINE = "<!-- yours to edit. Copied once from the default template by outerlayer init; never overwritten. -->";
+function maintainedClassLine(version) {
+  return `<!-- maintained by OuterLayer ${version}. Edits are overwritten on the next outerlayer context emit. -->`;
+}
+function resolvePackRoot(entryPath = fileURLToPath(import.meta.url)) {
+  return join(dirname(dirname(entryPath)), "skill-pack");
+}
+function skillDir(skill) {
+  return `.outerlayer/skills/${skill}`;
+}
+function renderSkillFile(skillClass, content, version) {
+  const line = skillClass === "maintained" ? maintainedClassLine(version) : TEMPLATE_CLASS_LINE;
+  const { frontmatterInner, body } = splitRawFile(content);
+  if (frontmatterInner === null) return `${line}
+${content}`;
+  const block = content.slice(0, content.length - body.length);
+  return `${block}${block.endsWith("\n") ? "" : "\n"}${line}
+${body}`;
+}
+function filesUnder(dir, base = dir) {
+  const out = [];
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const abs = join(dir, entry.name);
+    if (entry.isDirectory()) out.push(...filesUnder(abs, base));
+    else if (entry.isFile()) out.push(abs.slice(base.length + 1).split("\\").join("/"));
+  }
+  return out.sort();
+}
+function orderSkillFiles(relPaths) {
+  return [...relPaths.filter((p) => p === "SKILL.md"), ...relPaths.filter((p) => p !== "SKILL.md")];
+}
+function loadClass(packRoot, skillClass, names, version) {
+  const files = [];
+  for (const skill of names) {
+    const dir = join(packRoot, skillClass, skill);
+    if (!existsSync(dir)) throw new Error(`skill pack is missing ${skillClass}/${skill} under ${packRoot}`);
+    for (const rel of orderSkillFiles(filesUnder(dir))) {
+      const raw = readFileSync(join(dir, rel), "utf8");
+      files.push({
+        skill,
+        skillClass,
+        path: `${skillDir(skill)}/${rel}`,
+        content: rel === "SKILL.md" ? renderSkillFile(skillClass, raw, version) : raw
+      });
+    }
+  }
+  return files;
+}
+function loadTemplateFiles(packRoot = resolvePackRoot(), version = resolvePackageVersion()) {
+  return loadClass(packRoot, "template", TEMPLATE_SKILLS, version);
+}
+function loadMaintainedFiles(packRoot = resolvePackRoot(), version = resolvePackageVersion()) {
+  return loadClass(packRoot, "maintained", MAINTAINED_SKILLS, version);
+}
+function writeMaintainedFiles(repoRoot, files) {
+  const created = [];
+  const rewritten = [];
+  for (const file of files) {
+    const abs = join(repoRoot, file.path);
+    const exists = existsSync(abs);
+    if (exists && readFileSync(abs, "utf8") === file.content) continue;
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, file.content);
+    (exists ? rewritten : created).push(file.path);
+  }
+  return { created, rewritten };
+}
+function maintainedFilesForExistingSkills(repoRoot, files) {
+  return files.filter((file) => existsSync(join(repoRoot, skillDir(file.skill))));
+}
+
+export { MAINTAINED_SKILLS, TEMPLATE_SKILLS, loadMaintainedFiles, loadTemplateFiles, maintainedFilesForExistingSkills, resolvePackRoot, skillDir, writeMaintainedFiles };

package/dist/chunk-WZBHBH3J.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+createRequire(import.meta.url);
+
+// src/tracker-number.ts
+var MAX_TRACKER_NUMBER = Number.MAX_SAFE_INTEGER;
+function parseTrackerNumber(raw) {
+  if (raw === void 0) return void 0;
+  const text = typeof raw === "number" ? String(raw) : raw;
+  if (!/^\d+$/.test(text)) return void 0;
+  const n = Number(text);
+  if (!Number.isSafeInteger(n) || n <= 0) return void 0;
+  return n;
+}
+function trackerNumberError(flag, raw) {
+  return `invalid ${flag} "${raw}" \u2014 expected a positive integer no larger than ${MAX_TRACKER_NUMBER}`;
+}
+
+export { parseTrackerNumber, trackerNumberError };

package/dist/{chunk-IWIUYLDR.js → chunk-XCCLFVXM.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'node:module';
 import { homeFromEnv } from './chunk-VNVZDWO3.js';
-import { existsSync, readFileSync, unlinkSync, readdirSync, mkdirSync, writeFileSync, chmodSync } from 'fs';
+import { mkdirSync, chmodSync, writeFileSync, readFileSync, readdirSync, existsSync, unlinkSync } from 'fs';
 import { join, isAbsolute, dirname, basename, resolve } from 'path';
 import { execFileSync } from 'child_process';
 
@@ -74,138 +74,103 @@ function contextExcludesPresent(gitCommonDir) {
   if (beginIdx === -1) return false;
   return BLOCK_LINES.every((l, i) => lines[beginIdx + i] === l);
 }
-var POST_REWRITE_MARKER = "# outerlayer post-rewrite journal";
-var POST_REWRITE_VERSION = `${POST_REWRITE_MARKER} v1`;
-var POST_REWRITE_HOOK_SCRIPT = `#!/bin/sh
-${POST_REWRITE_VERSION}
-# Appends exact old->new commit pairs (amend/rebase, incl. squashes) to the
-# OuterLayer spool so rewritten history stays creditable to the recorded
-# sessions that produced it. Always exits 0: journaling must never break a
-# rebase.
-# On a machine without OuterLayer (this hook can be committed into a repo
-# and run for every contributor) there is nothing to journal and no reason
-# to create ~/.outerlayer: bow out before touching the filesystem.
-[ -n "$OUTERLAYER_SPOOL_DIR" ] || [ -d "$HOME/.outerlayer" ] || exit 0
-SPOOL_DIR="\${OUTERLAYER_SPOOL_DIR:-$HOME/.outerlayer/spool}"
-mkdir -p "$SPOOL_DIR" 2>/dev/null || exit 0
-FILE="$SPOOL_DIR/rewrites.jsonl"
-if [ -f "$FILE" ] && [ "$(wc -c < "$FILE" 2>/dev/null || echo 0)" -gt 5242880 ]; then
-  mv -f "$FILE" "$FILE.1" 2>/dev/null || true
+var HOOKS_DIR_NAME = "git-hooks";
+var CO_AUTHOR_FILE = "co-author";
+var HOOKS = [
+  "applypatch-msg",
+  "pre-applypatch",
+  "post-applypatch",
+  "pre-commit",
+  "pre-merge-commit",
+  "prepare-commit-msg",
+  "commit-msg",
+  "post-commit",
+  "pre-rebase",
+  "post-checkout",
+  "post-merge",
+  "pre-push",
+  "pre-receive",
+  "update",
+  "post-receive",
+  "post-update",
+  "reference-transaction",
+  "pre-auto-gc",
+  "post-rewrite",
+  "sendemail-validate",
+  "post-index-change"
+];
+var READS_STDIN = /* @__PURE__ */ new Set(["pre-push", "pre-receive", "post-receive", "reference-transaction", "post-rewrite"]);
+var PRE_COMMIT_GUARD_MARKER = "# outerlayer materialized-context commit guard";
+var RUN_GUARD = `common=$(git rev-parse --git-common-dir 2>/dev/null)
+guard=$common/hooks/pre-commit
+if [ "$guard" != "$hook" ] && [ -f "$guard" ] && [ -x "$guard" ] &&
+  sed -n 2p "$guard" | grep -q '^${PRE_COMMIT_GUARD_MARKER}'; then
+  "$guard" "$@" || exit $?
 fi
-REPO="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
-if [ -z "$REPO" ]; then
-  REPO="$(git rev-parse --git-common-dir 2>/dev/null)" || exit 0
-  case "$REPO" in /*) ;; *) REPO="$PWD/$REPO" ;; esac
+`;
+var ADD_TRAILER = `
+# Every commit of the build names the requester once: a trailer already there is left alone.
+file=\${1-}
+if [ -n "$file" ] && [ -f "$file" ]; then
+  git interpret-trailers --in-place --if-exists addIfDifferent --trailer "Co-authored-by: $(cat "$here/${CO_AUTHOR_FILE}")" "$file" ||
+    echo "outerlayer: could not add the co-author line to the commit message" >&2
 fi
-TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-awk -v repo="$REPO" -v ts="$TS" -v src="$1" '
-  NF >= 2 && $1 ~ /^[0-9a-f]+$/ && $2 ~ /^[0-9a-f]+$/ {
-    pairs = pairs (n ? "," : "") "[\\"" $1 "\\",\\"" $2 "\\"]"; n++
-  }
-  END {
-    if (n) {
-      gsub(/\\\\/, "\\\\\\\\", repo); gsub(/"/, "\\\\\\"", repo)
-      printf "{\\"t\\":\\"%s\\",\\"repo\\":\\"%s\\",\\"source\\":\\"%s\\",\\"pairs\\":[%s]}\\n", ts, repo, src, pairs
-    }
-  }
-' >> "$FILE" 2>/dev/null || true
-exit 0
 `;
-var POST_COMMIT_HOOK_SCRIPT = `#!/bin/sh
-${POST_REWRITE_VERSION}
-# Appends every commit's SHA to the OuterLayer spool the moment it exists,
-# so a session whose transcript lost git's porcelain line (piped or muted
-# output) can still be credited at sync time. Always exits 0.
-# On a machine without OuterLayer (this hook can be committed into a repo
-# and run for every contributor) there is nothing to journal and no reason
-# to create ~/.outerlayer: bow out before touching the filesystem.
-[ -n "$OUTERLAYER_SPOOL_DIR" ] || [ -d "$HOME/.outerlayer" ] || exit 0
-SPOOL_DIR="\${OUTERLAYER_SPOOL_DIR:-$HOME/.outerlayer/spool}"
-mkdir -p "$SPOOL_DIR" 2>/dev/null || exit 0
-FILE="$SPOOL_DIR/commits.jsonl"
-if [ -f "$FILE" ] && [ "$(wc -c < "$FILE" 2>/dev/null || echo 0)" -gt 5242880 ]; then
-  mv -f "$FILE" "$FILE.1" 2>/dev/null || true
+var HOOK_WRAPPER_MARKER = "# Written by the OuterLayer runner.";
+function script(name) {
+  const adds = name === "prepare-commit-msg";
+  return `#!/bin/sh
+${HOOK_WRAPPER_MARKER} Runs the repository's own ${name} hook, then
+# ${adds ? "adds the co-author line to the commit message" : "hands its status on"}.
+here=$(dirname "$0")
+
+# The hooks path git would use without this directory: cut the list of configuration
+# entries the runner passes just before its own core.hooksPath entry, then ask git.
+n=\${GIT_CONFIG_COUNT-0}
+case $n in '' | *[!0-9]*) n=0 ;; esac
+cut=$n
+i=$n
+while [ "$i" -gt 0 ]; do
+  i=$((i - 1))
+  eval "key=\\\${GIT_CONFIG_KEY_$i-}"
+  eval "value=\\\${GIT_CONFIG_VALUE_$i-}"
+  if [ "$key" = core.hooksPath ] && { [ "$value" = "$here" ] || [ "$value" -ef "$here" ]; }; then
+    cut=$i
+    break
+  fi
+done
+path=$(GIT_CONFIG_COUNT=$cut git config --type=path core.hooksPath 2>/dev/null) || path=
+if [ -z "$path" ]; then
+  path=$(git rev-parse --git-common-dir 2>/dev/null)/hooks
 fi
-REPO="$(git rev-parse --path-format=absolute --git-common-dir 2>/dev/null)"
-if [ -z "$REPO" ]; then
-  REPO="$(git rev-parse --git-common-dir 2>/dev/null)" || exit 0
-  case "$REPO" in /*) ;; *) REPO="$PWD/$REPO" ;; esac
+
+hook=$path/${name}
+${name === "pre-commit" ? RUN_GUARD : ""}status=0
+if [ "$path" -ef "$here" ] || [ ! -f "$hook" ] || [ ! -x "$hook" ]; then
+${READS_STDIN.has(name) ? "  cat >/dev/null\n" : ""}  :
+else
+${adds ? `  "$hook" "$@" || status=$?` : `  exec "$hook" "$@"`}
 fi
-SHA="$(git rev-parse HEAD 2>/dev/null)" || exit 0
-TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
-case "$SHA" in
-  *[!0-9a-f]*) exit 0 ;;
-esac
-REPO_ESCAPED=$(printf '%s' "$REPO" | sed -e 's/\\\\/\\\\\\\\/g' -e 's/"/\\\\"/g')
-printf '{"t":"%s","repo":"%s","sha":"%s"}
-' "$TS" "$REPO_ESCAPED" "$SHA" >> "$FILE" 2>/dev/null || true
-exit 0
+${adds ? `[ "$status" -eq 0 ] || exit "$status"
+${ADD_TRAILER}` : ""}exit 0
 `;
-var PREPARE_COMMIT_MSG_HOOK_SCRIPT = `#!/bin/sh
-${POST_REWRITE_VERSION}
-# Appends "OuterLayer-Session: <id>" to commits made during a recorded agent
-# session, so the commit itself carries the session identity through squash
-# and cross-machine rebases (the server-side trailer tier parses it). Stamps
-# NOTHING outside a session: the agent env marker is required, and the id
-# comes from the shell's own session variable \u2014 exact, because the commit
-# process is a child of the session that issued it \u2014 with the spool journal
-# as the fallback for harnesses that don't export one. Always exits 0.
-# The journal-fallback selection rules mirror detectActiveSession in
-# packages/cli/src/session-detect.ts \u2014 keep them in step.
-[ -n "$OUTERLAYER_NO_TRAILER" ] && exit 0
-[ -n "$CLAUDECODE" ] || exit 0
-MSG_FILE="$1"
-[ -f "$MSG_FILE" ] || exit 0
-grep -qi '^outerlayer-session:' "$MSG_FILE" 2>/dev/null && exit 0
-SID="$CLAUDE_CODE_SESSION_ID"
-case "$SID" in
-  *[!0-9a-fA-F-]*) SID="" ;;
-esac
-if [ -n "$SID" ]; then
-  printf '\\nOuterLayer-Session: %s\\n' "$SID" >> "$MSG_FILE" 2>/dev/null || true
-  exit 0
-fi
-SPOOL_DIR="\${OUTERLAYER_SPOOL_DIR:-$HOME/.outerlayer/spool}"
-EVENTS="$SPOOL_DIR/events.jsonl"
-[ -f "$EVENTS" ] || exit 0
-TOP="$(git rev-parse --show-toplevel 2>/dev/null)" || exit 0
-[ -n "$TOP" ] || exit 0
-TOP_REAL="$(cd "$TOP" 2>/dev/null && pwd -P)" || TOP_REAL="$TOP"
-CUTOFF="$(date -u -v-24H +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -d '24 hours ago' +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo 1970-01-01T00:00:00Z)"
-SID="$(tail -c 65536 "$EVENTS" 2>/dev/null | awk -v top="$TOP" -v topr="$TOP_REAL" -v cutoff="$CUTOFF" '
-  function field(line, key,   re, v) {
-    re = "\\"" key "\\":\\"[^\\"]*\\""
-    if (match(line, re) == 0) return ""
-    v = substr(line, RSTART, RLENGTH)
-    sub("^\\"" key "\\":\\"", "", v); sub("\\"$", "", v)
-    return v
-  }
-  # macOS spells one directory two ways (/var is a symlink to /private/var);
-  # git reports the resolved form while the session recorded the launch
-  # spelling, so both sides normalize before comparing.
-  function norm(p) { sub(/^\\/private\\//, "/", p); return p }
-  function cwdMatches(c,   cn, tn, rn) {
-    cn = norm(c); tn = norm(top); rn = norm(topr)
-    return cn == tn || cn == rn || index(cn, tn "/") == 1 || index(cn, rn "/") == 1
-  }
-  /^\\{/ {
-    sid = field($0, "sessionId"); if (sid == "") next
-    ev = field($0, "event")
-    if (ev == "SessionEnd") { ended[sid] = 1; next }
-    t = field($0, "t"); c = field($0, "cwd")
-    if (t >= cutoff && cwdMatches(c)) { lastAt[sid] = NR }
-  }
-  END {
-    best = ""; bestNr = 0
-    for (sid in lastAt) if (!ended[sid] && lastAt[sid] > bestNr) { best = sid; bestNr = lastAt[sid] }
-    if (best != "" && best ~ /^[0-9a-fA-F-]+$/) print best
+}
+function writeCommitHooks(buildDir, coAuthor) {
+  const dir = join(buildDir, HOOKS_DIR_NAME);
+  mkdirSync(dir, { recursive: true });
+  chmodSync(dir, 493);
+  for (const name of HOOKS) {
+    const path = join(dir, name);
+    writeFileSync(path, script(name));
+    chmodSync(path, 493);
   }
-')"
-[ -n "$SID" ] || exit 0
-printf '\\nOuterLayer-Session: %s\\n' "$SID" >> "$MSG_FILE" 2>/dev/null || true
-exit 0
-`;
-var PRE_COMMIT_GUARD_MARKER = "# outerlayer materialized-context commit guard";
+  const data = join(dir, CO_AUTHOR_FILE);
+  writeFileSync(data, `${coAuthor.name} <${coAuthor.email}>
+`);
+  chmodSync(data, 420);
+  return dir;
+}
+var JOURNAL_HOOK_MARKER = "# outerlayer post-rewrite journal";
 var PRE_COMMIT_GUARD_VERSION = `${PRE_COMMIT_GUARD_MARKER} v1`;
 var PRE_COMMIT_GUARD_BODY_SIGNATURE = "outerlayer: refusing to commit materialized control-plane context";
 var PRE_COMMIT_GUARD_SCRIPT = `#!/bin/sh
@@ -242,15 +207,10 @@ echo "  $REMEDY" >&2
 exit 1
 `;
 function managedHookScripts() {
-  return [
-    ["post-rewrite", printableHookScript(POST_REWRITE_HOOK_SCRIPT)],
-    ["post-commit", printableHookScript(POST_COMMIT_HOOK_SCRIPT)],
-    ["prepare-commit-msg", printableHookScript(PREPARE_COMMIT_MSG_HOOK_SCRIPT)],
-    ["pre-commit", printableHookScript(PRE_COMMIT_GUARD_SCRIPT)]
-  ];
+  return [["pre-commit", printableHookScript(PRE_COMMIT_GUARD_SCRIPT)]];
 }
-function printableHookScript(script) {
-  const lines = script.split("\n");
+function printableHookScript(script2) {
+  const lines = script2.split("\n");
   return [lines[0], ...lines.slice(2)].join("\n");
 }
 function git(cwd, args) {
@@ -276,7 +236,7 @@ function commonHooksDir(cwd) {
   if (rel === void 0) return void 0;
   return join(isAbsolute(rel) ? rel : join(cwd, rel), "hooks");
 }
-function installHookFile(dir, name, script, marker) {
+function installHookFile(dir, name, script2, marker) {
   const path = join(dir, name);
   let existing;
   try {
@@ -286,7 +246,7 @@ function installHookFile(dir, name, script, marker) {
   }
   if (existing !== void 0) {
     if (!isOwnRecognitionLine(existing, marker)) return "skipped-foreign";
-    if (existing === script) {
+    if (existing === script2) {
       try {
         chmodSync(path, 493);
       } catch {
@@ -295,36 +255,10 @@ function installHookFile(dir, name, script, marker) {
     }
   }
   mkdirSync(dir, { recursive: true });
-  writeFileSync(path, script);
+  writeFileSync(path, script2);
   chmodSync(path, 493);
   return existing === void 0 ? "installed" : "updated";
 }
-function installPostRewriteHook(cwd, opts) {
-  const stampTrailers = opts?.stampTrailers ?? true;
-  const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
-  if (inRepo !== "true") return { status: "not-a-repo" };
-  if ((git(cwd, ["config", "core.hooksPath"]) ?? "") !== "") {
-    return { status: "skipped-custom-hooks-path" };
-  }
-  const dir = hooksDir(cwd);
-  if (dir === void 0) return { status: "not-a-repo" };
-  const pairOutcomes = [
-    installHookFile(dir, "post-rewrite", POST_REWRITE_HOOK_SCRIPT, POST_REWRITE_MARKER),
-    installHookFile(dir, "post-commit", POST_COMMIT_HOOK_SCRIPT, POST_REWRITE_MARKER)
-  ];
-  const outcomes = [...pairOutcomes];
-  if (stampTrailers) {
-    outcomes.push(installHookFile(dir, "prepare-commit-msg", PREPARE_COMMIT_MSG_HOOK_SCRIPT, POST_REWRITE_MARKER));
-  } else {
-    removeOurHookFile(join(dir, "prepare-commit-msg"), POST_REWRITE_MARKER);
-  }
-  const path = join(dir, "post-rewrite");
-  if (pairOutcomes.every((o) => o === "skipped-foreign")) return { status: "skipped-foreign", path };
-  if (outcomes.every((o) => o === "unchanged")) return { status: "unchanged", path };
-  if (outcomes.includes("updated")) return { status: "updated", path };
-  if (outcomes.includes("installed")) return { status: "installed", path };
-  return { status: "skipped-foreign", path };
-}
 function removeOurHookFile(path, marker) {
   if (!existsSync(path)) return false;
   let content;
@@ -341,33 +275,14 @@ function isOwnRecognitionLine(content, marker) {
   const secondLine = content.split("\n", 2)[1];
   return secondLine !== void 0 && secondLine.startsWith(marker);
 }
-function removePostRewriteHook(cwd) {
+function removeJournalHooks(cwd) {
   const dir = hooksDir(cwd);
   if (dir === void 0) return { removed: false };
   let removed = false;
   for (const name of ["post-rewrite", "post-commit", "prepare-commit-msg"]) {
-    if (removeOurHookFile(join(dir, name), POST_REWRITE_MARKER)) removed = true;
+    if (removeOurHookFile(join(dir, name), JOURNAL_HOOK_MARKER)) removed = true;
   }
-  return { removed, path: join(dir, "post-rewrite") };
-}
-function postRewriteHookPresence(cwd) {
-  const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
-  if (inRepo !== "true") return "not-a-repo";
-  if ((git(cwd, ["config", "core.hooksPath"]) ?? "") !== "") return "custom-hooks-path";
-  const dir = hooksDir(cwd);
-  if (dir === void 0) return "not-a-repo";
-  const states = ["post-rewrite", "post-commit"].map((name) => {
-    let content;
-    try {
-      content = readFileSync(join(dir, name), "utf8");
-    } catch {
-      return "absent";
-    }
-    return content.includes(POST_REWRITE_MARKER) ? "ours" : "foreign";
-  });
-  if (states.every((st) => st === "ours")) return "ours";
-  if (states.includes("foreign")) return "foreign";
-  return "absent";
+  return { removed, path: dir };
 }
 function installPreCommitGuardHook(cwd) {
   const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
@@ -417,15 +332,29 @@ function expandHooksPathTilde(hooksPath) {
 }
 function ensurePreCommitGuardHook(repoRoot, gitCommonDir) {
   const hooksPath = git(repoRoot, ["config", "core.hooksPath"]) ?? "";
-  if (hooksPath !== "") {
+  if (hooksPath !== "" && !isRunnerHookWrapper(hooksPath, repoRoot)) {
     const expanded = expandHooksPathTilde(hooksPath);
     const effectivePath = isAbsolute(expanded) ? join(expanded, "pre-commit") : join(repoRoot, expanded, "pre-commit");
     return { status: "skipped-custom-hooks-path", adopted: guardAdoptedAtEffectiveHook(effectivePath) };
   }
+  return installPreCommitGuardInGitDir(gitCommonDir);
+}
+function installPreCommitGuardInGitDir(gitCommonDir) {
   const path = join(gitCommonDir, "hooks", "pre-commit");
   const status = installHookFile(join(gitCommonDir, "hooks"), "pre-commit", PRE_COMMIT_GUARD_SCRIPT, PRE_COMMIT_GUARD_MARKER);
   return { status, adopted: status === "skipped-foreign" ? guardBodyPresent(path) : true };
 }
+function isRunnerHookWrapper(hooksPath, repoRoot) {
+  const dir = resolve(repoRoot, expandHooksPathTilde(hooksPath));
+  if (basename(dir) !== HOOKS_DIR_NAME) return false;
+  try {
+    const script2 = readFileSync(join(dir, "pre-commit"), "utf8");
+    const secondLine = script2.indexOf("\n") + 1;
+    return secondLine > 0 && script2.startsWith(HOOK_WRAPPER_MARKER, secondLine);
+  } catch {
+    return false;
+  }
+}
 function deadHooksState(cwd) {
   const inRepo = git(cwd, ["rev-parse", "--is-inside-work-tree"]);
   if (inRepo !== "true") return { dead: false };
@@ -462,11 +391,11 @@ function preparePackageManagerCommand(repoRoot) {
 function huskyPrepareScript(repoRoot) {
   try {
     const pkg = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8"));
-    const script = pkg.scripts?.prepare;
-    if (typeof script === "string" && /husky/i.test(script)) return script;
+    const script2 = pkg.scripts?.prepare;
+    if (typeof script2 === "string" && /husky/i.test(script2)) return script2;
   } catch {
   }
   return null;
 }
 
-export { contextExcludesPresent, deadHooksState, ensureContextExcludes, ensurePreCommitGuardHook, huskyPrepareScript, installPostRewriteHook, installPreCommitGuardHook, managedHookScripts, postRewriteHookPresence, preparePackageManagerCommand, removePostRewriteHook, removePreCommitGuardHook };
+export { HOOKS_DIR_NAME, contextExcludesPresent, deadHooksState, ensureContextExcludes, ensurePreCommitGuardHook, huskyPrepareScript, installPreCommitGuardHook, installPreCommitGuardInGitDir, managedHookScripts, preparePackageManagerCommand, removeJournalHooks, removePreCommitGuardHook, writeCommitHooks };