opencode-orchestrator 1.2.62 → 1.2.66

package/dist/scripts/preuninstall.js

@@ -1,9 +1,197 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/jsonc-parser/lib/umd/main.js
+var require_main = __commonJS({
+  "node_modules/jsonc-parser/lib/umd/main.js"(exports, module) {
+    (function(factory) {
+      if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(__require, exports);
+        if (v !== void 0) module.exports = v;
+      } else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "./impl/format", "./impl/edit", "./impl/scanner", "./impl/parser"], factory);
+      }
+    })(function(require2, exports2) {
+      "use strict";
+      Object.defineProperty(exports2, "__esModule", { value: true });
+      exports2.applyEdits = exports2.modify = exports2.format = exports2.printParseErrorCode = exports2.ParseErrorCode = exports2.stripComments = exports2.visit = exports2.getNodeValue = exports2.getNodePath = exports2.findNodeAtOffset = exports2.findNodeAtLocation = exports2.parseTree = exports2.parse = exports2.getLocation = exports2.SyntaxKind = exports2.ScanError = exports2.createScanner = void 0;
+      const formatter = require2("./impl/format");
+      const edit = require2("./impl/edit");
+      const scanner = require2("./impl/scanner");
+      const parser = require2("./impl/parser");
+      exports2.createScanner = scanner.createScanner;
+      var ScanError;
+      (function(ScanError2) {
+        ScanError2[ScanError2["None"] = 0] = "None";
+        ScanError2[ScanError2["UnexpectedEndOfComment"] = 1] = "UnexpectedEndOfComment";
+        ScanError2[ScanError2["UnexpectedEndOfString"] = 2] = "UnexpectedEndOfString";
+        ScanError2[ScanError2["UnexpectedEndOfNumber"] = 3] = "UnexpectedEndOfNumber";
+        ScanError2[ScanError2["InvalidUnicode"] = 4] = "InvalidUnicode";
+        ScanError2[ScanError2["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter";
+        ScanError2[ScanError2["InvalidCharacter"] = 6] = "InvalidCharacter";
+      })(ScanError || (exports2.ScanError = ScanError = {}));
+      var SyntaxKind;
+      (function(SyntaxKind2) {
+        SyntaxKind2[SyntaxKind2["OpenBraceToken"] = 1] = "OpenBraceToken";
+        SyntaxKind2[SyntaxKind2["CloseBraceToken"] = 2] = "CloseBraceToken";
+        SyntaxKind2[SyntaxKind2["OpenBracketToken"] = 3] = "OpenBracketToken";
+        SyntaxKind2[SyntaxKind2["CloseBracketToken"] = 4] = "CloseBracketToken";
+        SyntaxKind2[SyntaxKind2["CommaToken"] = 5] = "CommaToken";
+        SyntaxKind2[SyntaxKind2["ColonToken"] = 6] = "ColonToken";
+        SyntaxKind2[SyntaxKind2["NullKeyword"] = 7] = "NullKeyword";
+        SyntaxKind2[SyntaxKind2["TrueKeyword"] = 8] = "TrueKeyword";
+        SyntaxKind2[SyntaxKind2["FalseKeyword"] = 9] = "FalseKeyword";
+        SyntaxKind2[SyntaxKind2["StringLiteral"] = 10] = "StringLiteral";
+        SyntaxKind2[SyntaxKind2["NumericLiteral"] = 11] = "NumericLiteral";
+        SyntaxKind2[SyntaxKind2["LineCommentTrivia"] = 12] = "LineCommentTrivia";
+        SyntaxKind2[SyntaxKind2["BlockCommentTrivia"] = 13] = "BlockCommentTrivia";
+        SyntaxKind2[SyntaxKind2["LineBreakTrivia"] = 14] = "LineBreakTrivia";
+        SyntaxKind2[SyntaxKind2["Trivia"] = 15] = "Trivia";
+        SyntaxKind2[SyntaxKind2["Unknown"] = 16] = "Unknown";
+        SyntaxKind2[SyntaxKind2["EOF"] = 17] = "EOF";
+      })(SyntaxKind || (exports2.SyntaxKind = SyntaxKind = {}));
+      exports2.getLocation = parser.getLocation;
+      exports2.parse = parser.parse;
+      exports2.parseTree = parser.parseTree;
+      exports2.findNodeAtLocation = parser.findNodeAtLocation;
+      exports2.findNodeAtOffset = parser.findNodeAtOffset;
+      exports2.getNodePath = parser.getNodePath;
+      exports2.getNodeValue = parser.getNodeValue;
+      exports2.visit = parser.visit;
+      exports2.stripComments = parser.stripComments;
+      var ParseErrorCode;
+      (function(ParseErrorCode2) {
+        ParseErrorCode2[ParseErrorCode2["InvalidSymbol"] = 1] = "InvalidSymbol";
+        ParseErrorCode2[ParseErrorCode2["InvalidNumberFormat"] = 2] = "InvalidNumberFormat";
+        ParseErrorCode2[ParseErrorCode2["PropertyNameExpected"] = 3] = "PropertyNameExpected";
+        ParseErrorCode2[ParseErrorCode2["ValueExpected"] = 4] = "ValueExpected";
+        ParseErrorCode2[ParseErrorCode2["ColonExpected"] = 5] = "ColonExpected";
+        ParseErrorCode2[ParseErrorCode2["CommaExpected"] = 6] = "CommaExpected";
+        ParseErrorCode2[ParseErrorCode2["CloseBraceExpected"] = 7] = "CloseBraceExpected";
+        ParseErrorCode2[ParseErrorCode2["CloseBracketExpected"] = 8] = "CloseBracketExpected";
+        ParseErrorCode2[ParseErrorCode2["EndOfFileExpected"] = 9] = "EndOfFileExpected";
+        ParseErrorCode2[ParseErrorCode2["InvalidCommentToken"] = 10] = "InvalidCommentToken";
+        ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfComment"] = 11] = "UnexpectedEndOfComment";
+        ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfString"] = 12] = "UnexpectedEndOfString";
+        ParseErrorCode2[ParseErrorCode2["UnexpectedEndOfNumber"] = 13] = "UnexpectedEndOfNumber";
+        ParseErrorCode2[ParseErrorCode2["InvalidUnicode"] = 14] = "InvalidUnicode";
+        ParseErrorCode2[ParseErrorCode2["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter";
+        ParseErrorCode2[ParseErrorCode2["InvalidCharacter"] = 16] = "InvalidCharacter";
+      })(ParseErrorCode || (exports2.ParseErrorCode = ParseErrorCode = {}));
+      function printParseErrorCode2(code) {
+        switch (code) {
+          case 1:
+            return "InvalidSymbol";
+          case 2:
+            return "InvalidNumberFormat";
+          case 3:
+            return "PropertyNameExpected";
+          case 4:
+            return "ValueExpected";
+          case 5:
+            return "ColonExpected";
+          case 6:
+            return "CommaExpected";
+          case 7:
+            return "CloseBraceExpected";
+          case 8:
+            return "CloseBracketExpected";
+          case 9:
+            return "EndOfFileExpected";
+          case 10:
+            return "InvalidCommentToken";
+          case 11:
+            return "UnexpectedEndOfComment";
+          case 12:
+            return "UnexpectedEndOfString";
+          case 13:
+            return "UnexpectedEndOfNumber";
+          case 14:
+            return "InvalidUnicode";
+          case 15:
+            return "InvalidEscapeCharacter";
+          case 16:
+            return "InvalidCharacter";
+        }
+        return "<unknown ParseErrorCode>";
+      }
+      exports2.printParseErrorCode = printParseErrorCode2;
+      function format(documentText, range, options) {
+        return formatter.format(documentText, range, options);
+      }
+      exports2.format = format;
+      function modify2(text, path, value, options) {
+        return edit.setProperty(text, path, value, options);
+      }
+      exports2.modify = modify2;
+      function applyEdits2(text, edits) {
+        let sortedEdits = edits.slice(0).sort((a, b) => {
+          const diff = a.offset - b.offset;
+          if (diff === 0) {
+            return a.length - b.length;
+          }
+          return diff;
+        });
+        let lastModifiedOffset = text.length;
+        for (let i = sortedEdits.length - 1; i >= 0; i--) {
+          let e = sortedEdits[i];
+          if (e.offset + e.length <= lastModifiedOffset) {
+            text = edit.applyEdit(text, e);
+          } else {
+            throw new Error("Overlapping edit");
+          }
+          lastModifiedOffset = e.offset;
+        }
+        return text;
+      }
+      exports2.applyEdits = applyEdits2;
+    });
+  }
+});
 
 // scripts/preuninstall.ts
+var import_jsonc_parser = __toESM(require_main(), 1);
 import { existsSync, readFileSync, writeFileSync, appendFileSync, copyFileSync, renameSync, unlinkSync, readdirSync } from "fs";
 import { homedir, tmpdir } from "os";
-import { join } from "path";
+import { dirname, join, basename } from "path";
+var isCI = process.env.CI === "true" || process.env.CONTINUOUS_INTEGRATION === "true";
+var TIMEOUT_MS = 3e4;
+var timeoutId = setTimeout(() => {
+  console.log("\u26A0\uFE0F  preuninstall timeout - exiting gracefully");
+  process.exit(0);
+}, TIMEOUT_MS);
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
 var LOG_FILE = join(tmpdir(), "opencode-orchestrator.log");
 function log(message, data) {
   try {
@@ -40,6 +228,41 @@ function formatError(err, context) {
   return `Failed to ${context}: ${String(err)}`;
 }
 var PLUGIN_NAME = "opencode-orchestrator";
+function isOurPluginEntry(p) {
+  return p === PLUGIN_NAME || p.startsWith(`${PLUGIN_NAME}@`);
+}
+function getConfigFileCandidates(configDir) {
+  return [join(configDir, "opencode.jsonc"), join(configDir, "opencode.json")];
+}
+function resolveConfigFile(configDir) {
+  for (const candidate of getConfigFileCandidates(configDir)) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  return getConfigFileCandidates(configDir)[0];
+}
+function parseConfigContent(rawContent) {
+  const errors = [];
+  const config = (0, import_jsonc_parser.parse)(rawContent, errors, {
+    allowTrailingComma: true,
+    disallowComments: false
+  });
+  if (errors.length > 0) {
+    const [firstError] = errors;
+    const line = rawContent.slice(0, firstError.offset).split("\n").length;
+    const column = firstError.offset - rawContent.lastIndexOf("\n", firstError.offset - 1);
+    return {
+      parseError: `${(0, import_jsonc_parser.printParseErrorCode)(firstError.error)} at line ${line}, column ${column}`
+    };
+  }
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    return {
+      parseError: "Root config must be a JSON object"
+    };
+  }
+  return { config };
+}
 function detectWSLWindowsConfigDir() {
   try {
     const isWSL = process.env.WSL_DISTRO_NAME || process.env.WSLENV;
@@ -97,7 +320,7 @@ function getConfigPaths() {
       paths.push(wslWindowsConfig);
     }
   }
-  return paths;
+  return [...new Set(paths)];
 }
 function validateConfig(config) {
   try {
@@ -134,10 +357,19 @@ function createBackup(configFile) {
     return null;
   }
 }
-function atomicWriteJSON(filePath, data) {
+function atomicWriteJSON(filePath, data, originalContent) {
   const tempFile = `${filePath}.tmp.${Date.now()}`;
   try {
-    writeFileSync(tempFile, JSON.stringify(data, null, 2) + "\n", { mode: 420 });
+    let output = JSON.stringify(data, null, 2) + "\n";
+    if (filePath.endsWith(".jsonc") && originalContent !== void 0) {
+      const source = originalContent.trim() ? originalContent : "{}";
+      const edits = (0, import_jsonc_parser.modify)(source, ["plugin"], data.plugin, {
+        formattingOptions: { tabSize: 2, insertSpaces: true }
+      });
+      output = (0, import_jsonc_parser.applyEdits)(source, edits);
+      if (!output.endsWith("\n")) output += "\n";
+    }
+    writeFileSync(tempFile, output, { mode: 420 });
     renameSync(tempFile, filePath);
     log("Atomic write successful", { filePath });
   } catch (error) {
@@ -151,27 +383,29 @@ function atomicWriteJSON(filePath, data) {
   }
 }
 function removeFromConfig(configDir) {
-  const configFile = join(configDir, "opencode.json");
+  const configFile = resolveConfigFile(configDir);
   let backupFile = null;
+  let originalContent;
   try {
     if (!existsSync(configFile)) {
       log("Config file does not exist", { configFile });
       return { success: false, backupFile: null };
     }
     backupFile = createBackup(configFile);
-    const content = readFileSync(configFile, "utf-8").trim();
-    if (!content) {
+    const content = readFileSync(configFile, "utf-8");
+    originalContent = content;
+    const trimmedContent = content.trim();
+    if (!trimmedContent) {
       log("Empty config file", { configFile });
       return { success: false, backupFile };
     }
-    let config;
-    try {
-      config = JSON.parse(content);
-    } catch (error) {
-      log("Failed to parse config, skipping", { error: String(error), configFile });
+    const parsed = parseConfigContent(trimmedContent);
+    if (parsed.parseError) {
+      log("Failed to parse config, skipping", { error: parsed.parseError, configFile });
       console.log(`\u26A0\uFE0F  Corrupted config detected. Backup saved: ${backupFile}`);
       return { success: false, backupFile };
     }
+    const config = parsed.config ?? {};
     if (!validateConfig(config)) {
       log("Invalid config structure, skipping", { config, configFile });
       return { success: false, backupFile };
@@ -184,7 +418,7 @@ function removeFromConfig(configDir) {
     const originalPlugins = [...config.plugin];
     config.plugin = config.plugin.filter((p) => {
       if (typeof p !== "string") return true;
-      return p !== PLUGIN_NAME && !p.includes(PLUGIN_NAME);
+      return !isOurPluginEntry(p);
     });
     if (config.plugin.length === originalLength) {
       log("Plugin not found in config", { configFile });
@@ -198,12 +432,16 @@ function removeFromConfig(configDir) {
       newPlugins: config.plugin,
       configFile
     });
-    atomicWriteJSON(configFile, config);
+    atomicWriteJSON(configFile, config, originalContent);
     try {
       const verifyContent = readFileSync(configFile, "utf-8");
-      const verifyConfig = JSON.parse(verifyContent);
+      const verifyParsed = parseConfigContent(verifyContent);
+      if (verifyParsed.parseError || !verifyParsed.config) {
+        throw new Error(`Verification parse failed: ${verifyParsed.parseError ?? "unknown parse error"}`);
+      }
+      const verifyConfig = verifyParsed.config;
       const stillHasPlugin = verifyConfig.plugin?.some(
-        (p) => typeof p === "string" && (p === PLUGIN_NAME || p.includes(PLUGIN_NAME))
+        (p) => typeof p === "string" && isOurPluginEntry(p)
       );
       if (stillHasPlugin) {
         throw new Error("Verification failed: plugin still present after removal");
@@ -234,9 +472,10 @@ function removeFromConfig(configDir) {
 }
 function cleanupOldBackups(configFile) {
   try {
-    const configDir = join(configFile, "..");
+    const configDir = dirname(configFile);
+    const configBase = basename(configFile);
     const files = readdirSync(configDir);
-    const backupFiles = files.filter((f) => f.startsWith("opencode.json.backup.")).sort().reverse();
+    const backupFiles = files.filter((f) => f.startsWith(`${configBase}.backup.`)).sort().reverse();
     for (let i = 5; i < backupFiles.length; i++) {
       const backupPath = join(configDir, backupFiles[i]);
       try {
@@ -250,13 +489,20 @@ function cleanupOldBackups(configFile) {
 }
 try {
   console.log("\u{1F9F9} OpenCode Orchestrator - Uninstalling...");
+  if (isCI) log("Running in CI mode");
   log("Uninstallation started", { platform: process.platform, node: process.version });
+  if (isCI) {
+    console.log("\u2139\uFE0F  CI environment detected. Skipping automatic plugin cleanup.");
+    log("Skipping automatic plugin cleanup in CI");
+    clearTimeout(timeoutId);
+    process.exit(0);
+  }
   const configPaths = getConfigPaths();
   log("Config paths to check", configPaths);
   let removed = false;
   let backupCreated = null;
   for (const configDir of configPaths) {
-    const configFile = join(configDir, "opencode.json");
+    const configFile = resolveConfigFile(configDir);
     const result = removeFromConfig(configDir);
     if (result.success) {
       console.log(`\u2705 Plugin removed: ${configFile}`);
@@ -281,4 +527,6 @@ try {
   console.error("\u274C " + formatError(error, "clean up config"));
   console.log(`   Check logs: ${LOG_FILE}`);
   process.exit(0);
+} finally {
+  clearTimeout(timeoutId);
 }

package/dist/shared/index.d.ts

@@ -17,4 +17,3 @@ export * from "./verification/index.js";
 export * from "./lifecycle/index.js";
 export * from "./errors/index.js";
 export * from "./prompt/index.js";
-export { TASK_STATUS, TODO_STATUS } from "../core/agents/consts/task-status.const.js";

package/dist/shared/loop/constants/index.d.ts

@@ -3,5 +3,6 @@
  */
 export { LOOP } from "./loop.js";
 export { MISSION_CONTROL, MISSION } from "./mission-control.js";
+export { TASK_STATUS } from "./task-status.js";
 export { TODO_STATUS } from "./todo-status.js";
 export { LOOP_LABELS } from "./labels.js";

package/dist/shared/loop/constants/task-status.d.ts

@@ -0,0 +1,9 @@
+export declare const TASK_STATUS: {
+    readonly PENDING: "pending";
+    readonly RUNNING: "running";
+    readonly COMPLETED: "completed";
+    readonly FAILED: "failed";
+    readonly ERROR: "error";
+    readonly TIMEOUT: "timeout";
+    readonly CANCELLED: "cancelled";
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "opencode-orchestrator",
   "displayName": "OpenCode Orchestrator",
   "description": "Distributed Cognitive Architecture for OpenCode. Turns simple prompts into specialized multi-agent workflows (Planner, Coder, Reviewer).",
-  "version": "1.2.62",
+  "version": "1.2.66",
   "author": "agnusdei1207",
   "license": "MIT",
   "repository": {
@@ -34,6 +34,7 @@
   },
   "files": [
     "dist",
+    "scripts/run-install-hook.mjs",
     "bin",
     "README.md",
     "LICENSE"
@@ -51,13 +52,16 @@
     "test:unit": "vitest run tests/unit --reporter=verbose",
     "test:e2e": "vitest run tests/e2e --reporter=verbose",
     "test:all": "npm run build && vitest run --reporter=verbose && echo '=== ALL TESTS PASSED ==='",
-    "postinstall": "node dist/scripts/postinstall.js",
-    "preuninstall": "node dist/scripts/preuninstall.js",
+    "postinstall": "node scripts/run-install-hook.mjs postinstall",
+    "preuninstall": "node scripts/run-install-hook.mjs preuninstall",
     "prepublishOnly": "npm run build",
     "publish:token": "npm publish --access public",
-    "release:patch": "npm run build && npm run docker:rust-dist && npm version patch && git push --follow-tags && npm run publish:token",
-    "release:minor": "npm run build && npm run docker:rust-dist && npm version minor && git push --follow-tags && npm run publish:token",
-    "release:major": "npm run build && npm run docker:rust-dist && npm version major && git push --follow-tags && npm run publish:token",
+    "releae:patch": "npm run release:patch",
+    "sync:readme-version": "node scripts/sync-readme-version.mjs",
+    "version": "npm run sync:readme-version",
+    "release:patch": "npm version patch && npm run build && npm run docker:rust-dist && npm run publish:token",
+    "release:minor": "npm version minor && npm run build && npm run docker:rust-dist && npm run publish:token",
+    "release:major": "npm version major && npm run build && npm run docker:rust-dist && npm run publish:token",
     "reset:local": "brew uninstall opencode 2>/dev/null; rm -rf ~/.config/opencode ~/.opencode ~/.local/share/opencode ~/.cache/opencode/node_modules/opencode-orchestrator && echo '=== Clean done ===' && brew install opencode && echo '{\"plugin\": [\"opencode-orchestrator\"], \"$schema\": \"https://opencode.ai/config.json\"}' > ~/.config/opencode/opencode.json && echo '=== Reset (Dev) complete. Run: opencode ==='",
     "reset:prod": "brew uninstall opencode 2>/dev/null; rm -rf ~/.config/opencode ~/.opencode ~/.local/share/opencode ~/.cache/opencode/node_modules/opencode-orchestrator && echo '=== Clean done ===' && brew install opencode && echo '{\"plugin\": [\"opencode-orchestrator\"], \"$schema\": \"https://opencode.ai/config.json\"}' > ~/.config/opencode/opencode.json && npm uninstall -g opencode-orchestrator && echo '=== Reset (Prod) complete. Run: opencode ==='",
     "ginstall": "npm install -g opencode-orchestrator",
@@ -69,6 +73,7 @@
   "dependencies": {
     "@opencode-ai/plugin": "^1.1.35",
     "@opencode-ai/sdk": "^1.1.35",
+    "jsonc-parser": "^3.3.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/scripts/run-install-hook.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+import { existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const VALID_HOOKS = new Set(["postinstall", "preuninstall"]);
+
+function resolveRepoRoot() {
+  const scriptPath = fileURLToPath(import.meta.url);
+  return path.resolve(path.dirname(scriptPath), "..");
+}
+
+function resolveHookCommand(repoRoot, hookName) {
+  const distEntry = path.join(repoRoot, "dist", "scripts", `${hookName}.js`);
+  if (existsSync(distEntry)) {
+    return {
+      command: process.execPath,
+      args: [distEntry],
+    };
+  }
+
+  const sourceEntry = path.join(repoRoot, "scripts", `${hookName}.ts`);
+  if (existsSync(sourceEntry)) {
+    return {
+      command: process.execPath,
+      args: ["--experimental-strip-types", sourceEntry],
+    };
+  }
+
+  return null;
+}
+
+function main() {
+  const hookName = process.argv[2];
+  if (!VALID_HOOKS.has(hookName)) {
+    console.error(`Unknown install hook: ${hookName ?? "(missing)"}`);
+    process.exit(1);
+  }
+
+  const repoRoot = resolveRepoRoot();
+  const hookCommand = resolveHookCommand(repoRoot, hookName);
+
+  if (!hookCommand) {
+    console.log(`⚠️  ${hookName} entrypoint not found. Skipping gracefully.`);
+    process.exit(0);
+  }
+
+  const result = spawnSync(hookCommand.command, hookCommand.args, {
+    cwd: repoRoot,
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  if (typeof result.status === "number") {
+    process.exit(result.status);
+  }
+
+  if (result.error) {
+    console.error(`Failed to run ${hookName}: ${result.error.message}`);
+  }
+  process.exit(1);
+}
+
+main();