@primitive.ai/prim 0.1.0-alpha.65 → 0.1.0-alpha.67

package/dist/{chunk-CPHJUQNE.js → chunk-XPVNH3J6.js}

@@ -9,7 +9,7 @@ import {
   HttpError,
   getClient,
   withFileLock
-} from "./chunk-CPX3BUOC.js";
+} from "./chunk-RTLFE6EZ.js";
 
 // src/commands/skill.ts
 import { randomUUID } from "crypto";
@@ -616,6 +616,9 @@ import { basename, dirname as dirname3, isAbsolute as isAbsolute2, resolve as re
 var PRIM_POST_COMMIT_BLOCK_START = "# >>> prim post-commit hook >>>";
 var PRIM_POST_COMMIT_BLOCK_END = "# <<< prim post-commit hook <<<";
 var PRIM_CREATED_MARK = "prim-created-post-commit-hook";
+var PRIM_POST_REWRITE_BLOCK_START = "# >>> prim post-rewrite hook >>>";
+var PRIM_POST_REWRITE_BLOCK_END = "# <<< prim post-rewrite hook <<<";
+var PRIM_POST_REWRITE_CREATED_MARK = "prim-created-post-rewrite-hook";
 var LEGACY_PRIM_CREATED_MARK = "prim-created-hook";
 var LEGACY_PRIM_OWNED_HEADER = "# prim post-commit hook \u2014 installed by: prim hooks install (prim-managed-hook)";
 var LEGACY_GLOBAL_OWNED_HEADER = "# prim global post-commit hook (core.hooksPath) \u2014 managed by prim; do not edit.";
@@ -684,6 +687,67 @@ ${PRIM_POST_COMMIT_BLOCK_END}`;
 function postCommitHookBlock() {
   return currentPostCommitBlock();
 }
+function postRewriteHookBlock() {
+  return `${PRIM_POST_REWRITE_BLOCK_START}
+if [ "$(git config --get prim.active 2>/dev/null)" = "true" ]; then
+  case "$1" in amend|rebase) prim_rewrite_source="$1" ;; *) prim_rewrite_source= ;; esac
+  if [ -n "$prim_rewrite_source" ]; then
+    prim_rewrite_pairs_file=$(mktemp "\${TMPDIR:-/tmp}/prim-post-rewrite-pairs.XXXXXXXX" 2>/dev/null) || prim_rewrite_pairs_file=
+    if [ -n "$prim_rewrite_pairs_file" ] && ! chmod 600 "$prim_rewrite_pairs_file" 2>/dev/null; then
+      rm -f "$prim_rewrite_pairs_file"
+      prim_rewrite_pairs_file=
+    fi
+    if [ -n "$prim_rewrite_pairs_file" ]; then
+      if cat > "$prim_rewrite_pairs_file"; then
+        exec < "$prim_rewrite_pairs_file"
+        prim_rewrite_branch=$(git symbolic-ref --quiet --short HEAD 2>/dev/null) || prim_rewrite_branch=
+        prim_cache_dir="\${XDG_CACHE_HOME:-$HOME/.cache}/prim/bin"
+        prim_post_rewrite_ran=0
+        if [ "\${PRIM_BIN_CACHE:-1}" != "0" ] && [ -f "$prim_cache_dir/prim-post-rewrite" ] && [ -f "$prim_cache_dir/node" ] && [ -n "$(find "$prim_cache_dir/prim-post-rewrite" -mmin "-\${PRIM_BIN_CACHE_TTL_MIN:-1440}" 2>/dev/null)" ]; then
+          prim_node=$(cat "$prim_cache_dir/node")
+          prim_entry=$(cat "$prim_cache_dir/prim-post-rewrite")
+          if [ -x "$prim_node" ] && [ -f "$prim_entry" ]; then
+            ( trap '' HUP; trap 'if [ -n "$prim_rewrite_pairs_file" ]; then rm -f "$prim_rewrite_pairs_file"; fi' 0; export PRIM_REWRITE_SOURCE="$prim_rewrite_source" PRIM_REWRITE_BRANCH="$prim_rewrite_branch" PRIM_REWRITE_PAIRS_FILE="$prim_rewrite_pairs_file"; "$prim_node" "$prim_entry" ) </dev/null >/dev/null 2>&1 &
+            prim_post_rewrite_ran=1
+          fi
+        fi
+        if [ "$prim_post_rewrite_ran" -eq 0 ]; then
+          if [ -x "./node_modules/.bin/prim-post-rewrite" ]; then
+            ( trap '' HUP; trap 'if [ -n "$prim_rewrite_pairs_file" ]; then rm -f "$prim_rewrite_pairs_file"; fi' 0; export PRIM_REWRITE_SOURCE="$prim_rewrite_source" PRIM_REWRITE_BRANCH="$prim_rewrite_branch" PRIM_REWRITE_PAIRS_FILE="$prim_rewrite_pairs_file"; ./node_modules/.bin/prim-post-rewrite ) </dev/null >/dev/null 2>&1 &
+            prim_post_rewrite_ran=1
+          elif command -v npx >/dev/null 2>&1; then
+            ( trap '' HUP; trap 'if [ -n "$prim_rewrite_pairs_file" ]; then rm -f "$prim_rewrite_pairs_file"; fi' 0; export PRIM_REWRITE_SOURCE="$prim_rewrite_source" PRIM_REWRITE_BRANCH="$prim_rewrite_branch" PRIM_REWRITE_PAIRS_FILE="$prim_rewrite_pairs_file"; npx --yes -p @primitive.ai/prim@latest prim-post-rewrite ) </dev/null >/dev/null 2>&1 &
+            prim_post_rewrite_ran=1
+          fi
+        fi
+        if [ "$prim_post_rewrite_ran" -eq 0 ]; then
+          rm -f "$prim_rewrite_pairs_file"
+        fi
+        unset prim_cache_dir prim_post_rewrite_ran prim_node prim_entry prim_rewrite_branch
+      else
+        rm -f "$prim_rewrite_pairs_file"
+      fi
+      unset prim_rewrite_pairs_file
+    fi
+  fi
+  unset prim_rewrite_source
+fi
+${PRIM_POST_REWRITE_BLOCK_END}`;
+}
+var POST_COMMIT_MANAGED_HOOK = {
+  hookName: "post-commit",
+  blockStart: PRIM_POST_COMMIT_BLOCK_START,
+  blockEnd: PRIM_POST_COMMIT_BLOCK_END,
+  createdMark: PRIM_CREATED_MARK,
+  block: postCommitHookBlock
+};
+var POST_REWRITE_MANAGED_HOOK = {
+  hookName: "post-rewrite",
+  blockStart: PRIM_POST_REWRITE_BLOCK_START,
+  blockEnd: PRIM_POST_REWRITE_BLOCK_END,
+  createdMark: PRIM_POST_REWRITE_CREATED_MARK,
+  block: postRewriteHookBlock
+};
 function legacyFloatingInvocation() {
   return `if command -v prim-post-commit >/dev/null 2>&1; then
   prim-post-commit || true
