@pushary/agent-hooks 1.9.0 → 1.9.2

package/dist/{chunk-MQJWO3AA.js → chunk-FHLRRCUZ.js}

@@ -1,17 +1,17 @@
 import {
   CLAUDE_HOOK_EVENTS,
   supportedClaudeEvents
-} from "./chunk-YFS4HYCI.js";
+} from "./chunk-B6BLCHJW.js";
 import {
   guardBinary,
   holdBudgetOf,
   isProtectedByScope,
   registerHookEntry
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   HOOK_LOCATOR_BINARY,
   withHookHoldBudget
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/claude-config.ts
 import { join } from "path";

package/dist/{chunk-7LLNRCOK.js → chunk-FWQM6V7Z.js}

@@ -1,6 +1,6 @@
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-ABIW72ST.js";
 
 // src/setup/codex-trust.ts
 var CODEX_TRUST_TELEMETRY = {

package/dist/{chunk-CFAD2LTH.js → chunk-HLNSTJND.js}

@@ -10,10 +10,10 @@ import {
   resolvePackageVersionFromBinary,
   resolvePathBinary,
   resolvePathBinaryAsync
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   MANAGED_PROVIDERS
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/setup/codex-install.ts
 var NATIVE_BINARY_MIN_BYTES = 20 * 1024 * 1024;

package/dist/{chunk-R76C43H7.js → chunk-HZ57E6LS.js}

@@ -13,7 +13,45 @@ import {
   isReleaseVersion,
   ownPackageName,
   withHookHoldBudget
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
+
+// src/setup/paths.ts
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+
+// src/codex-config.ts
+import { createHash } from "crypto";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/registration-holder.ts
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var registeredCommands = (document) => {
+  const hooks = asRecord(document?.hooks);
+  if (!hooks) return [];
+  const found = [];
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) continue;
+    for (const item of value) {
+      const inner = asRecord(item)?.hooks;
+      if (!Array.isArray(inner)) continue;
+      for (const hook of inner) {
+        const command = asRecord(hook)?.command;
+        if (typeof command === "string") found.push({ event, command });
+      }
+    }
+  }
+  return found;
+};
+var wholeSegments = (command) => command.split(/[\s/\\"']+/).map((segment) => segment.replace(/\.(cmd|exe)$/i, ""));
+var namesLocator = (command) => wholeSegments(command).includes(HOOK_LOCATOR_BINARY);
+var namesCliBinary = (command, cliBinaries) => wholeSegments(command).some((segment) => cliBinaries.has(segment));
+var namesOurBinary = (command, cliBinaries) => namesLocator(command) || namesCliBinary(command, cliBinaries);
+var registrationHolderOf = (document, cliBinaries) => {
+  const commands = registeredCommands(document);
+  if (commands.some(({ command }) => namesLocator(command))) return "app";
+  return commands.some(({ command }) => namesCliBinary(command, cliBinaries)) ? "cli" : "none";
+};
 
 // src/npm.ts
 import { promisify } from "util";
@@ -327,19 +365,32 @@ var installGlobally = (options) => {
   }
   const started = (async () => {
     if (!npmIsOnPath()) throw new NpmMissingError();
-    const platform = process.platform;
-    const { prefix, packageName } = planGlobalInstall(platform);
-    const pinned = process.env.PUSHARY_PIN_GLOBAL_VERSION !== "0";
-    if (pinned && prefix !== void 0 && !needsGlobalInstall(
-      options.version,
-      installedVersionOf(prefix, packageName, platform),
-      globalPackageBinsPresent(packageName, prefix, platform)
-    )) {
-      return "skipped";
+    const { withUpgradeLock } = await import("./global-upgrade-N24WINE7.js");
+    const { installWithUpgradeLock, ownsUpgradeLock } = await import("./upgrade-lock-F6SM6IEZ.js");
+    const { autoUpdateLock: autoUpdateLock2 } = await import("./paths-53PCHAOJ.js");
+    let result = "skipped";
+    const install = async () => {
+      const platform = process.platform;
+      const { prefix, packageName } = planGlobalInstall(platform);
+      const pinned = process.env.PUSHARY_PIN_GLOBAL_VERSION !== "0";
+      if (pinned && prefix !== void 0 && !needsGlobalInstall(
+        options.version,
+        installedVersionOf(prefix, packageName, platform),
+        globalPackageBinsPresent(packageName, prefix, platform)
+      )) {
+        return;
+      }
+      const version = pinned && options.version && options.version !== "0.0.0" ? options.version : LATEST_TAG;
+      installWithUpgradeLock({ packageName, version, timeoutMs: options.timeoutMs ?? 12e4 }, options.lockPath);
+      result = "installed";
+    };
+    if (ownsUpgradeLock(options.lockPath ?? autoUpdateLock2())) {
+      await install();
+    } else {
+      const lock = await withUpgradeLock(install, options);
+      if (lock.kind === "refused") throw new Error(lock.message);
     }
-    const version = pinned && options.version && options.version !== "0.0.0" ? options.version : LATEST_TAG;
-    installPackageGlobally({ packageName, version, timeoutMs: options.timeoutMs ?? 12e4 });
-    return "installed";
+    return result;
   })();
   installState = started;
   started.catch(() => {
@@ -397,40 +448,6 @@ var guardedArgv = (target, args = [], platform = process.platform) => {
   return [shell, ...shellArgs, HOOK_GUARD_SCRIPTS[guardKindOf(target)], path, ...args];
 };
 
-// src/codex-config.ts
-import { createHash } from "crypto";
-import { homedir } from "os";
-import { join as join2 } from "path";
-
-// src/registration-holder.ts
-var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
-var registeredCommands = (document) => {
-  const hooks = asRecord(document?.hooks);
-  if (!hooks) return [];
-  const found = [];
-  for (const [event, value] of Object.entries(hooks)) {
-    if (!Array.isArray(value)) continue;
-    for (const item of value) {
-      const inner = asRecord(item)?.hooks;
-      if (!Array.isArray(inner)) continue;
-      for (const hook of inner) {
-        const command = asRecord(hook)?.command;
-        if (typeof command === "string") found.push({ event, command });
-      }
-    }
-  }
-  return found;
-};
-var wholeSegments = (command) => command.split(/[\s/\\"']+/).map((segment) => segment.replace(/\.(cmd|exe)$/i, ""));
-var namesLocator = (command) => wholeSegments(command).includes(HOOK_LOCATOR_BINARY);
-var namesCliBinary = (command, cliBinaries) => wholeSegments(command).some((segment) => cliBinaries.has(segment));
-var namesOurBinary = (command, cliBinaries) => namesLocator(command) || namesCliBinary(command, cliBinaries);
-var registrationHolderOf = (document, cliBinaries) => {
-  const commands = registeredCommands(document);
-  if (commands.some(({ command }) => namesLocator(command))) return "app";
-  return commands.some(({ command }) => namesCliBinary(command, cliBinaries)) ? "cli" : "none";
-};
-
 // src/hook-entries.ts
 var registerHookEntry = (existing, isOurs, entry) => {
   const rewritten = [];
@@ -493,6 +510,7 @@ var CODEX_HOOK_EVENTS = [
   { event: "PreCompact", matcher: "manual|auto", delivery: "telemetry", timeout: 5 },
   { event: "PostCompact", matcher: "manual|auto", delivery: "telemetry", timeout: 5 }
 ];
+var CODEX_REQUIRED_APPROVAL_EVENTS = CODEX_HOOK_EVENTS.filter((event) => event.delivery === "approval").map((event) => event.event);
 var CODEX_EVENT_KEY = {
   PermissionRequest: "permission_request",
   PreToolUse: "pre_tool_use",
@@ -684,11 +702,22 @@ var codexTrustGaps = (config, hooksConfig, hooksJsonPath, command, positions) =>
   for (const definition of CODEX_HOOK_EVENTS) {
     const position = positions[definition.event];
     if (!position) continue;
-    const stored = asRecord2(state?.[codexHookStateKey(hooksJsonPath, definition.event, position)])?.trusted_hash;
+    const hookState = asRecord2(state?.[codexHookStateKey(hooksJsonPath, definition.event, position)]);
+    if (definition.delivery === "approval" && hookState?.enabled === false) {
+      gaps.push({ event: definition.event, kind: "disabled" });
+      continue;
+    }
+    const stored = hookState?.trusted_hash;
     const eventKey = CODEX_EVENT_KEY[definition.event] ?? definition.event;
     const onDisk = asRecord2(
       asRecord2(hooks?.[definition.event]) ?? (Array.isArray(hooks?.[definition.event]) ? hooks[definition.event][position[0]] : void 0)
     );
+    const handlers = onDisk?.hooks;
+    const handler = Array.isArray(handlers) ? asRecord2(handlers[position[1]]) : void 0;
+    if (definition.delivery === "approval" && handler?.async === true) {
+      gaps.push({ event: definition.event, kind: "asynchronous" });
+      continue;
+    }
     const diskHash = onDisk ? codexEntryTrustHash(eventKey, onDisk) : void 0;
     if (stored !== void 0 && diskHash !== void 0 && stored === diskHash) {
       if (diskHash !== codexHookTrustHash(definition, command)) {
@@ -759,13 +788,14 @@ var staleTrustKeys = (state, hooksJsonPath, event, currentKey, ourHash) => {
 };
 
 // src/setup/paths.ts
-import { homedir as homedir2 } from "os";
-import { join as join3 } from "path";
 var claudeSettings = () => join3(homedir2(), ".claude", "settings.json");
 var claudeJson = () => join3(homedir2(), ".claude.json");
 var claudeSkillDir = () => join3(homedir2(), ".claude", "skills", "pushary");
 var cursorPluginDir = () => join3(homedir2(), ".cursor", "plugins", "local", "pushary");
 var cursorUserHooks = () => join3(homedir2(), ".cursor", "hooks.json");
+var cursorPluginMcp = () => join3(cursorPluginDir(), "mcp.json");
+var cursorPluginManifest = () => join3(cursorPluginDir(), ".cursor-plugin", "plugin.json");
+var cursorPluginRule = () => join3(cursorPluginDir(), "rules", "pushary.mdc");
 var cursorUserMcp = () => join3(homedir2(), ".cursor", "mcp.json");
 var vscodePluginDir = () => join3(homedir2(), ".pushary", "plugins", "vscode");
 var vscodePluginMcp = () => join3(vscodePluginDir(), ".mcp.json");
@@ -837,6 +867,7 @@ export {
   codexAgentsMd,
   codexSkillDir,
   CODEX_HOOK_EVENTS,
+  CODEX_REQUIRED_APPROVAL_EVENTS,
   addCodexMcpServer,
   readCodexMcpAuth,
   isPusharyCodexCommand,
@@ -859,6 +890,9 @@ export {
   claudeSkillDir,
   cursorPluginDir,
   cursorUserHooks,
+  cursorPluginMcp,
+  cursorPluginManifest,
+  cursorPluginRule,
   cursorUserMcp,
   vscodePluginDir,
   vscodePluginMcp,

package/dist/{chunk-ZMVLKPT7.js → chunk-HZYUDXIH.js}

@@ -1,23 +1,23 @@
 import {
   clientErrorKindOf,
   reportClientError
-} from "./chunk-BG4QCOHQ.js";
+} from "./chunk-XXSAGQAV.js";
 import {
   SubscriptionRequiredError,
   callMcpTool
-} from "./chunk-CPBRXBLG.js";
+} from "./chunk-XOXW4D6P.js";
 import {
   installNetworkDefaults
-} from "./chunk-P6VDRQF3.js";
+} from "./chunk-V3P2VSX7.js";
 import {
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-L52OIZXV.js";
 import {
   ASK_AGENT_NAME_MAX,
   ASK_QUESTION_MAX,
   DECISION_LINE_MAX,
   truncateLine
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/api.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-OXQKXZJ3.js → chunk-IH5NZMN4.js}

@@ -1,9 +1,9 @@
 import {
   registerTranscript
-} from "./chunk-WFVNXGZ6.js";
+} from "./chunk-PN3F7LOB.js";
 import {
   writeDegraded
-} from "./chunk-BG4QCOHQ.js";
+} from "./chunk-XXSAGQAV.js";
 
 // src/tool-hook-input.ts
 var OPTIONAL_TEXT_FIELDS = ["hook_event_name", "session_id", "cwd", "transcript_path", "tool_use_id", "permission_mode"];

package/dist/{chunk-2V64X5RE.js → chunk-IVPVCCFT.js}

@@ -4,7 +4,7 @@ import {
 import {
   describeKeyCheck,
   keyCheckFromResponse
-} from "./chunk-75CEJ4WP.js";
+} from "./chunk-Y6DSV2OS.js";
 import {
   EXIT
 } from "./chunk-KZERVKTD.js";

package/dist/chunk-JXLANQLV.js

@@ -0,0 +1,175 @@
+import {
+  autoUpdateLock,
+  installPackageGlobally,
+  npmErrorMessage
+} from "./chunk-HZ57E6LS.js";
+import {
+  writeJsonAtomic
+} from "./chunk-T7E75EKA.js";
+
+// src/upgrade-lock.ts
+import { fork } from "child_process";
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, realpathSync, unlinkSync } from "fs";
+import { createServer, Server } from "net";
+import { basename, dirname, join } from "path";
+var LOCK_HOST = "127.0.0.1";
+var LOCK_PORT_START = 49152;
+var LOCK_PORT_COUNT = 16384;
+var INHERITED_LOCK_ENV = "PUSHARY_UPGRADE_LOCK";
+var LOCK_READY = "pushary-upgrade-lock-ready";
+var LOCK_HANDLE = "pushary-upgrade-lock-handle";
+var HANDOFF_TIMEOUT_MS = 1e4;
+var FINISH_TIMEOUT_MS = 5 * 60 * 1e3;
+var KERNEL_LOCK_FORMAT = "kernel-v1";
+var heldLocks = /* @__PURE__ */ new Map();
+var canonicalLockPath = (path) => {
+  mkdirSync(dirname(path), { recursive: true });
+  return join(realpathSync(dirname(path)), basename(path));
+};
+var lockPort = (path) => LOCK_PORT_START + createHash("sha256").update(path).digest().readUInt32BE(0) % LOCK_PORT_COUNT;
+var readLockRecord = (path) => {
+  try {
+    const value = JSON.parse(readFileSync(path, "utf8"));
+    const pid = value && typeof value === "object" && "pid" in value ? value.pid : void 0;
+    return {
+      pid: typeof pid === "number" && Number.isInteger(pid) && pid > 0 ? pid : void 0,
+      installationPending: value !== null && typeof value === "object" && "installationPending" in value && value.installationPending === true,
+      usesKernelLock: value !== null && typeof value === "object" && "format" in value && value.format === KERNEL_LOCK_FORMAT
+    };
+  } catch {
+    return { pid: void 0, usesKernelLock: false, installationPending: false };
+  }
+};
+var isProcessAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return !(error instanceof Error && "code" in error && error.code === "ESRCH");
+  }
+};
+var rejectConnection = (socket) => {
+  socket.destroy();
+};
+var inheritLock = (path) => new Promise((resolve) => {
+  const done = (claim) => {
+    clearTimeout(timer);
+    process.off("message", receive);
+    process.off("disconnect", disconnected);
+    resolve(claim);
+  };
+  const disconnected = () => done({ kind: "unavailable", reason: "Upgrade parent disconnected before transferring its lock" });
+  const receive = (message, handle) => {
+    if (message !== LOCK_HANDLE || !(handle instanceof Server)) return;
+    const address = handle.address();
+    if (address === null || typeof address === "string" || address.port !== lockPort(path) || address.address !== LOCK_HOST) {
+      handle.close();
+      done({ kind: "unavailable", reason: "Invalid inherited upgrade lock" });
+      return;
+    }
+    handle.on("connection", rejectConnection);
+    heldLocks.set(path, handle);
+    done({ kind: "inherited" });
+    process.disconnect?.();
+  };
+  const timer = setTimeout(() => done({ kind: "unavailable", reason: "Upgrade lock handoff timed out" }), HANDOFF_TIMEOUT_MS);
+  process.on("message", receive);
+  process.once("disconnect", disconnected);
+  if (!process.send || !process.connected) return disconnected();
+  process.send(LOCK_READY, (error) => {
+    if (error) disconnected();
+  });
+});
+var claimUpgradeLock = async (request = {}) => {
+  let server;
+  try {
+    const path = canonicalLockPath(request.lockPath ?? autoUpdateLock());
+    const inheritedPath = process.env[INHERITED_LOCK_ENV];
+    delete process.env[INHERITED_LOCK_ENV];
+    if (inheritedPath === path && !heldLocks.has(path)) return await inheritLock(path);
+    server = createServer(rejectConnection);
+    const listener = server;
+    await new Promise((resolve, reject) => {
+      listener.once("error", reject);
+      listener.listen({ host: LOCK_HOST, port: lockPort(path), exclusive: true }, resolve);
+    });
+    const record = readLockRecord(path);
+    if (record.installationPending) {
+      server.close();
+      return { kind: "unavailable", reason: `An earlier installation did not finish safely. Stop its npm processes (or restart the computer), then remove ${path} and retry the upgrade.` };
+    }
+    if (existsSync(path) && !record.usesKernelLock && (record.pid === void 0 || (request.isAlive ?? isProcessAlive)(record.pid))) {
+      server.close();
+      return { kind: "held", holderPid: record.pid };
+    }
+    writeJsonAtomic(path, { pid: process.pid, format: KERNEL_LOCK_FORMAT }, 384);
+    heldLocks.set(path, server);
+    return { kind: "acquired" };
+  } catch (error) {
+    server?.close();
+    if (error instanceof Error && "code" in error && error.code === "EADDRINUSE") {
+      return { kind: "held", holderPid: readLockRecord(request.lockPath ?? autoUpdateLock()).pid };
+    }
+    return { kind: "unavailable", reason: npmErrorMessage(error) };
+  }
+};
+var ownsUpgradeLock = (lockPath) => {
+  try {
+    return heldLocks.has(canonicalLockPath(lockPath));
+  } catch {
+    return false;
+  }
+};
+var releaseAutoUpdateLock = (lockPath) => {
+  const path = canonicalLockPath(lockPath);
+  const server = heldLocks.get(path);
+  if (!server) return;
+  heldLocks.delete(path);
+  try {
+    const record = readLockRecord(path);
+    if (record.pid === process.pid && !record.installationPending) unlinkSync(path);
+  } finally {
+    server.close();
+  }
+};
+var finishWithUpgradeLock = (request) => new Promise((resolve, reject) => {
+  const path = canonicalLockPath(request.lockPath ?? autoUpdateLock());
+  const server = heldLocks.get(path);
+  if (!server) return reject(new Error("Cannot finish an upgrade without its lock"));
+  const child = fork(request.entry, [...request.args], {
+    execArgv: [],
+    stdio: request.stdio ?? ["inherit", "inherit", "inherit", "ipc"],
+    env: { ...process.env, ...request.env, [INHERITED_LOCK_ENV]: path }
+  });
+  const timer = setTimeout(() => child.kill("SIGKILL"), FINISH_TIMEOUT_MS);
+  child.on("message", (message) => {
+    if (message === LOCK_READY) child.send(LOCK_HANDLE, server, (error) => {
+      if (error) child.kill();
+    });
+  });
+  child.once("error", (error) => {
+    clearTimeout(timer);
+    reject(error);
+  });
+  child.once("exit", (code, signal) => {
+    clearTimeout(timer);
+    if (code === 0) resolve();
+    else reject(new Error(`Upgrade finish exited with ${signal ?? code}`));
+  });
+});
+var installWithUpgradeLock = (request, lockPath = autoUpdateLock(), runNpm) => {
+  const path = canonicalLockPath(lockPath);
+  if (!heldLocks.has(path)) throw new Error("Cannot install an upgrade without its lock");
+  writeJsonAtomic(path, { pid: process.pid, format: KERNEL_LOCK_FORMAT, installationPending: true }, 384);
+  installPackageGlobally(request, runNpm);
+  writeJsonAtomic(path, { pid: process.pid, format: KERNEL_LOCK_FORMAT }, 384);
+};
+
+export {
+  claimUpgradeLock,
+  ownsUpgradeLock,
+  releaseAutoUpdateLock,
+  finishWithUpgradeLock,
+  installWithUpgradeLock
+};

package/dist/{chunk-OLG6FJV2.js → chunk-KP45FGHD.js}

@@ -1,15 +1,15 @@
 import {
   AGENT_CHOICES
-} from "./chunk-ET6QSY3H.js";
+} from "./chunk-CEHDCHXK.js";
 import {
   isBridgeLocator
-} from "./chunk-TUZ7WKOF.js";
+} from "./chunk-2XK6D4WL.js";
 import {
   pusharyHookExecutable
-} from "./chunk-NAJ3UV4E.js";
+} from "./chunk-EUNYNLDU.js";
 import {
   BELL_HOOK_BINARY
-} from "./chunk-RZXQFAWR.js";
+} from "./chunk-DKDZXJHZ.js";
 
 // src/setup/hook-ownership.ts
 var commandsIn = (value) => {

package/dist/{chunk-EG46RJRF.js → chunk-L52OIZXV.js}

@@ -1,6 +1,6 @@
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-ABIW72ST.js";
 
 // src/config.ts
 import { readFileSync } from "fs";

package/dist/{chunk-IJJ3HHFT.js → chunk-MZXXLIF6.js}

@@ -1,6 +1,6 @@
 import {
   isSafeReadOnlyCommand
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/ledger.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from "fs";

package/dist/{chunk-YJZDIFON.js → chunk-N2ATGXI4.js}

@@ -5,7 +5,7 @@ import {
   permissionDeniedAction,
   releaseThrottle,
   reportEvent
-} from "./chunk-42E4DE6C.js";
+} from "./chunk-35N53QLA.js";
 import {
   DEFAULT_SESSION
 } from "./chunk-N6IOSZOE.js";
@@ -13,7 +13,7 @@ import {
   machineDecisionFor,
   shouldDeferToNativeMode,
   wireVerdictFor
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/machine-decision-audit.ts
 import { basename } from "path";

package/dist/{chunk-WFVNXGZ6.js → chunk-PN3F7LOB.js}

@@ -6,38 +6,38 @@ import {
 } from "./chunk-SGZJ5LYH.js";
 import {
   hookOwnerOf
-} from "./chunk-OLG6FJV2.js";
+} from "./chunk-KP45FGHD.js";
 import {
   ensureDaemonRunning
-} from "./chunk-LQESQPIT.js";
+} from "./chunk-WCHFDVCC.js";
 import {
   buildTranscriptRecords,
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-MGXXQHCM.js";
+} from "./chunk-U4DLXAGD.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
-} from "./chunk-HSM5FIA3.js";
+} from "./chunk-UX2YSFKS.js";
 import {
   transcriptEnvironmentPreference,
   transcriptsEnabled
-} from "./chunk-MBVV3RX3.js";
+} from "./chunk-CTYCABBH.js";
 import {
   readTranscriptPreference
-} from "./chunk-ZRHA4PGN.js";
+} from "./chunk-ZNUNWWCN.js";
 import {
   codexHome,
   pusharyDir
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   writeJsonAtomic
 } from "./chunk-T7E75EKA.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-L52OIZXV.js";
 
 // src/transcript-registration.ts
 import { createHash } from "crypto";

package/dist/{chunk-4ZXYWEEH.js → chunk-Q36G3P7I.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-3EGEA4KH.js";
 import {
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-L52OIZXV.js";
 
 // src/cli/login-ui.ts
 import { hostname } from "os";

package/dist/{chunk-XXVMUMKT.js → chunk-QDCEEQUS.js}

@@ -1,11 +1,11 @@
 import {
   ensureCodexTrustsPusharyHooks
-} from "./chunk-JW7DKTT6.js";
+} from "./chunk-SI327OZF.js";
 import {
   addClaudeMcpServer,
   addPusharyHooks,
   addPusharyToolPermissions
-} from "./chunk-MQJWO3AA.js";
+} from "./chunk-FHLRRCUZ.js";
 import {
   detectClaudeVersion
 } from "./chunk-RIVNNBEK.js";
@@ -15,7 +15,7 @@ import {
   codexUnprovenHolds,
   codexWired,
   geminiWired
-} from "./chunk-NAJ3UV4E.js";
+} from "./chunk-EUNYNLDU.js";
 import {
   CLAUDE_HOOK_BINARY,
   CLAUDE_HOOK_EVENTS,
@@ -26,7 +26,7 @@ import {
   needsReregistration,
   registrationSignatures,
   supportedClaudeEvents
-} from "./chunk-YFS4HYCI.js";
+} from "./chunk-B6BLCHJW.js";
 import {
   formatVersion
 } from "./chunk-6ICPEJY5.js";
@@ -49,7 +49,7 @@ import {
   registrationHolderOf,
   resolveGlobalBinary,
   vscodePluginMcp
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   readJsonSafe,
   writeFileAtomic,

package/dist/{chunk-VYNTRHB6.js → chunk-RTKPR4UA.js}

@@ -1,6 +1,6 @@
 import {
   PRETOOLUSE_GATED_TOOLS
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/claude-tools.ts
 var POSTTOOLUSE_MIRROR_ONLY_TOOLS = ["TodoWrite", "Task", "WebFetch", "WebSearch"];

package/dist/{chunk-MBNMO5IR.js → chunk-SFKU5DXZ.js}

@@ -1,9 +1,9 @@
 import {
   parseSseMessages
-} from "./chunk-CPBRXBLG.js";
+} from "./chunk-XOXW4D6P.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-ABIW72ST.js";
 
 // src/mcp-stdio-bridge.ts
 var MCP_BRIDGE_BINARY = "pushary-mcp";