@primitive.ai/prim 0.1.0-alpha.8 → 0.1.0-alpha.81

package/dist/chunk-HWSS4BV5.js

@@ -0,0 +1,1400 @@
+import {
+  binFile,
+  compareSemver,
+  pinnedNpxCommand
+} from "./chunk-PMRDE2DA.js";
+import {
+  gitToplevel,
+  githubRepositoryFullName,
+  isValidRepoSyncId,
+  setRepoSyncId,
+  setRepositoryBindingState
+} from "./chunk-TJTVHDJ5.js";
+import {
+  HttpError,
+  atomicWriteFile,
+  getClient,
+  withFileLock
+} from "./chunk-Z7YPFWAZ.js";
+
+// src/lib/bin-cache.ts
+import { chmodSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var GIT_HOOK_CACHE_SHELL_DIR = "${XDG_CACHE_HOME:-$HOME/.cache}/prim/bin";
+var GIT_HOOK_CACHE_TTL_MINUTES = 1440;
+var GIT_HOOK_CACHED_BINS = ["prim-post-commit", "prim-post-rewrite"];
+function binCacheDir() {
+  const base = process.env.XDG_CACHE_HOME || join(homedir(), ".cache");
+  return join(base, "prim", "bin");
+}
+function writeAtomic(path, content) {
+  atomicWriteFile(path, content, { mode: 384 });
+}
+function warmBinCache() {
+  try {
+    if (process.env.PRIM_BIN_CACHE === "0") {
+      return;
+    }
+    const dir = binCacheDir();
+    mkdirSync(dir, { recursive: true, mode: 448 });
+    chmodSync(dir, 448);
+    writeAtomic(join(dir, "node"), process.execPath);
+    for (const bin of GIT_HOOK_CACHED_BINS) {
+      const file = binFile(bin);
+      if (file) {
+        writeAtomic(join(dir, bin), file);
+      }
+    }
+  } catch {
+  }
+}
+
+// src/commands/skill.ts
+import {
+  constants as constants2,
+  closeSync as closeSync2,
+  existsSync as existsSync2,
+  fstatSync as fstatSync2,
+  lstatSync as lstatSync2,
+  openSync as openSync2,
+  readFileSync as readFileSync2,
+  readSync as readSync2
+} from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { createPatch } from "diff";
+import { parse as parseYaml2 } from "yaml";
+
+// src/output.ts
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+// src/commands/claude-plugin.ts
+import { createHash } from "crypto";
+import {
+  constants,
+  closeSync,
+  existsSync,
+  fstatSync,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  openSync,
+  readFileSync,
+  readSync,
+  readdirSync,
+  realpathSync,
+  rmSync,
+  rmdirSync
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, isAbsolute, join as join2, relative, resolve, sep } from "path";
+import { fileURLToPath } from "url";
+import { parse as parseYaml } from "yaml";
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var PLUGIN_DESCRIPTION = "Primitive decision-graph guidance for the prim CLI \u2014 a model-invoked skill installed by prim skill install.";
+var MAX_MANIFEST_BYTES = 64 * 1024;
+var MAX_SKILL_BYTES = 1024 * 1024;
+var REFRESH_LOCK_TIMEOUT_MS = 150;
+var REFRESH_LOCK_POLL_MS = 10;
+function pluginDirFor(cwd, scope) {
+  const base = scope === "user" ? join2(homedir2(), ".claude") : join2(gitToplevel(cwd) ?? cwd, ".claude");
+  return join2(base, "skills", "prim");
+}
+function resolvePluginDir(cwd, scope) {
+  if (scope && scope !== "user" && scope !== "project") {
+    console.error(`Unknown --scope "${scope}" (expected user or project)`);
+    return null;
+  }
+  return pluginDirFor(cwd, scope === "user" ? "user" : "project");
+}
+function packageVersion() {
+  let dir = __dirname;
+  while (dir !== dirname(dir)) {
+    const p = resolve(dir, "package.json");
+    if (existsSync(p)) return JSON.parse(readFileSync(p, "utf-8")).version;
+    dir = dirname(dir);
+  }
+  return "0.0.0";
+}
+function pluginManifest(version) {
+  const manifest = { name: "prim", description: PLUGIN_DESCRIPTION, version };
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+function renderClaudePlugin() {
+  const version = packageVersion();
+  return { manifest: pluginManifest(version), skill: loadSkill(), version };
+}
+function removeDirIfEmpty(dir) {
+  if (existsSync(dir) && readdirSync(dir).length === 0) rmdirSync(dir);
+}
+function pluginPaths(dir) {
+  return {
+    manifestPath: join2(dir, ".claude-plugin", "plugin.json"),
+    skillPath: join2(dir, "SKILL.md")
+  };
+}
+function pathIsInside(root, path) {
+  const rel = relative(root, path);
+  return rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+function managedPathsAreSafe(paths, projectRoot) {
+  try {
+    const managed = [paths.manifestPath, paths.skillPath];
+    if (managed.some((path) => !lstatSync(path).isFile())) return false;
+    if (projectRoot === void 0) return true;
+    const realRoot = realpathSync(projectRoot);
+    return managed.every((path) => pathIsInside(realRoot, realpathSync(path)));
+  } catch {
+    return false;
+  }
+}
+function readBoundedRegularFile(path, maxBytes) {
+  const fd = openSync(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  try {
+    const stat = fstatSync(fd);
+    if (!stat.isFile() || stat.size > maxBytes) throw new Error("unsafe managed file");
+    const chunks = [];
+    let total = 0;
+    while (total <= maxBytes) {
+      const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, maxBytes + 1 - total));
+      const bytesRead = readSync(fd, chunk, 0, chunk.length, null);
+      if (bytesRead === 0) break;
+      chunks.push(chunk.subarray(0, bytesRead));
+      total += bytesRead;
+    }
+    if (total > maxBytes) throw new Error("unsafe managed file");
+    return Buffer.concat(chunks, total).toString("utf8");
+  } finally {
+    closeSync(fd);
+  }
+}
+function hasUsablePrimFrontmatter(skill) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)([\s\S]*)$/u.exec(skill);
+  if (!match) return false;
+  try {
+    const parsed = parseYaml(match[1]);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return false;
+    const frontmatter = parsed;
+    return frontmatter.name === "prim" && typeof frontmatter.description === "string" && frontmatter.description.trim().length > 0 && match[2].trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function inspectRecognizedInstallation(paths, projectRoot) {
+  if (!existsSync(paths.manifestPath) || !existsSync(paths.skillPath)) return;
+  if (!managedPathsAreSafe(paths, projectRoot)) return;
+  const manifest = readBoundedRegularFile(paths.manifestPath, MAX_MANIFEST_BYTES);
+  const parsed = JSON.parse(manifest);
+  if (parsed.name !== "prim") return;
+  const skill = readBoundedRegularFile(paths.skillPath, MAX_SKILL_BYTES);
+  return {
+    manifest,
+    manifestVersion: parsed.version,
+    skill,
+    usable: hasUsablePrimFrontmatter(skill)
+  };
+}
+function refreshLockDir(physicalPluginDir) {
+  const cacheRoot = process.env.XDG_CACHE_HOME || join2(homedir2(), ".cache");
+  const identity = createHash("sha256").update(physicalPluginDir).digest("hex");
+  return join2(cacheRoot, "prim", "skill-refresh-locks", `${identity}.lock`);
+}
+async function refreshClaudePlugins(cwd, options = {}) {
+  const result = { installed: 0, refreshed: 0 };
+  const candidates = [];
+  if (options.includeProject !== false) {
+    const projectRoot = options.projectRoot ?? gitToplevel(cwd);
+    if (projectRoot !== null && isAbsolute(projectRoot)) {
+      candidates.push({ dir: join2(projectRoot, ".claude", "skills", "prim"), projectRoot });
+    }
+  }
+  candidates.push({ dir: pluginDirFor(cwd, "user") });
+  const seen = /* @__PURE__ */ new Set();
+  let desired;
+  for (const { dir, projectRoot } of candidates) {
+    let counted = false;
+    const markInstalled = () => {
+      if (!counted) {
+        result.installed += 1;
+        counted = true;
+      }
+    };
+    const refreshCandidate = () => {
+      const { manifestPath, skillPath } = pluginPaths(dir);
+      const paths = { manifestPath, skillPath };
+      try {
+        let changed = false;
+        const current = inspectRecognizedInstallation(paths, projectRoot);
+        if (!current) return;
+        desired ??= renderClaudePlugin();
+        if (projectRoot !== void 0 && current.usable && compareSemver(current.manifestVersion, desired.version) === 1) {
+          markInstalled();
+          return;
+        }
+        if (current.manifest !== desired.manifest) {
+          if (!managedPathsAreSafe(paths, projectRoot)) throw new Error("unsafe managed path");
+          atomicWrite(manifestPath, desired.manifest);
+          if (!changed) result.refreshed += 1;
+          changed = true;
+        }
+        if (current.skill !== desired.skill) {
+          if (!managedPathsAreSafe(paths, projectRoot)) throw new Error("unsafe managed path");
+          atomicWrite(skillPath, desired.skill);
+          if (!changed) result.refreshed += 1;
+          changed = true;
+        }
+        markInstalled();
+      } catch {
+        try {
+          if (inspectRecognizedInstallation(paths, projectRoot)?.usable) markInstalled();
+        } catch {
+        }
+      }
+    };
+    try {
+      const paths = pluginPaths(dir);
+      if (!existsSync(paths.manifestPath) || !existsSync(paths.skillPath)) continue;
+      const physicalPluginDir = realpathSync(dir);
+      if (seen.has(physicalPluginDir)) continue;
+      seen.add(physicalPluginDir);
+      await withFileLock(refreshLockDir(physicalPluginDir), refreshCandidate, {
+        timeoutMs: REFRESH_LOCK_TIMEOUT_MS,
+        pollMs: REFRESH_LOCK_POLL_MS
+      });
+    } catch {
+    }
+  }
+  return result;
+}
+function installClaudePlugin(cwd, opts) {
+  const dir = resolvePluginDir(cwd, opts.scope);
+  if (dir === null) return 1;
+  const { manifestPath, skillPath } = pluginPaths(dir);
+  const { manifest, skill } = renderClaudePlugin();
+  const manifestCurrent = existsSync(manifestPath) ? readFileSync(manifestPath, "utf-8") : null;
+  const skillCurrent = existsSync(skillPath) ? readFileSync(skillPath, "utf-8") : null;
+  if (manifestCurrent === manifest && skillCurrent === skill) {
+    console.log("No changes \u2014 prim skill plugin already up to date.");
+    return 0;
+  }
+  if (opts.dryRun) {
+    console.log(`Would write plugin to ${dir} (.claude-plugin/plugin.json + SKILL.md)`);
+    return 0;
+  }
+  mkdirSync2(join2(dir, ".claude-plugin"), { recursive: true });
+  atomicWrite(manifestPath, manifest);
+  atomicWrite(skillPath, skill);
+  console.log(`Installed prim skill plugin at ${dir}`);
+  console.log("Restart Claude Code or run /reload-plugins to load it.");
+  if (opts.scope !== "user") {
+    console.log("Project-scope plugins load only when Claude Code launches from this directory.");
+  }
+  return 0;
+}
+function uninstallClaudePlugin(cwd, opts) {
+  const dir = resolvePluginDir(cwd, opts.scope);
+  if (dir === null) return 1;
+  const { manifestPath, skillPath } = pluginPaths(dir);
+  if (!existsSync(manifestPath) && !existsSync(skillPath)) {
+    console.log(`prim skill plugin not present at ${dir}`);
+    return 0;
+  }
+  rmSync(manifestPath, { force: true });
+  rmSync(skillPath, { force: true });
+  removeDirIfEmpty(join2(dir, ".claude-plugin"));
+  removeDirIfEmpty(dir);
+  console.log(`Removed prim skill plugin from ${dir}`);
+  return 0;
+}
+function statusClaudePlugin(cwd, opts) {
+  const dir = resolvePluginDir(cwd, opts.scope);
+  if (dir === null) return 1;
+  const { skillPath } = pluginPaths(dir);
+  const installed = existsSync(skillPath);
+  if (opts.json) {
+    printJson({ installed, target: dir });
+    return installed ? 0 : 1;
+  }
+  if (installed) {
+    console.log(`prim skill plugin installed at ${dir}`);
+    return 0;
+  }
+  console.log(`No prim skill plugin at ${dir}`);
+  return 1;
+}
+
+// src/commands/skill.ts
+var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
+var SKILL_BEGIN = "<!-- BEGIN PRIM SKILL v1 -->";
+var SKILL_END = "<!-- END PRIM SKILL v1 -->";
+var CODEX_GUIDANCE_LIMIT_BYTES = 1024 * 1024;
+var CODEX_DEFAULT_PROJECT_GUIDANCE_BYTES = 32 * 1024;
+var SKILL_BEGIN_BUFFER = Buffer.from(SKILL_BEGIN);
+var SKILL_END_BUFFER = Buffer.from(SKILL_END);
+function readCodexGuidance(path) {
+  try {
+    const entry = lstatSync2(path);
+    if (entry.isSymbolicLink() || !entry.isFile()) return null;
+    const fd = openSync2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW);
+    try {
+      const opened = fstatSync2(fd);
+      if (!opened.isFile() || opened.size > CODEX_GUIDANCE_LIMIT_BYTES) return null;
+      const bytes = Buffer.allocUnsafe(CODEX_GUIDANCE_LIMIT_BYTES + 1);
+      let length = 0;
+      while (length < bytes.length) {
+        const read = readSync2(fd, bytes, length, bytes.length - length, length);
+        if (read === 0) break;
+        length += read;
+      }
+      return length > CODEX_GUIDANCE_LIMIT_BYTES ? null : bytes.subarray(0, length);
+    } finally {
+      closeSync2(fd);
+    }
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? void 0 : null;
+  }
+}
+function effectiveCodexGuidance(scope) {
+  const override = readCodexGuidance(join3(scope, "AGENTS.override.md"));
+  if (override === null) return null;
+  if (override !== void 0 && override.toString("utf8").trim().length > 0) return override;
+  const base = readCodexGuidance(join3(scope, "AGENTS.md"));
+  return base ?? null;
+}
+function hasUsablePrimBlock(content, visibleBytes) {
+  const begin = content.indexOf(SKILL_BEGIN_BUFFER);
+  const end = content.indexOf(SKILL_END_BUFFER);
+  if (begin === -1 || end <= begin + SKILL_BEGIN_BUFFER.length || end + SKILL_END_BUFFER.length > visibleBytes || content.indexOf(SKILL_BEGIN_BUFFER, begin + SKILL_BEGIN_BUFFER.length) !== -1 || content.indexOf(SKILL_END_BUFFER, end + SKILL_END_BUFFER.length) !== -1) {
+    return false;
+  }
+  const block = content.subarray(begin + SKILL_BEGIN_BUFFER.length, end).toString("utf8").trim();
+  const match = /^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)([\s\S]*)$/u.exec(block);
+  if (!match || match[2].trim().length === 0) return false;
+  try {
+    const metadata = parseYaml2(match[1]);
+    if (typeof metadata !== "object" || metadata === null || Array.isArray(metadata)) return false;
+    const fields = metadata;
+    return fields.name === "prim" && typeof fields.description === "string" && fields.description.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function hasUsableCodexGuidance(projectRoot) {
+  try {
+    const codexHome = process.env.CODEX_HOME?.trim() ? resolve2(process.env.CODEX_HOME) : join3(homedir3(), ".codex");
+    const scopes = [
+      { path: codexHome, visibleBytes: CODEX_GUIDANCE_LIMIT_BYTES },
+      { path: projectRoot, visibleBytes: CODEX_DEFAULT_PROJECT_GUIDANCE_BYTES }
+    ];
+    return scopes.some(({ path, visibleBytes }) => {
+      const guidance = effectiveCodexGuidance(path);
+      return guidance !== null && hasUsablePrimBlock(guidance, visibleBytes);
+    });
+  } catch {
+    return false;
+  }
+}
+var TARGET_CANDIDATES = [
+  "CLAUDE.md",
+  "AGENTS.md",
+  ".hermes.md",
+  ".cursor/rules",
+  ".windsurfrules",
+  ".github/instructions/primitive.md"
+];
+var DEFAULT_TARGET = "CLAUDE.md";
+var AGENT_TARGET = {
+  claude: "CLAUDE.md",
+  codex: "AGENTS.md",
+  hermes: ".hermes.md"
+};
+function userTargetFor(agent) {
+  if (agent === "claude") return join3(homedir3(), ".claude", "CLAUDE.md");
+  if (agent === "codex") return join3(homedir3(), ".codex", "AGENTS.md");
+  if (agent === "hermes") {
+    return join3(process.env.HERMES_HOME ?? join3(homedir3(), ".hermes"), ".hermes.md");
+  }
+  return null;
+}
+function loadSkill() {
+  let dir = __dirname2;
+  while (dir !== dirname2(dir)) {
+    const p = resolve2(dir, "SKILL.md");
+    if (existsSync2(p)) return readFileSync2(p, "utf-8");
+    dir = dirname2(dir);
+  }
+  throw new Error("SKILL.md not found in package");
+}
+function detectTargets(cwd) {
+  return TARGET_CANDIDATES.filter((p) => existsSync2(resolve2(cwd, p)));
+}
+function detectNewline(content) {
+  return content.includes("\r\n") ? "\r\n" : "\n";
+}
+function composeBlock(skill, eol) {
+  const body = skill.replace(/\r?\n/g, eol);
+  return `${SKILL_BEGIN}${eol}${body}${eol}${SKILL_END}`;
+}
+function applyBlock(existing, block, eol) {
+  const b = existing.indexOf(SKILL_BEGIN);
+  const e = existing.indexOf(SKILL_END);
+  if (b !== -1 && e !== -1) {
+    return existing.slice(0, b) + block + existing.slice(e + SKILL_END.length);
+  }
+  if (existing.length === 0) return `${block}${eol}`;
+  const sep2 = existing.endsWith(eol) ? "" : eol;
+  return `${existing}${sep2}${block}${eol}`;
+}
+function removeBlock(existing) {
+  const b = existing.indexOf(SKILL_BEGIN);
+  const e = existing.indexOf(SKILL_END);
+  if (b === -1 || e === -1) return null;
+  const out = existing.slice(0, b) + existing.slice(e + SKILL_END.length);
+  return out.replace(/(\r?\n){2,}$/, "$1");
+}
+function atomicWrite(target, content) {
+  atomicWriteFile(target, content);
+}
+function resolveTarget(cwd, opts) {
+  if (opts.scope && opts.scope !== "user" && opts.scope !== "project") {
+    console.error(`Unknown --scope "${opts.scope}" (expected user or project)`);
+    return null;
+  }
+  if (opts.target) return resolve2(cwd, opts.target);
+  if (opts.scope === "user") {
+    if (!opts.agent) {
+      console.error("--scope user requires --agent (claude, codex, or hermes)");
+      return null;
+    }
+    const userTarget = userTargetFor(opts.agent);
+    if (userTarget) return userTarget;
+    console.error(`Unknown --agent "${opts.agent}" (expected claude, codex, or hermes)`);
+    return null;
+  }
+  if (opts.agent) {
+    const mapped = AGENT_TARGET[opts.agent];
+    if (typeof mapped === "string") return resolve2(cwd, mapped);
+    console.error(`Unknown --agent "${opts.agent}" (expected claude, codex, or hermes)`);
+    return null;
+  }
+  const matches = detectTargets(cwd);
+  if (matches.length === 0) return resolve2(cwd, DEFAULT_TARGET);
+  if (matches.length === 1) return resolve2(cwd, matches[0]);
+  console.error("Multiple rules files detected. Use --target to disambiguate:");
+  for (const m of matches) console.error(`  ${m}`);
+  return null;
+}
+function runInstall(cwd, opts) {
+  if (opts.agent === "claude" && !opts.target) return installClaudePlugin(cwd, opts);
+  const target = resolveTarget(cwd, opts);
+  if (target === null) return 1;
+  const existing = existsSync2(target) ? readFileSync2(target, "utf-8") : "";
+  const eol = existing ? detectNewline(existing) : "\n";
+  const block = composeBlock(loadSkill(), eol);
+  const next = applyBlock(existing, block, eol);
+  if (next === existing) {
+    console.log("No changes \u2014 skill block already up to date.");
+    return 0;
+  }
+  if (opts.dryRun) {
+    process.stdout.write(createPatch(target, existing, next, "current", "proposed"));
+    return 0;
+  }
+  atomicWrite(target, next);
+  console.log(`Wrote ${Buffer.byteLength(next)} bytes to ${target}`);
+  return 0;
+}
+function runUninstall(cwd, opts) {
+  if (opts.agent === "claude" && !opts.target) return uninstallClaudePlugin(cwd, opts);
+  const target = resolveTarget(cwd, opts);
+  if (target === null) return 1;
+  if (!existsSync2(target)) {
+    console.log(`Skill block not present at ${target}`);
+    return 0;
+  }
+  const existing = readFileSync2(target, "utf-8");
+  const next = removeBlock(existing);
+  if (next === null) {
+    console.log(`Skill block not present at ${target}`);
+    return 0;
+  }
+  atomicWrite(target, next);
+  console.log(`Removed skill block from ${target}`);
+  return 0;
+}
+function runStatus(cwd, opts) {
+  if (opts.agent === "claude" && !opts.target) return statusClaudePlugin(cwd, opts);
+  const target = resolveTarget(cwd, opts);
+  if (target === null) return 1;
+  const fileExists = existsSync2(target);
+  let installed = false;
+  if (fileExists) {
+    const content = readFileSync2(target, "utf-8");
+    installed = content.includes(SKILL_BEGIN) && content.includes(SKILL_END);
+  }
+  if (opts.json) {
+    printJson({ installed, target });
+    return installed ? 0 : 1;
+  }
+  if (!fileExists) {
+    console.log(`No rules file at ${target}`);
+    return 1;
+  }
+  if (installed) {
+    console.log(`PRIM SKILL v1 installed at ${target}`);
+    return 0;
+  }
+  console.log(`No PRIM SKILL block at ${target}`);
+  return 1;
+}
+function registerSkillCommands(program) {
+  const skill = program.command("skill").description("Manage the prim skill in your project rules file");
+  skill.command("install").description("Install the prim skill block into your project rules file").option("--target <path>", "Path to the rules file (overrides auto-detection)").option("--agent <agent>", "claude, codex, or hermes (selects the default rules file)").option("--scope <scope>", "project (default, this repo) or user (machine-global \u2014 every repo)").option("--dry-run", "Print a unified diff without writing").action((opts) => {
+    try {
+      process.exit(runInstall(process.cwd(), opts));
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exit(2);
+    }
+  });
+  skill.command("uninstall").description("Remove the prim skill block from your project rules file").option("--target <path>", "Path to the rules file (overrides auto-detection)").option("--agent <agent>", "claude, codex, or hermes (selects the default rules file)").option("--scope <scope>", "project (default, this repo) or user (machine-global \u2014 every repo)").action((opts) => {
+    process.exit(runUninstall(process.cwd(), opts));
+  });
+  skill.command("status").description("Report whether the prim skill block is installed").option("--target <path>", "Path to the rules file (overrides auto-detection)").option("--agent <agent>", "claude, codex, or hermes (selects the default rules file)").option("--scope <scope>", "project (default, this repo) or user (machine-global \u2014 every repo)").option("--json", "Output as JSON").action((opts) => {
+    process.exit(runStatus(process.cwd(), opts));
+  });
+}
+
+// src/lib/post-commit-hook.ts
+import { execFileSync } from "child_process";
+import { createHash as createHash2, randomUUID } from "crypto";
+import {
+  constants as constants3,
+  closeSync as closeSync3,
+  existsSync as existsSync3,
+  fchmodSync,
+  fsyncSync,
+  lstatSync as lstatSync3,
+  mkdirSync as mkdirSync3,
+  openSync as openSync3,
+  readFileSync as readFileSync3,
+  renameSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2, resolve as resolve3 } from "path";
+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.";
+var MAX_HOOK_BYTES = 1048576;
+var GIT_TIMEOUT_MS = 1e3;
+var SUPPORTED_SHEBANGS = /* @__PURE__ */ new Set([
+  "#!/bin/sh",
+  "#!/usr/bin/env sh",
+  "#!/bin/bash",
+  "#!/usr/bin/env bash",
+  "#!/bin/zsh",
+  "#!/usr/bin/env zsh"
+]);
+var HUSKY_V9_DISPATCHERS = /* @__PURE__ */ new Set([
+  '#!/usr/bin/env sh\n. "${0%/*}/h"',
+  '#!/usr/bin/env sh\n. "$(dirname "$0")/h"'
+]);
+var HUSKY_DIRECT_DISPATCHER = '#!/bin/sh\nexec sh "$(dirname "$0")/../post-commit"\n';
+var HUSKY_V9_RUNTIME_HASHES = /* @__PURE__ */ new Set([
+  "d6aaa6f3f7c11008c525e649161df4a93152f1e55d0887fa1d7b8d622735d380",
+  "b02cb91cab7125a9e906be723a1b85297fc435a8307d429ae845546b4ee0ecde",
+  "9db5d129c4eb822a773157d98cd8fb8f1b156b85e3193117fefe527ca6d45e91",
+  "3b2cb21335e544b4ebce658ca47af4a69d2c77026cc4d3f8b2227c34d062b207",
+  "548990e1c11285694096184993d907b258d41235461a7ca2551e3b53ff9d3a38",
+  "c029a943acea5d6e2ddbaa271a1fb22c2da55d56b5c6fb59ca804ac9a4018708",
+  "ae3413a8fe2b39372de48bdc9691f42055f089c0c7529834b2fb07a131585b6a",
+  "70200b200ca709b0622784f93839a5b2872333a917a09afddefd7dc2d8cdc680"
+]);
+function currentPostCommitBlock() {
+  return `${PRIM_POST_COMMIT_BLOCK_START}
+if [ "$(git config --get prim.active 2>/dev/null)" = "true" ]; then
+  prim_commit_sha=$(git rev-parse --verify HEAD 2>/dev/null) || prim_commit_sha=
+  case "$prim_commit_sha" in *[!0-9a-f]*|"") prim_commit_sha= ;; esac
+  case "\${#prim_commit_sha}" in 40|64) ;; *) prim_commit_sha= ;; esac
+  if [ -n "$prim_commit_sha" ]; then
+    prim_commit_observed_file=$(mktemp "\${TMPDIR:-/tmp}/prim-post-commit-observed.XXXXXXXX" 2>/dev/null) || prim_commit_observed_file=
+    prim_commit_branch=$(git symbolic-ref --quiet --short HEAD 2>/dev/null) || prim_commit_branch=
+    prim_cache_dir="${GIT_HOOK_CACHE_SHELL_DIR}"
+    prim_post_commit_ran=0
+    if [ "\${PRIM_BIN_CACHE:-1}" != "0" ] && [ -f "$prim_cache_dir/prim-post-commit" ] && [ -f "$prim_cache_dir/node" ] && [ -n "$(find "$prim_cache_dir/prim-post-commit" -mmin "-\${PRIM_BIN_CACHE_TTL_MIN:-${GIT_HOOK_CACHE_TTL_MINUTES}}" 2>/dev/null)" ]; then
+      prim_node=$(cat "$prim_cache_dir/node")
+      prim_entry=$(cat "$prim_cache_dir/prim-post-commit")
+      if [ -x "$prim_node" ] && [ -f "$prim_entry" ]; then
+        ( trap '' HUP; trap 'if [ -n "$prim_commit_observed_file" ]; then rm -f "$prim_commit_observed_file"; fi' 0; export PRIM_COMMIT_SHA="$prim_commit_sha" PRIM_COMMIT_BRANCH="$prim_commit_branch" PRIM_COMMIT_OBSERVED_FILE="$prim_commit_observed_file"; "$prim_node" "$prim_entry" ) </dev/null >/dev/null 2>&1 &
+        prim_post_commit_ran=1
+      fi
+    fi
+    if [ "$prim_post_commit_ran" -eq 0 ] && command -v npx >/dev/null 2>&1; then
+      ( trap '' HUP; trap 'if [ -n "$prim_commit_observed_file" ]; then rm -f "$prim_commit_observed_file"; fi' 0; export PRIM_COMMIT_SHA="$prim_commit_sha" PRIM_COMMIT_BRANCH="$prim_commit_branch" PRIM_COMMIT_OBSERVED_FILE="$prim_commit_observed_file"; ${pinnedNpxCommand("prim-post-commit")} ) </dev/null >/dev/null 2>&1 &
+      prim_post_commit_ran=1
+    fi
+    if [ "$prim_post_commit_ran" -eq 0 ] && [ -n "$prim_commit_observed_file" ]; then
+      rm -f "$prim_commit_observed_file"
+    fi
+    unset prim_cache_dir prim_post_commit_ran prim_node prim_entry prim_commit_branch prim_commit_observed_file
+  fi
+  unset prim_commit_sha
+fi
+${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="${GIT_HOOK_CACHE_SHELL_DIR}"
+        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:-${GIT_HOOK_CACHE_TTL_MINUTES}}" 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 ] && 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"; ${pinnedNpxCommand("prim-post-rewrite")} ) </dev/null >/dev/null 2>&1 &
+          prim_post_rewrite_ran=1
+        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
+elif [ -f "./node_modules/.bin/prim-post-commit" ]; then
+  ./node_modules/.bin/prim-post-commit || true
+else
+  npx --yes -p @primitive.ai/prim prim-post-commit 2>/dev/null || true
+fi`;
+}
+function legacyGlobalGate() {
+  return Buffer.from(`if [ "$(git config --get prim.active 2>/dev/null)" = "true" ]; then
+${legacyFloatingInvocation()}
+fi
+`);
+}
+var PINNED_INVOCATION_RE = /^\{ if \[ -x (?<node>'.*') \] && \[ -f (?<entry>'.*') \]; then \k<node> \k<entry>; else npx --yes -p @primitive\.ai\/prim@(?<version>[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?) prim-post-commit; fi; \} \|\| true$/u;
+var SHELL_QUOTED_RE = /^'(?:[^']|'"'"')*'$/u;
+function decodePinnedPath(token) {
+  if (!token || !SHELL_QUOTED_RE.test(token)) return void 0;
+  const value = token.slice(1, -1).replaceAll(`'"'"'`, "'");
+  if (!isAbsolute2(value) || value.includes("\0") || value.includes("\n") || value.includes("\r")) {
+    return void 0;
+  }
+  return value;
+}
+function isPinnedInvocation(value) {
+  const match = PINNED_INVOCATION_RE.exec(value);
+  const node = decodePinnedPath(match?.groups?.node);
+  const entry = decodePinnedPath(match?.groups?.entry);
+  return Boolean(node && entry?.endsWith("/dist/hooks/post-commit.js"));
+}
+function legacyProjectPrefixLength(existing) {
+  const prefix = Buffer.from(`#!/bin/sh
+${LEGACY_PRIM_OWNED_HEADER}
+
+`);
+  if (!existing.subarray(0, prefix.length).equals(prefix)) return void 0;
+  const floating = Buffer.from(`${legacyFloatingInvocation()}
+`);
+  if (existing.subarray(prefix.length, prefix.length + floating.length).equals(floating)) {
+    return prefix.length + floating.length;
+  }
+  const invocationEnd = existing.indexOf(10, prefix.length);
+  if (invocationEnd === -1) return void 0;
+  const invocation = existing.subarray(prefix.length, invocationEnd).toString("utf8");
+  return isPinnedInvocation(invocation) ? invocationEnd + 1 : void 0;
+}
+function isKnownLegacyGlobalGate(value) {
+  if (value.equals(legacyGlobalGate())) return true;
+  const prefix = Buffer.from(
+    'if [ "$(git config --get prim.active 2>/dev/null)" = "true" ]; then\n'
+  );
+  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(spec) {
+  return Buffer.from(`#!/bin/sh
+${spec.block()}
+# ${spec.createdMark}
+`);
+}
+function safeGitPath(root, value) {
+  if (value.length === 0 || value !== value.trim() || value.includes("\0") || value.includes("\n") || value.includes("\r")) {
+    throw new Error("Git returned an unsafe hooks path");
+  }
+  return isAbsolute2(value) ? resolve3(value) : resolve3(root, value);
+}
+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"], {
+    cwd: gitRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+    timeout: GIT_TIMEOUT_MS
+  }).replace(/\r?\n$/u, "");
+  const hooksDir = safeGitPath(gitRoot, value);
+  if (basename(hooksDir) === "_" && basename(dirname3(hooksDir)) === ".husky") {
+    return {
+      gitRoot,
+      hooksDir,
+      hookPath: resolve3(dirname3(hooksDir), spec.hookName),
+      kind: "husky_v9",
+      dispatcherPath: resolve3(hooksDir, spec.hookName)
+    };
+  }
+  return {
+    gitRoot,
+    hooksDir,
+    hookPath: resolve3(hooksDir, spec.hookName),
+    kind: "direct"
+  };
+}
+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 ${spec.hookName} hook target: ${path}`);
+  }
+  return stat;
+}
+function assertUsableHuskyDispatcher(target, spec) {
+  if (!target.dispatcherPath) return;
+  const stat = assertSafeFile(target.dispatcherPath, spec);
+  if (!stat || (stat.mode & 64) === 0) {
+    throw new Error(
+      `Husky ${spec.hookName} dispatcher is missing or not executable: ${target.dispatcherPath}`
+    );
+  }
+  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 ${spec.hookName} dispatcher: ${target.dispatcherPath}`);
+  }
+  const huskyRuntime = resolve3(dirname3(target.dispatcherPath), "h");
+  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)) {
+    throw new Error(`unrecognized Husky v9 hook runtime: ${huskyRuntime}`);
+  }
+}
+function readHookFile(path) {
+  const value = readFileSync3(path);
+  return Buffer.isBuffer(value) ? value : Buffer.from(value);
+}
+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 ${spec.hookName} hook`);
+  }
+}
+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 ${spec.hookName} hook interpreter`);
+  }
+  return Buffer.byteLength(text.slice(0, newline + 1), "utf8");
+}
+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 ${spec.hookName} hook interpreter`);
+}
+function allIndexes(haystack, needle) {
+  const indexes = [];
+  let offset = 0;
+  while (offset <= haystack.length - needle.length) {
+    const index = haystack.indexOf(needle, offset);
+    if (index === -1) break;
+    indexes.push(index);
+    offset = index + needle.length;
+  }
+  return indexes;
+}
+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 ${spec.hookName} markers`);
+  }
+  const start = starts[0];
+  const end = ends[0] + endMarker.length;
+  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, spec) {
+  const block = Buffer.from(spec.block());
+  if (!existing) {
+    return createdScaffold(spec);
+  }
+  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'));
+    const chainAt = existing.indexOf(Buffer.from("common_dir=$(git rev-parse --git-common-dir"));
+    if (gateAt === -1 || chainAt <= gateAt) {
+      throw new Error("malformed legacy Prim global post-commit hook");
+    }
+    if (!isKnownLegacyGlobalGate(existing.subarray(gateAt, chainAt))) {
+      throw new Error("unrecognized legacy Prim global post-commit invocation");
+    }
+    const withoutLegacyGate = Buffer.concat([
+      existing.subarray(0, gateAt),
+      existing.subarray(chainAt)
+    ]);
+    const shebangEnd2 = shellInsertionPoint(withoutLegacyGate, allowShebangless, spec);
+    return Buffer.concat([
+      withoutLegacyGate.subarray(0, shebangEnd2),
+      block,
+      Buffer.from("\n"),
+      withoutLegacyGate.subarray(shebangEnd2)
+    ]);
+  }
+  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(spec), existing.subarray(prefixLength)]);
+  }
+  if (range.kind !== "absent") {
+    const oldCreatedPrefixes = [
+      Buffer.from(`#!/bin/sh
+# ${spec.createdMark}
+
+`),
+      ...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)
+    );
+    if (oldCreated) {
+      const suffix = existing.subarray(range.end);
+      const tail = suffix.at(0) === 10 ? suffix.subarray(1) : suffix;
+      return Buffer.concat([createdScaffold(spec), tail]);
+    }
+  }
+  const shebangEnd = shellInsertionPoint(existing, allowShebangless, spec);
+  if (range.kind === "current" && range.start === shebangEnd) return existing;
+  let withoutBlock = existing;
+  if (range.kind !== "absent") {
+    const suffix = existing.subarray(range.end);
+    withoutBlock = Buffer.concat([
+      existing.subarray(0, range.start),
+      range.start === shebangEnd && suffix.at(0) === 10 ? suffix.subarray(1) : suffix
+    ]);
+  }
+  return Buffer.concat([
+    withoutBlock.subarray(0, shebangEnd),
+    block,
+    Buffer.from("\n"),
+    withoutBlock.subarray(shebangEnd)
+  ]);
+}
+function errorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+}
+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(`${spec.hookName} hook changed concurrently: ${path}`);
+  }
+  if (expected === void 0) {
+    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(`${spec.hookName} hook changed concurrently: ${path}`);
+  }
+}
+function rewriteHookAtomically(path, next, expected, spec, stat) {
+  const parent = dirname3(path);
+  mkdirSync3(parent, { recursive: true });
+  const temporary = resolve3(
+    parent,
+    `.${basename(path)}.prim-${String(process.pid)}-${randomUUID()}.tmp`
+  );
+  let fd;
+  try {
+    fd = openSync3(
+      temporary,
+      constants3.O_CREAT | constants3.O_EXCL | constants3.O_WRONLY | constants3.O_NOFOLLOW,
+      stat?.mode ?? 493
+    );
+    writeFileSync(fd, next);
+    fchmodSync(fd, (stat?.mode ?? 493) & 4095);
+    fsyncSync(fd);
+    closeSync3(fd);
+    fd = void 0;
+    assertTargetUnchanged(path, expected, spec, stat);
+    renameSync(temporary, path);
+  } finally {
+    if (fd !== void 0) {
+      try {
+        closeSync3(fd);
+      } catch {
+      }
+    }
+    try {
+      unlinkSync(temporary);
+    } catch (error) {
+      if (errorCode(error) !== "ENOENT") {
+      }
+    }
+  }
+}
+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, POST_COMMIT_MANAGED_HOOK);
+}
+function ensureEffectivePostRewriteHook(cwd = process.cwd()) {
+  const target = resolveEffectivePostRewriteHook(cwd);
+  return ensureTarget(target, POST_REWRITE_MANAGED_HOOK);
+}
+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 ${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", spec);
+  if (!existing && initialContent !== void 0) {
+    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 ${spec.hookName} scaffold`);
+    }
+  }
+  const contentChanged = !existing || !next.equals(existing);
+  if (contentChanged) {
+    rewriteHookAtomically(target.hookPath, next, existing, spec, stat);
+  }
+  return { path: target.hookPath, changed: contentChanged || !stat, kind: target.kind };
+}
+function ensurePostCommitHookAtPath(hookPath, initialContent) {
+  const absolute = resolve3(hookPath);
+  const result = ensureTarget(
+    {
+      gitRoot: dirname3(dirname3(absolute)),
+      hooksDir: dirname3(absolute),
+      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()) {
+  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, spec);
+  } catch (error) {
+    const missing = error instanceof Error && (error.message.includes("missing or not executable") || error.message.includes("unsafe"));
+    return {
+      ...target,
+      covered: false,
+      executable: false,
+      current: false,
+      reason: missing ? "husky_dispatcher_missing" : "husky_dispatcher_invalid"
+    };
+  }
+  let stat;
+  try {
+    stat = assertSafeFile(target.hookPath, spec);
+  } catch {
+    return {
+      ...target,
+      covered: false,
+      executable: false,
+      current: false,
+      reason: "unsafe_target"
+    };
+  }
+  if (!stat) {
+    return {
+      ...target,
+      covered: false,
+      executable: false,
+      current: false,
+      reason: "missing"
+    };
+  }
+  const executable = target.kind === "husky_v9" || (stat.mode & 64) !== 0;
+  try {
+    const content = readHookFile(target.hookPath);
+    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 {
+      ...target,
+      covered: current && executable,
+      executable,
+      current,
+      reason: range.kind === "current" && !positioned ? "unreachable_block" : !current ? "stale_block" : executable ? void 0 : "not_executable"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "";
+    const reason = message.includes("binary") ? "binary" : message.includes("unsupported") ? "unsupported_interpreter" : "malformed_markers";
+    return {
+      ...target,
+      covered: false,
+      executable,
+      current: false,
+      reason
+    };
+  }
+}
+function uninstallEffectivePostCommitHook(cwd = process.cwd()) {
+  const target = resolveEffectivePostCommitHook(cwd);
+  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"]) {
+    try {
+      const value = execFileSync("git", ["config", scope, "--get", "core.hooksPath"], {
+        cwd: gitRoot,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: GIT_TIMEOUT_MS
+      }).trim();
+      if (value.length > 0) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function uninstallProjectPostCommitHook(cwd = process.cwd()) {
+  const gitRoot = gitToplevel(cwd);
+  if (!gitRoot) throw new Error("not a git repository");
+  if (projectHooksPathIsConfigured(gitRoot)) {
+    return uninstallEffectivePostCommitHook(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 uninstallPostCommitHookAtPath(
+    resolve3(safeGitPath(gitRoot, commonDir), "hooks", "post-commit")
+  );
+}
+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, spec);
+  if (range.kind === "absent") {
+    if (spec.hookName === POST_COMMIT_MANAGED_HOOK.hookName && 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");
+      }
+      const tail = existing.subarray(prefixLength);
+      if (tail.length === 0) {
+        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", spec);
+  const suffix = existing.subarray(range.end);
+  const createdSuffix = Buffer.from(`
+# ${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, 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
+# ${spec.createdMark}
+
+`),
+    ...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)
+  );
+  if (createdPrefix) {
+    const tail = suffix.at(0) === 10 ? suffix.subarray(1) : suffix;
+    if (tail.length === 0) {
+      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 };
+  }
+  const next = Buffer.concat([
+    existing.subarray(0, range.start),
+    range.start === shebangEnd && suffix.at(0) === 10 ? suffix.subarray(1) : suffix
+  ]);
+  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"
+    },
+    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
+var InvalidRepositoryBindingResponseError = class extends Error {
+};
+async function resolveRepositoryBindingWithClient(root, client, options) {
+  const repositoryFullName = githubRepositoryFullName(root);
+  if (!repositoryFullName) {
+    throw new Error("origin must be a GitHub HTTPS/SSH remote in owner/name form");
+  }
+  let response;
+  try {
+    response = await client.post(
+      "/api/cli/repositories/bind",
+      { repositoryFullName },
+      options
+    );
+  } catch (error) {
+    if (error instanceof HttpError && error.status === 404) {
+      return { status: "unbound", repositoryFullName };
+    }
+    throw error;
+  }
+  if (!isValidRepoSyncId(response.repoSyncId)) {
+    throw new InvalidRepositoryBindingResponseError(
+      "server returned an invalid repository binding"
+    );
+  }
+  return { status: "connected", repoSyncId: response.repoSyncId, repositoryFullName };
+}
+async function resolveRepositoryBinding(root, options) {
+  return resolveRepositoryBindingWithClient(root, getClient(), options);
+}
+function persistRepositoryBinding(root, binding) {
+  if (binding.status === "connected") {
+    setRepoSyncId(root, binding.repoSyncId, binding.repositoryFullName);
+    setRepositoryBindingState(root, "connected");
+    return;
+  }
+  setRepositoryBindingState(root, "unbound");
+}
+async function bindRepositoryWithClient(root, client, options) {
+  let binding;
+  try {
+    binding = await resolveRepositoryBindingWithClient(root, client, options);
+  } catch (error) {
+    if (error instanceof InvalidRepositoryBindingResponseError) {
+      try {
+        setRepositoryBindingState(root, "invalid");
+      } catch {
+      }
+    }
+    throw error;
+  }
+  persistRepositoryBinding(root, binding);
+  return binding;
+}
+async function bindRepository(root, options) {
+  return bindRepositoryWithClient(root, getClient(), options);
+}
+
+export {
+  warmBinCache,
+  postCommitHookBlock,
+  postRewriteHookBlock,
+  ensureEffectivePostCommitHook,
+  ensureEffectivePostRewriteHook,
+  ensurePostCommitHookAtPath,
+  ensurePostRewriteHookAtPath,
+  inspectEffectivePostCommitHook,
+  inspectEffectivePostRewriteHook,
+  uninstallProjectPostCommitHook,
+  uninstallProjectPostRewriteHook,
+  uninstallPostCommitHookAtPath,
+  uninstallPostRewriteHookAtPath,
+  resolveRepositoryBinding,
+  bindRepositoryWithClient,
+  bindRepository,
+  printJson,
+  refreshClaudePlugins,
+  hasUsableCodexGuidance,
+  registerSkillCommands
+};