@@ -739,10 +803,10 @@ function isKnownLegacyGlobalGate(value) {
   const suffix = Buffer.from("\nfi\n");
   return value.subarray(0, prefix.length).equals(prefix) && value.subarray(-suffix.length).equals(suffix) && isPinnedInvocation(value.subarray(prefix.length, -suffix.length).toString("utf8"));
 }
-function createdScaffold() {
+function createdScaffold(spec) {
   return Buffer.from(`#!/bin/sh
-${currentPostCommitBlock()}
-# ${PRIM_CREATED_MARK}
+${spec.block()}
+# ${spec.createdMark}
 `);
 }
 function safeGitPath(root, value) {
@@ -751,7 +815,7 @@ function safeGitPath(root, value) {
   }
   return isAbsolute2(value) ? resolve3(value) : resolve3(root, value);
 }
-function resolveEffectivePostCommitHook(cwd = process.cwd()) {
+function resolveEffectiveManagedHook(spec, cwd = process.cwd()) {
   const gitRoot = gitToplevel(cwd);
   if (!gitRoot) throw new Error("not a git repository");
   const value = execFileSync("git", ["rev-parse", "--git-path", "hooks"], {
@@ -765,42 +829,49 @@ function resolveEffectivePostCommitHook(cwd = process.cwd()) {
     return {
       gitRoot,
       hooksDir,
-      hookPath: resolve3(dirname3(hooksDir), "post-commit"),
+      hookPath: resolve3(dirname3(hooksDir), spec.hookName),
       kind: "husky_v9",
-      dispatcherPath: resolve3(hooksDir, "post-commit")
+      dispatcherPath: resolve3(hooksDir, spec.hookName)
     };
   }
   return {
     gitRoot,
     hooksDir,
-    hookPath: resolve3(hooksDir, "post-commit"),
+    hookPath: resolve3(hooksDir, spec.hookName),
     kind: "direct"
   };
 }
-function assertSafeFile(path) {
+function resolveEffectivePostCommitHook(cwd = process.cwd()) {
+  return resolveEffectiveManagedHook(POST_COMMIT_MANAGED_HOOK, cwd);
+}
+function resolveEffectivePostRewriteHook(cwd = process.cwd()) {
+  return resolveEffectiveManagedHook(POST_REWRITE_MANAGED_HOOK, cwd);
+}
+function assertSafeFile(path, spec) {
   if (!existsSync3(path)) return void 0;
   const stat = lstatSync3(path);
   if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_HOOK_BYTES) {
-    throw new Error(`unsafe post-commit hook target: ${path}`);
+    throw new Error(`unsafe ${spec.hookName} hook target: ${path}`);
   }
   return stat;
 }
-function assertUsableHuskyDispatcher(target) {
+function assertUsableHuskyDispatcher(target, spec) {
   if (!target.dispatcherPath) return;
-  const stat = assertSafeFile(target.dispatcherPath);
+  const stat = assertSafeFile(target.dispatcherPath, spec);
   if (!stat || (stat.mode & 64) === 0) {
     throw new Error(
-      `Husky post-commit dispatcher is missing or not executable: ${target.dispatcherPath}`
+      `Husky ${spec.hookName} dispatcher is missing or not executable: ${target.dispatcherPath}`
     );
   }
-  const dispatcher = decodeHookText(readHookFile(target.dispatcherPath));
-  if (dispatcher === HUSKY_DIRECT_DISPATCHER) return;
+  const dispatcher = decodeHookText(readHookFile(target.dispatcherPath), spec);
+  const directDispatcher = HUSKY_DIRECT_DISPATCHER.replaceAll("post-commit", spec.hookName);
+  if (dispatcher === directDispatcher) return;
   const normalizedDispatcher = dispatcher.endsWith("\n") ? dispatcher.slice(0, -1) : dispatcher;
   if (!HUSKY_V9_DISPATCHERS.has(normalizedDispatcher)) {
-    throw new Error(`unrecognized Husky post-commit dispatcher: ${target.dispatcherPath}`);
+    throw new Error(`unrecognized Husky ${spec.hookName} dispatcher: ${target.dispatcherPath}`);
   }
   const huskyRuntime = resolve3(dirname3(target.dispatcherPath), "h");
-  const runtimeStat = assertSafeFile(huskyRuntime);
+  const runtimeStat = assertSafeFile(huskyRuntime, spec);
   const runtime = runtimeStat ? readHookFile(huskyRuntime) : void 0;
   const runtimeHash = runtime ? createHash2("sha256").update(runtime).digest("hex") : void 0;
   if (!runtimeHash || !HUSKY_V9_RUNTIME_HASHES.has(runtimeHash)) {
@@ -811,28 +882,28 @@ function readHookFile(path) {
   const value = readFileSync3(path);
   return Buffer.isBuffer(value) ? value : Buffer.from(value);
 }
-function decodeHookText(content) {
-  if (content.includes(0)) throw new Error("binary post-commit hook");
+function decodeHookText(content, spec) {
+  if (content.includes(0)) throw new Error(`binary ${spec.hookName} hook`);
   try {
     return new TextDecoder("utf-8", { fatal: true }).decode(content);
   } catch {
-    throw new Error("binary post-commit hook");
+    throw new Error(`binary ${spec.hookName} hook`);
   }
 }
-function supportedShebangEnd(content) {
-  const text = decodeHookText(content);
+function supportedShebangEnd(content, spec) {
+  const text = decodeHookText(content, spec);
   const newline = text.indexOf("\n");
   const shebang = newline === -1 ? text : text.slice(0, newline);
   if (!SUPPORTED_SHEBANGS.has(shebang) || newline === -1) {
-    throw new Error("unsupported post-commit hook interpreter");
+    throw new Error(`unsupported ${spec.hookName} hook interpreter`);
   }
   return Buffer.byteLength(text.slice(0, newline + 1), "utf8");
 }
-function shellInsertionPoint(content, allowShebangless) {
-  const text = decodeHookText(content);
-  if (text.startsWith("#!")) return supportedShebangEnd(content);
+function shellInsertionPoint(content, allowShebangless, spec) {
+  const text = decodeHookText(content, spec);
+  if (text.startsWith("#!")) return supportedShebangEnd(content, spec);
   if (allowShebangless) return 0;
-  throw new Error("unsupported post-commit hook interpreter");
+  throw new Error(`unsupported ${spec.hookName} hook interpreter`);
 }
 function allIndexes(haystack, needle) {
   const indexes = [];
@@ -845,28 +916,28 @@ function allIndexes(haystack, needle) {
   }
   return indexes;
 }
-function blockRange(content) {
-  decodeHookText(content);
-  const startMarker = Buffer.from(PRIM_POST_COMMIT_BLOCK_START);
-  const endMarker = Buffer.from(PRIM_POST_COMMIT_BLOCK_END);
+function blockRange(content, spec) {
+  decodeHookText(content, spec);
+  const startMarker = Buffer.from(spec.blockStart);
+  const endMarker = Buffer.from(spec.blockEnd);
   const starts = allIndexes(content, startMarker);
   const ends = allIndexes(content, endMarker);
   if (starts.length === 0 && ends.length === 0) return { kind: "absent" };
   if (starts.length !== 1 || ends.length !== 1 || ends[0] < starts[0]) {
-    throw new Error("malformed Prim post-commit markers");
+    throw new Error(`malformed Prim ${spec.hookName} markers`);
   }
   const start = starts[0];
   const end = ends[0] + endMarker.length;
-  const current = Buffer.from(currentPostCommitBlock());
+  const current = Buffer.from(spec.block());
   return content.subarray(start, end).equals(current) ? { kind: "current", start, end } : { kind: "stale", start, end };
 }
-function mergedContent(existing, allowShebangless) {
-  const block = Buffer.from(currentPostCommitBlock());
+function mergedContent(existing, allowShebangless, spec) {
+  const block = Buffer.from(spec.block());
   if (!existing) {
-    return createdScaffold();
+    return createdScaffold(spec);
   }
-  const range = blockRange(existing);
-  if (range.kind === "absent" && existing.toString("utf8").startsWith(`#!/bin/sh
+  const range = blockRange(existing, spec);
+  if (spec.hookName === POST_COMMIT_MANAGED_HOOK.hookName && range.kind === "absent" && existing.toString("utf8").startsWith(`#!/bin/sh
 ${LEGACY_GLOBAL_OWNED_HEADER}
 `)) {
     const gateAt = existing.indexOf(Buffer.from('if [ "$(git config --get prim.active'));
@@ -881,7 +952,7 @@ ${LEGACY_GLOBAL_OWNED_HEADER}
       existing.subarray(0, gateAt),
       existing.subarray(chainAt)
     ]);
-    const shebangEnd2 = shellInsertionPoint(withoutLegacyGate, allowShebangless);
+    const shebangEnd2 = shellInsertionPoint(withoutLegacyGate, allowShebangless, spec);
     return Buffer.concat([
       withoutLegacyGate.subarray(0, shebangEnd2),
       block,
@@ -889,25 +960,25 @@ ${LEGACY_GLOBAL_OWNED_HEADER}
       withoutLegacyGate.subarray(shebangEnd2)
     ]);
   }
-  if (range.kind === "absent" && existing.toString("utf8").startsWith(`#!/bin/sh
+  if (spec.hookName === POST_COMMIT_MANAGED_HOOK.hookName && range.kind === "absent" && existing.toString("utf8").startsWith(`#!/bin/sh
 ${LEGACY_PRIM_OWNED_HEADER}
 `)) {
     const prefixLength = legacyProjectPrefixLength(existing);
     if (prefixLength === void 0) {
       throw new Error("unrecognized legacy Prim post-commit invocation");
     }
-    return Buffer.concat([createdScaffold(), existing.subarray(prefixLength)]);
+    return Buffer.concat([createdScaffold(spec), existing.subarray(prefixLength)]);
   }
   if (range.kind !== "absent") {
     const oldCreatedPrefixes = [
       Buffer.from(`#!/bin/sh
-# ${PRIM_CREATED_MARK}
+# ${spec.createdMark}
 
 `),
-      Buffer.from(`#!/bin/sh
+      ...spec.hookName === POST_COMMIT_MANAGED_HOOK.hookName ? [Buffer.from(`#!/bin/sh
 # ${LEGACY_PRIM_CREATED_MARK}
 
-`)
+`)] : []
     ];
     const oldCreated = oldCreatedPrefixes.some(
       (prefix) => range.start === prefix.length && existing.subarray(0, prefix.length).equals(prefix)
@@ -915,10 +986,10 @@ ${LEGACY_PRIM_OWNED_HEADER}
     if (oldCreated) {
       const suffix = existing.subarray(range.end);
       const tail = suffix.at(0) === 10 ? suffix.subarray(1) : suffix;
-      return Buffer.concat([createdScaffold(), tail]);
+      return Buffer.concat([createdScaffold(spec), tail]);
     }
   }
-  const shebangEnd = shellInsertionPoint(existing, allowShebangless);
+  const shebangEnd = shellInsertionPoint(existing, allowShebangless, spec);
   if (range.kind === "current" && range.start === shebangEnd) return existing;
   let withoutBlock = existing;
   if (range.kind !== "absent") {
@@ -938,22 +1009,22 @@ ${LEGACY_PRIM_OWNED_HEADER}
 function errorCode(error) {
   return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
 }
-function assertTargetUnchanged(path, expected, stat) {
+function assertTargetUnchanged(path, expected, spec, stat) {
   let current;
   try {
     current = lstatSync3(path);
   } catch (error) {
     if (expected === void 0 && errorCode(error) === "ENOENT") return;
-    throw new Error(`post-commit hook changed concurrently: ${path}`);
+    throw new Error(`${spec.hookName} hook changed concurrently: ${path}`);
   }
   if (expected === void 0) {
-    throw new Error(`post-commit hook appeared concurrently: ${path}`);
+    throw new Error(`${spec.hookName} hook appeared concurrently: ${path}`);
   }
   if (!current.isFile() || current.isSymbolicLink() || current.size > MAX_HOOK_BYTES || current.dev !== stat?.dev || current.ino !== stat?.ino || (current.mode & 4095) !== ((stat?.mode ?? 0) & 4095) || !readHookFile(path).equals(expected)) {
-    throw new Error(`post-commit hook changed concurrently: ${path}`);
+    throw new Error(`${spec.hookName} hook changed concurrently: ${path}`);
   }
 }
-function rewriteHookAtomically(path, next, expected, stat) {
+function rewriteHookAtomically(path, next, expected, spec, stat) {
   const parent = dirname3(path);
   mkdirSync2(parent, { recursive: true });
   const temporary = resolve3(
@@ -972,7 +1043,7 @@ function rewriteHookAtomically(path, next, expected, stat) {
     fsyncSync2(fd);
     closeSync3(fd);
     fd = void 0;
-    assertTargetUnchanged(path, expected, stat);
+    assertTargetUnchanged(path, expected, spec, stat);
     renameSync2(temporary, path);
   } finally {
     if (fd !== void 0) {
@@ -989,32 +1060,36 @@ function rewriteHookAtomically(path, next, expected, stat) {
     }
   }
 }
-function unlinkHookUnchanged(path, expected, stat) {
-  assertTargetUnchanged(path, expected, stat);
+function unlinkHookUnchanged(path, expected, stat, spec) {
+  assertTargetUnchanged(path, expected, spec, stat);
   unlinkSync(path);
 }
 function ensureEffectivePostCommitHook(cwd = process.cwd()) {
   const target = resolveEffectivePostCommitHook(cwd);
-  return ensureTarget(target);
+  return ensureTarget(target, POST_COMMIT_MANAGED_HOOK);
+}
+function ensureEffectivePostRewriteHook(cwd = process.cwd()) {
+  const target = resolveEffectivePostRewriteHook(cwd);
+  return ensureTarget(target, POST_REWRITE_MANAGED_HOOK);
 }
-function ensureTarget(target, initialContent) {
-  assertUsableHuskyDispatcher(target);
-  const stat = assertSafeFile(target.hookPath);
+function ensureTarget(target, spec, initialContent) {
+  assertUsableHuskyDispatcher(target, spec);
+  const stat = assertSafeFile(target.hookPath, spec);
   if (stat && target.kind === "direct" && (stat.mode & 64) === 0) {
-    throw new Error(`existing post-commit hook is not executable: ${target.hookPath}`);
+    throw new Error(`existing ${spec.hookName} hook is not executable: ${target.hookPath}`);
   }
   const existing = stat ? readHookFile(target.hookPath) : void 0;
-  const next = !existing && initialContent !== void 0 ? Buffer.from(initialContent) : mergedContent(existing, target.kind === "husky_v9");
+  const next = !existing && initialContent !== void 0 ? Buffer.from(initialContent) : mergedContent(existing, target.kind === "husky_v9", spec);
   if (!existing && initialContent !== void 0) {
-    const shebangEnd = shellInsertionPoint(next, target.kind === "husky_v9");
-    const range = blockRange(next);
+    const shebangEnd = shellInsertionPoint(next, target.kind === "husky_v9", spec);
+    const range = blockRange(next, spec);
     if (range.kind !== "current" || range.start !== shebangEnd) {
-      throw new Error("invalid initial Prim post-commit scaffold");
+      throw new Error(`invalid initial Prim ${spec.hookName} scaffold`);
     }
   }
   const contentChanged = !existing || !next.equals(existing);
   if (contentChanged) {
-    rewriteHookAtomically(target.hookPath, next, existing, stat);
+    rewriteHookAtomically(target.hookPath, next, existing, spec, stat);
   }
   return { path: target.hookPath, changed: contentChanged || !stat, kind: target.kind };
 }
@@ -1027,14 +1102,35 @@ function ensurePostCommitHookAtPath(hookPath, initialContent) {
       hookPath: absolute,
       kind: "direct"
     },
+    POST_COMMIT_MANAGED_HOOK,
+    initialContent
+  );
+  return { ...result, kind: "direct" };
+}
+function ensurePostRewriteHookAtPath(hookPath, initialContent) {
+  const absolute = resolve3(hookPath);
+  const result = ensureTarget(
+    {
+      gitRoot: dirname3(dirname3(absolute)),
+      hooksDir: dirname3(absolute),
+      hookPath: absolute,
+      kind: "direct"
+    },
+    POST_REWRITE_MANAGED_HOOK,
     initialContent
   );
   return { ...result, kind: "direct" };
 }
 function inspectEffectivePostCommitHook(cwd = process.cwd()) {
-  const target = resolveEffectivePostCommitHook(cwd);
+  return inspectEffectiveManagedHook(POST_COMMIT_MANAGED_HOOK, cwd);
+}
+function inspectEffectivePostRewriteHook(cwd = process.cwd()) {
+  return inspectEffectiveManagedHook(POST_REWRITE_MANAGED_HOOK, cwd);
+}
+function inspectEffectiveManagedHook(spec, cwd) {
+  const target = resolveEffectiveManagedHook(spec, cwd);
   try {
-    assertUsableHuskyDispatcher(target);
+    assertUsableHuskyDispatcher(target, spec);
   } catch (error) {
     const missing = error instanceof Error && (error.message.includes("missing or not executable") || error.message.includes("unsafe"));
     return {
@@ -1047,7 +1143,7 @@ function inspectEffectivePostCommitHook(cwd = process.cwd()) {
   }
   let stat;
   try {
-    stat = assertSafeFile(target.hookPath);
+    stat = assertSafeFile(target.hookPath, spec);
   } catch {
     return {
       ...target,
@@ -1069,8 +1165,8 @@ function inspectEffectivePostCommitHook(cwd = process.cwd()) {
   const executable = target.kind === "husky_v9" || (stat.mode & 64) !== 0;
   try {
     const content = readHookFile(target.hookPath);
-    const shebangEnd = shellInsertionPoint(content, target.kind === "husky_v9");
-    const range = blockRange(content);
+    const shebangEnd = shellInsertionPoint(content, target.kind === "husky_v9", spec);
+    const range = blockRange(content, spec);
     const positioned = range.kind !== "absent" && range.start === shebangEnd;
     const current = range.kind === "current" && positioned;
     return {
@@ -1094,7 +1190,11 @@ function inspectEffectivePostCommitHook(cwd = process.cwd()) {
 }
 function uninstallEffectivePostCommitHook(cwd = process.cwd()) {
   const target = resolveEffectivePostCommitHook(cwd);
-  return uninstallTarget(target);
+  return uninstallTarget(target, POST_COMMIT_MANAGED_HOOK);
+}
+function uninstallEffectivePostRewriteHook(cwd = process.cwd()) {
+  const target = resolveEffectivePostRewriteHook(cwd);
+  return uninstallTarget(target, POST_REWRITE_MANAGED_HOOK);
 }
 function projectHooksPathIsConfigured(gitRoot) {
   for (const scope of ["--worktree", "--local"]) {
@@ -1127,13 +1227,29 @@ function uninstallProjectPostCommitHook(cwd = process.cwd()) {
     resolve3(safeGitPath(gitRoot, commonDir), "hooks", "post-commit")
   );
 }
-function uninstallTarget(target) {
-  const stat = assertSafeFile(target.hookPath);
+function uninstallProjectPostRewriteHook(cwd = process.cwd()) {
+  const gitRoot = gitToplevel(cwd);
+  if (!gitRoot) throw new Error("not a git repository");
+  if (projectHooksPathIsConfigured(gitRoot)) {
+    return uninstallEffectivePostRewriteHook(gitRoot);
+  }
+  const commonDir = execFileSync("git", ["rev-parse", "--git-common-dir"], {
+    cwd: gitRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: GIT_TIMEOUT_MS
+  }).replace(/\r?\n$/u, "");
+  return uninstallPostRewriteHookAtPath(
+    resolve3(safeGitPath(gitRoot, commonDir), "hooks", POST_REWRITE_MANAGED_HOOK.hookName)
+  );
+}
+function uninstallTarget(target, spec) {
+  const stat = assertSafeFile(target.hookPath, spec);
   if (!stat) return { path: target.hookPath, changed: false, removedFile: false };
   const existing = readHookFile(target.hookPath);
-  const range = blockRange(existing);
+  const range = blockRange(existing, spec);
   if (range.kind === "absent") {
-    if (existing.toString("utf8").startsWith(`#!/bin/sh
+    if (spec.hookName === POST_COMMIT_MANAGED_HOOK.hookName && existing.toString("utf8").startsWith(`#!/bin/sh
 ${LEGACY_PRIM_OWNED_HEADER}
 `)) {
       const prefixLength = legacyProjectPrefixLength(existing);
@@ -1142,47 +1258,49 @@ ${LEGACY_PRIM_OWNED_HEADER}
       }
       const tail = existing.subarray(prefixLength);
       if (tail.length === 0) {
-        unlinkHookUnchanged(target.hookPath, existing, stat);
+        unlinkHookUnchanged(target.hookPath, existing, stat, spec);
         return { path: target.hookPath, changed: true, removedFile: true };
       }
       rewriteHookAtomically(
         target.hookPath,
         Buffer.concat([Buffer.from("#!/bin/sh\n"), tail]),
         existing,
+        spec,
         stat
       );
       return { path: target.hookPath, changed: true, removedFile: false };
     }
     return { path: target.hookPath, changed: false, removedFile: false };
   }
-  const shebangEnd = shellInsertionPoint(existing, target.kind === "husky_v9");
+  const shebangEnd = shellInsertionPoint(existing, target.kind === "husky_v9", spec);
   const suffix = existing.subarray(range.end);
   const createdSuffix = Buffer.from(`
-# ${PRIM_CREATED_MARK}
+# ${spec.createdMark}
 `);
   if (range.start === shebangEnd && suffix.subarray(0, createdSuffix.length).equals(createdSuffix)) {
     const tail = suffix.subarray(createdSuffix.length);
     if (tail.length === 0) {
-      unlinkHookUnchanged(target.hookPath, existing, stat);
+      unlinkHookUnchanged(target.hookPath, existing, stat, spec);
       return { path: target.hookPath, changed: true, removedFile: true };
     }
     rewriteHookAtomically(
       target.hookPath,
       Buffer.concat([existing.subarray(0, shebangEnd), tail]),
       existing,
+      spec,
       stat
     );
     return { path: target.hookPath, changed: true, removedFile: false };
   }
   const createdPrefixes = [
     Buffer.from(`#!/bin/sh
-# ${PRIM_CREATED_MARK}
+# ${spec.createdMark}
 
 `),
-    Buffer.from(`#!/bin/sh
+    ...spec.hookName === POST_COMMIT_MANAGED_HOOK.hookName ? [Buffer.from(`#!/bin/sh
 # ${LEGACY_PRIM_CREATED_MARK}
 
-`)
+`)] : []
   ];
   const createdPrefix = createdPrefixes.find(
     (prefix) => range.start === prefix.length && existing.subarray(0, prefix.length).equals(prefix)
@@ -1190,13 +1308,14 @@ ${LEGACY_PRIM_OWNED_HEADER}
   if (createdPrefix) {
     const tail = suffix.at(0) === 10 ? suffix.subarray(1) : suffix;
     if (tail.length === 0) {
-      unlinkHookUnchanged(target.hookPath, existing, stat);
+      unlinkHookUnchanged(target.hookPath, existing, stat, spec);
       return { path: target.hookPath, changed: true, removedFile: true };
     }
     rewriteHookAtomically(
       target.hookPath,
       Buffer.concat([Buffer.from("#!/bin/sh\n"), tail]),
       existing,
+      spec,
       stat
     );
     return { path: target.hookPath, changed: true, removedFile: false };
@@ -1205,17 +1324,32 @@ ${LEGACY_PRIM_OWNED_HEADER}
     existing.subarray(0, range.start),
     range.start === shebangEnd && suffix.at(0) === 10 ? suffix.subarray(1) : suffix
   ]);
-  rewriteHookAtomically(target.hookPath, next, existing, stat);
+  rewriteHookAtomically(target.hookPath, next, existing, spec, stat);
   return { path: target.hookPath, changed: true, removedFile: false };
 }
 function uninstallPostCommitHookAtPath(hookPath) {
   const absolute = resolve3(hookPath);
-  return uninstallTarget({
-    gitRoot: dirname3(dirname3(absolute)),
-    hooksDir: dirname3(absolute),
-    hookPath: absolute,
-    kind: "direct"
-  });
+  return uninstallTarget(
+    {
+      gitRoot: dirname3(dirname3(absolute)),
+      hooksDir: dirname3(absolute),
+      hookPath: absolute,
+      kind: "direct"
+    },
+    POST_COMMIT_MANAGED_HOOK
+  );
+}
+function uninstallPostRewriteHookAtPath(hookPath) {
+  const absolute = resolve3(hookPath);
+  return uninstallTarget(
+    {
+      gitRoot: dirname3(dirname3(absolute)),
+      hooksDir: dirname3(absolute),
+      hookPath: absolute,
+      kind: "direct"
+    },
+    POST_REWRITE_MANAGED_HOOK
+  );
 }
 
 // src/lib/repository-binding.ts
@@ -1254,11 +1388,17 @@ async function bindRepository(root, options) {
 
 export {
   postCommitHookBlock,
+  postRewriteHookBlock,
   ensureEffectivePostCommitHook,
+  ensureEffectivePostRewriteHook,
   ensurePostCommitHookAtPath,
+  ensurePostRewriteHookAtPath,
   inspectEffectivePostCommitHook,
+  inspectEffectivePostRewriteHook,
   uninstallProjectPostCommitHook,
+  uninstallProjectPostRewriteHook,
   uninstallPostCommitHookAtPath,
+  uninstallPostRewriteHookAtPath,
   resolveRepositoryBinding,
   bindRepository,
   printJson,

package/dist/{chunk-WS3MCNFD.js → chunk-XUAP572Z.js}

@@ -1,7 +1,7 @@
 import {
   getClient,
   getSiteUrl
-} from "./chunk-CPX3BUOC.js";
+} from "./chunk-RTLFE6EZ.js";
 import {
   daemonRequest
 } from "./chunk-UTKQTZHL.js";

package/dist/daemon/server.js

@@ -394,10 +394,12 @@ function refreshToken(options = {}) {
 }
 var HttpError = class extends Error {
   status;
-  constructor(status, message) {
+  body;
+  constructor(status, message, body) {
     super(message);
     this.name = "HttpError";
     this.status = status;
+    this.body = body;
   }
 };
 var _cachedCredential;
@@ -458,7 +460,9 @@ async function request(method, path, body, options) {
       throw new HttpError(401, AUTH_EXPIRED_MESSAGE);
     }
     const errorBody = await response.json().catch(() => null);
-    throw new HttpError(response.status, errorBody?.error ?? `HTTP ${response.status}`);
+    const errorRecord = typeof errorBody === "object" && errorBody !== null && !Array.isArray(errorBody) ? errorBody : void 0;
+    const message = typeof errorRecord?.error === "string" ? errorRecord.error : `HTTP ${response.status}`;
+    throw new HttpError(response.status, message, errorBody);
   }
   return response.json();
 }