@pushary/agent-hooks 0.84.1 → 0.85.0

package/dist/chunk-64PXDATC.js

@@ -0,0 +1,187 @@
+import {
+  guardBinary
+} from "./chunk-PWTKKQQI.js";
+import {
+  HOOK_BUDGETS
+} from "./chunk-MQMPG5X4.js";
+
+// src/claude-config.ts
+import { join } from "path";
+
+// src/agent-version.ts
+var parseVersion = (raw) => {
+  const match = raw.match(/(\d+)\.(\d+)\.(\d+)/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+};
+var compareVersion = (a, b) => {
+  for (let index = 0; index < 3; index++) {
+    if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
+  }
+  return 0;
+};
+var atLeast = (version, floor) => compareVersion(version, floor) >= 0;
+
+// src/claude-tools.ts
+var PRETOOLUSE_GATED_TOOLS = [
+  "Bash",
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "NotebookEdit",
+  "PowerShell",
+  "Monitor"
+];
+var POSTTOOLUSE_MIRRORED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, "TodoWrite"];
+var PRETOOLUSE_HANDLED_TOOLS = /* @__PURE__ */ new Set([...PRETOOLUSE_GATED_TOOLS, "AskUserQuestion"]);
+
+// src/claude-events.ts
+var GATED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, "AskUserQuestion"].join("|");
+var MIRRORED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, "TodoWrite"].join("|");
+var ESTABLISHED = [1, 0, 0];
+var OBSERVED = [2, 0, 0];
+var CLAUDE_HOOK_EVENTS = [
+  { event: "PreToolUse", binary: "pushary-hook", matcher: GATED_TOOLS, timeout: HOOK_BUDGETS.claude.budgetSeconds, since: ESTABLISHED },
+  { event: "PostToolUse", binary: "pushary-post-hook", matcher: MIRRORED_TOOLS, timeout: 10, since: ESTABLISHED },
+  { event: "Stop", binary: "pushary-stop-hook", timeout: 10, since: ESTABLISHED },
+  { event: "UserPromptSubmit", binary: "pushary-prompt-hook", timeout: 10, since: ESTABLISHED },
+  { event: "Notification", binary: "pushary-notification-hook", matcher: "permission_prompt|idle_prompt|agent_needs_input|agent_completed", timeout: 10, since: ESTABLISHED },
+  { event: "SessionStart", binary: "pushary-session-start-hook", matcher: "startup|resume|clear", timeout: 10, since: ESTABLISHED },
+  { event: "SessionEnd", binary: "pushary-session-end-hook", timeout: 10, since: ESTABLISHED },
+  { event: "StopFailure", binary: "pushary-stopfailure-hook", timeout: 10, since: ESTABLISHED },
+  { event: "PermissionRequest", binary: "pushary-permission-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, since: ESTABLISHED },
+  { event: "PermissionDenied", binary: "pushary-permission-denied-hook", timeout: 60, since: ESTABLISHED },
+  // Observability only. Each carries session shape the island cannot get any other
+  // way, and none of them decides anything.
+  { event: "SubagentStart", binary: "pushary-session-start-hook", timeout: 10, since: OBSERVED },
+  { event: "SubagentStop", binary: "pushary-stop-hook", timeout: 10, since: OBSERVED },
+  { event: "PreCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, since: OBSERVED },
+  { event: "PostCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, since: OBSERVED },
+  { event: "TeammateIdle", binary: "pushary-notification-hook", timeout: 10, since: OBSERVED }
+];
+var supportedClaudeEvents = (version) => CLAUDE_HOOK_EVENTS.filter((hook) => version ? atLeast(version, hook.since) : hook.since === ESTABLISHED);
+
+// src/claude-config.ts
+var PUSHARY_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var PUSHARY_PERMISSION_RULE = "mcp__pushary__*";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyPermission = (rule) => typeof rule === "string" && (rule.includes("pushary") || rule.includes("MCP(pushary"));
+var HOOK_BINARIES = new Set(CLAUDE_HOOK_EVENTS.map((hook) => hook.binary));
+var namesPusharyBinary = (command) => command.split(/[\s/\\"']+/).some((segment) => HOOK_BINARIES.has(segment.replace(/\.(cmd|exe)$/i, "")));
+var isPusharyHook = (entry2) => {
+  const hooks = asRecord(entry2)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => namesPusharyBinary(String(asRecord(hook)?.command ?? "")));
+};
+var addClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = ensureRecord(config, "mcpServers");
+  mcpServers.pushary = {
+    type: "http",
+    url: PUSHARY_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+};
+var removeClaudeMcpServers = (config) => {
+  let changed = false;
+  const removeFrom = (target) => {
+    const mcpServers = asRecord(target.mcpServers);
+    if (!mcpServers?.pushary) return;
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete target.mcpServers;
+    changed = true;
+  };
+  removeFrom(config);
+  const projects = asRecord(config.projects);
+  if (projects) {
+    for (const project of Object.values(projects)) {
+      const projectConfig = asRecord(project);
+      if (projectConfig) removeFrom(projectConfig);
+    }
+  }
+  return changed;
+};
+var addPusharyToolPermissions = (settings) => {
+  const permissions = ensureRecord(settings, "permissions");
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filtered = allow.filter((rule) => !isPusharyPermission(rule));
+  if (!filtered.includes(PUSHARY_PERMISSION_RULE)) {
+    filtered.push(PUSHARY_PERMISSION_RULE);
+  }
+  permissions.allow = filtered;
+};
+var addPusharyHooks = (settings, binDir, version = null) => {
+  const resolve = (name) => guardBinary(binDir ? join(binDir, name) : name);
+  const hooks = ensureRecord(settings, "hooks");
+  const supported = new Map(supportedClaudeEvents(version).map((hook) => [hook.event, hook]));
+  for (const known of CLAUDE_HOOK_EVENTS) {
+    const current = hooks[known.event];
+    const others = (Array.isArray(current) ? current : []).filter((item) => !isPusharyHook(item));
+    const definition = supported.get(known.event);
+    if (definition) {
+      hooks[known.event] = [...others, entry(definition, resolve)];
+    } else if (others.length > 0) {
+      hooks[known.event] = others;
+    } else {
+      delete hooks[known.event];
+    }
+  }
+};
+var entry = (definition, resolve) => ({
+  ...definition.matcher ? { matcher: definition.matcher } : {},
+  hooks: [{
+    type: "command",
+    command: resolve(definition.binary),
+    timeout: definition.timeout
+  }]
+});
+var removePusharySettings = (settings) => {
+  let changed = removeClaudeMcpServers(settings);
+  const permissions = asRecord(settings.permissions);
+  if (permissions && Array.isArray(permissions.allow)) {
+    const filtered = permissions.allow.filter((rule) => !isPusharyPermission(rule));
+    if (filtered.length !== permissions.allow.length) {
+      if (filtered.length === 0) {
+        delete permissions.allow;
+      } else {
+        permissions.allow = filtered;
+      }
+      if (Object.keys(permissions).length === 0) delete settings.permissions;
+      changed = true;
+    }
+  }
+  const hooks = asRecord(settings.hooks);
+  if (hooks) {
+    for (const { event: key } of CLAUDE_HOOK_EVENTS) {
+      const entries = hooks[key];
+      if (!Array.isArray(entries)) continue;
+      const filtered = entries.filter((entry2) => !isPusharyHook(entry2));
+      if (filtered.length !== entries.length) {
+        if (filtered.length === 0) {
+          delete hooks[key];
+        } else {
+          hooks[key] = filtered;
+        }
+        changed = true;
+      }
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  return changed;
+};
+
+export {
+  parseVersion,
+  compareVersion,
+  PRETOOLUSE_HANDLED_TOOLS,
+  addClaudeMcpServer,
+  removeClaudeMcpServers,
+  addPusharyToolPermissions,
+  addPusharyHooks,
+  removePusharySettings
+};

package/dist/chunk-6CUUA7HO.js

@@ -0,0 +1,59 @@
+// src/admission.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var NO_RULES = { version: 1, disabled: [] };
+var SUPPORTED_VERSION = 1;
+var parseAdmissionRules = (raw) => {
+  if (!raw) return NO_RULES;
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== SUPPORTED_VERSION) return NO_RULES;
+    if (!Array.isArray(parsed.disabled)) return NO_RULES;
+    return {
+      version: SUPPORTED_VERSION,
+      disabled: parsed.disabled.filter((rule) => typeof rule === "string")
+    };
+  } catch {
+    return NO_RULES;
+  }
+};
+var admissionRulesFile = () => process.env.PUSHARY_ADMISSION_FILE?.trim() || join(homedir(), ".pushary", "admission-rules.json");
+var readAdmissionRules = () => {
+  try {
+    return parseAdmissionRules(readFileSync(admissionRulesFile(), "utf-8"));
+  } catch {
+    return NO_RULES;
+  }
+};
+var matches = (rule, source, event) => {
+  const colon = rule.indexOf(":");
+  if (colon <= 0 || colon === rule.length - 1) return false;
+  const ruleSource = rule.slice(0, colon);
+  const ruleEvent = rule.slice(colon + 1);
+  return (ruleSource === "*" || ruleSource === source) && (ruleEvent === "*" || ruleEvent === event);
+};
+var isAdmitted = (rules, source, event) => !rules.disabled.some((rule) => matches(rule, source, event));
+var readHookInput = async (source, fallbackEvent = "", stdin = process.stdin) => {
+  let raw = "";
+  for await (const chunk of stdin) raw += chunk;
+  if (!raw.trim()) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  const event = eventNameOf(parsed) ?? fallbackEvent;
+  return isAdmitted(readAdmissionRules(), source, event) ? parsed : null;
+};
+var eventNameOf = (input) => {
+  if (!("hook_event_name" in input)) return void 0;
+  const name = input.hook_event_name;
+  return typeof name === "string" && name.length > 0 ? name : void 0;
+};
+
+export {
+  readHookInput
+};

package/dist/{chunk-UXWEE3QI.js → chunk-ADISVXZL.js}

@@ -1,6 +1,6 @@
 import {
   codexHomeFrom
-} from "./chunk-SEAHGHCE.js";
+} from "./chunk-HVZIHTOO.js";
 
 // src/vscode-config.ts
 import { homedir } from "os";

package/dist/chunk-AXRATIS6.js

@@ -0,0 +1,70 @@
+import {
+  parseVersion
+} from "./chunk-64PXDATC.js";
+
+// src/setup/agent-probe.ts
+import { execSync } from "child_process";
+import { readFileSync, realpathSync } from "fs";
+
+// src/setup/claude-version.ts
+import { dirname, basename, join } from "path";
+var versionFromInstallPath = (path) => {
+  const name = basename(path);
+  return /^\d+\.\d+\.\d+$/.test(name) ? parseVersion(name) : null;
+};
+var versionFromManifest = (probe, binPath) => {
+  let dir = dirname(binPath);
+  for (let depth = 0; depth < 4; depth++) {
+    const raw = probe.readFile(join(dir, "package.json"));
+    if (raw) {
+      try {
+        const { version } = JSON.parse(raw);
+        if (typeof version === "string") {
+          const parsed = parseVersion(version);
+          if (parsed) return parsed;
+        }
+      } catch {
+      }
+    }
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+};
+var readClaudeVersion = (probe) => {
+  const onPath2 = probe.resolveOnPath();
+  if (!onPath2) return null;
+  const resolved = probe.realpath(onPath2) ?? onPath2;
+  return versionFromInstallPath(resolved) ?? versionFromManifest(probe, resolved);
+};
+
+// src/setup/agent-probe.ts
+var onPath = (name) => {
+  const command = process.platform === "win32" ? "where" : "which";
+  try {
+    const found = execSync(`${command} ${name}`, { encoding: "utf-8", stdio: "pipe", timeout: 5e3 }).split("\n")[0].trim();
+    return found || null;
+  } catch {
+    return null;
+  }
+};
+var realpath = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return null;
+  }
+};
+var readFile = (path) => {
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var detectClaudeVersion = () => readClaudeVersion({ resolveOnPath: () => onPath("claude"), realpath, readFile });
+
+export {
+  detectClaudeVersion
+};

package/dist/{chunk-CCCJ6BPW.js → chunk-EXMUM226.js}

@@ -196,9 +196,10 @@ var readLastGoodMode = (apiKey) => {
     return null;
   }
 };
-var writeLastGoodMode = (apiKey, state) => {
+var writeLastGoodMode = (apiKey, state, sessionId) => {
   try {
-    writeFileSync(modeStateCacheFile(apiKey), JSON.stringify({ state, at: Date.now() }), { encoding: "utf-8", mode: 384 });
+    const cached = { state, at: Date.now(), ...sessionId ? { sessionId } : {} };
+    writeFileSync(modeStateCacheFile(apiKey), JSON.stringify(cached), { encoding: "utf-8", mode: 384 });
   } catch {
   }
 };
@@ -220,7 +221,18 @@ var degradedFallback = (apiKey, authoritative = false) => {
   return unknownMode();
 };
 var toPolicyVersion = (value) => typeof value === "string" || typeof value === "number" ? String(value) : null;
-var fetchModeState = async (apiKey, sessionId) => {
+var MODE_REUSE_MS = CACHE_TTL_MS;
+var readReusableMode = (apiKey, sessionId, maxAgeMs) => {
+  const last = readLastGoodMode(apiKey);
+  if (!last || (last.sessionId ?? null) !== (sessionId ?? null)) return null;
+  if (Date.now() - last.at >= maxAgeMs) return null;
+  return { ...last.state, degraded: false };
+};
+var fetchModeState = async (apiKey, sessionId, reuseWithinMs = 0) => {
+  if (reuseWithinMs > 0) {
+    const reusable = readReusableMode(apiKey, sessionId, reuseWithinMs);
+    if (reusable) return reusable;
+  }
   try {
     const baseUrl = getBaseUrl();
     const url = sessionId ? `${baseUrl}/api/mcp/mode?session=${encodeURIComponent(sessionId)}` : `${baseUrl}/api/mcp/mode`;
@@ -244,7 +256,7 @@ var fetchModeState = async (apiKey, sessionId) => {
       scope: isScopeContract(data.scope) ? data.scope : null,
       degraded: false
     };
-    writeLastGoodMode(apiKey, state);
+    writeLastGoodMode(apiKey, state, sessionId);
     return state;
   } catch {
     return degradedFallback(apiKey);
@@ -1053,7 +1065,7 @@ var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
     const isError = isToolResultError(toolResult);
     const receiptsEnabled = process.env.PUSHARY_RECEIPTS !== "off";
     const sessionKey = input.session_id || DEFAULT_SESSION;
-    const liveMode = await fetchModeState(getApiKey(), input.session_id);
+    const liveMode = await fetchModeState(getApiKey(), input.session_id, MODE_REUSE_MS);
     const late = await reconcilePendingQuestions(sessionKey);
     let additionalContext;
     if (late.length > 0 && agent.type === CLAUDE_CODE_AGENT.type) {
@@ -1239,7 +1251,7 @@ var handleNotification = async (input, agent = CLAUDE_CODE_AGENT) => {
       } catch {
         return;
       }
-      const mode = await fetchModeState(apiKey, input.session_id).catch(() => null);
+      const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS).catch(() => null);
       if (mode?.kill || mode?.mode === "terminal_only") return;
       await sendNotification(apiKey, {
         title: `${agent.label} is waiting`,
@@ -1302,7 +1314,7 @@ var handleStopFailure = async (input, agent = CLAUDE_CODE_AGENT) => {
       return;
     }
     const projectName = basename2(input.cwd ?? process.cwd());
-    const mode = await fetchModeState(apiKey, input.session_id).catch(() => null);
+    const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS).catch(() => null);
     if (mode?.kill || mode?.mode === "terminal_only") return;
     const reason = describeStopFailure(input.error);
     await sendNotification(apiKey, {

package/dist/{chunk-YR5TSPXB.js → chunk-GFM3STWO.js}

@@ -1,6 +1,6 @@
 import {
   PRETOOLUSE_HANDLED_TOOLS
-} from "./chunk-UKSQWTBH.js";
+} from "./chunk-64PXDATC.js";
 import {
   isGatingMoment,
   recordKeylessMoment
@@ -9,7 +9,7 @@ import {
   denyReasonFrom,
   isDeferAnswer,
   resolveGate
-} from "./chunk-BLDDXHHA.js";
+} from "./chunk-GXIFADGD.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -29,7 +29,7 @@ import {
   sendNotification,
   throttlePass,
   waitForAnswer
-} from "./chunk-CCCJ6BPW.js";
+} from "./chunk-EXMUM226.js";
 import {
   getMachineId
 } from "./chunk-RN3NOEJF.js";

package/dist/{chunk-MGJBC6DD.js → chunk-GOEXZ5QJ.js}

@@ -53,6 +53,7 @@ var COMMAND_LIST = [
     ]
   },
   { name: "doctor", module: "pushary-doctor", summary: "Verify your Pushary installation is working" },
+  { name: "disconnect", module: "pushary-disconnect", summary: "Turn off one agent (claude|codex|gemini|cursor)" },
   { name: "clean", module: "pushary-clean", summary: "Remove all Pushary configuration (--yes for non-interactive)" },
   { name: "mode", module: "pushary-mode", summary: "Switch approval mode (push_only, push_first, terminal_only)" },
   { name: "wait", module: "pushary-wait", summary: 'Show or set the "wait for your phone" ladder (pushary wait 45)' },

package/dist/{chunk-BLDDXHHA.js → chunk-GXIFADGD.js}

@@ -2,7 +2,7 @@ import {
   isModeStateDegraded,
   resolveAutoResolveOrigin,
   resolvePolicyAcross
-} from "./chunk-CCCJ6BPW.js";
+} from "./chunk-EXMUM226.js";
 import {
   evaluateScope,
   scopeChangeReason,

package/dist/{chunk-SEAHGHCE.js → chunk-HVZIHTOO.js}

@@ -139,6 +139,38 @@ var untrustedCodexHookEvents = (config, hooksJsonPath, command) => {
     return stored !== codexHookTrustHash(definition, command);
   }).map((definition) => definition.event);
 };
+var removeCodexMcpServer = (config) => {
+  const servers = asRecord(config.mcp_servers);
+  if (!servers?.pushary) return false;
+  delete servers.pushary;
+  if (Object.keys(servers).length === 0) delete config.mcp_servers;
+  return true;
+};
+var removeCodexHookTrust = (config, hooksJsonPath) => {
+  const state = asRecord(asRecord(config.hooks)?.state);
+  if (!state) return false;
+  let changed = false;
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const key = codexHookStateKey(hooksJsonPath, definition.event);
+    if (key in state) {
+      delete state[key];
+      changed = true;
+    }
+  }
+  if (changed && Object.keys(state).length === 0) {
+    const hooks = asRecord(config.hooks);
+    if (hooks) {
+      delete hooks.state;
+      if (Object.keys(hooks).length === 0) delete config.hooks;
+    }
+  }
+  return changed;
+};
+var removeCodexSettings = (config, hooksJsonPath) => {
+  const mcp = removeCodexMcpServer(config);
+  const trust = removeCodexHookTrust(config, hooksJsonPath);
+  return mcp || trust;
+};
 var addCodexHookTrust = (config, hooksJsonPath, command) => {
   const hooks = ensureRecord(config, "hooks");
   const state = ensureRecord(hooks, "state");
@@ -183,6 +215,7 @@ export {
   hasCodexHooks,
   missingCodexHookEvents,
   untrustedCodexHookEvents,
+  removeCodexSettings,
   addCodexHookTrust,
   claudeSettings,
   claudeJson,

package/dist/chunk-PWTKKQQI.js

@@ -0,0 +1,27 @@
+import {
+  quoteIfNeeded
+} from "./chunk-VT4IVERX.js";
+
+// src/hook-command.ts
+var SHELL = "/bin/sh -c";
+var LOCATE = 'B=$(command -v "$0") || exit 0; [ -f "$B" ] || exit 0; [ -x "$B" ] || exit 0';
+var NODE_PRESENT = "command -v node >/dev/null 2>&1 || exit 0";
+var RESOLVE = {
+  native: `${LOCATE}; exec "$B"`,
+  node: `${LOCATE}; ${NODE_PRESENT}; exec "$B"`
+};
+var guardHookCommand = (target, platform = process.platform) => {
+  if (target.kind === "node") {
+    const script = quoteIfNeeded(target.script);
+    return platform === "win32" ? `node ${script}` : `${SHELL} '[ -f "$0" ] || exit 0; command -v node >/dev/null 2>&1 || exit 0; exec node "$0"' ${script}`;
+  }
+  const path = quoteIfNeeded(target.path);
+  return platform === "win32" ? path : `${SHELL} '${RESOLVE[target.runtime]}' ${path}`;
+};
+var guardBinary = (path, platform) => guardHookCommand({ kind: "binary", path, runtime: "node" }, platform);
+var guardNodeScript = (script, platform) => guardHookCommand({ kind: "node", script }, platform);
+
+export {
+  guardBinary,
+  guardNodeScript
+};

package/dist/{chunk-J4KFVOCQ.js → chunk-SQOFGPNX.js}

@@ -1,6 +1,6 @@
 import {
   renderCommandHelp
-} from "./chunk-MGJBC6DD.js";
+} from "./chunk-GOEXZ5QJ.js";
 import {
   getPackageVersion
 } from "./chunk-DINDL2CF.js";

package/dist/{chunk-CCH775Y6.js → chunk-WEAQQSHQ.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-VT4IVERX.js";
 import {
   pusharyDir
-} from "./chunk-SEAHGHCE.js";
+} from "./chunk-HVZIHTOO.js";
 import {
   getMachineId
 } from "./chunk-RN3NOEJF.js";

package/dist/{chunk-ILB6UOAF.js → chunk-YKW6JCWI.js}

@@ -1,6 +1,6 @@
 import {
   pusharyDir
-} from "./chunk-SEAHGHCE.js";
+} from "./chunk-HVZIHTOO.js";
 import {
   readJsonSafe
 } from "./chunk-6MTNS63X.js";

package/dist/src/index.d.ts

@@ -39,7 +39,7 @@ interface ModeState {
     readonly scope?: ScopeContract | null;
     readonly degraded?: boolean;
 }
-declare const fetchModeState: (apiKey: string, sessionId?: string) => Promise<ModeState>;
+declare const fetchModeState: (apiKey: string, sessionId?: string, reuseWithinMs?: number) => Promise<ModeState>;
 declare const fetchModeOverride: (apiKey: string) => Promise<ApprovalMode | null>;
 
 interface UsageReport {

package/dist/src/index.js

@@ -1,9 +1,11 @@
 import {
   handlePreToolUse
-} from "../chunk-YR5TSPXB.js";
-import "../chunk-UKSQWTBH.js";
+} from "../chunk-GFM3STWO.js";
+import "../chunk-64PXDATC.js";
+import "../chunk-PWTKKQQI.js";
+import "../chunk-VT4IVERX.js";
 import "../chunk-NJ7JT26G.js";
-import "../chunk-BLDDXHHA.js";
+import "../chunk-GXIFADGD.js";
 import {
   askUser,
   cancelQuestion,
@@ -16,7 +18,7 @@ import {
   reportEvent,
   resolvePolicy,
   waitForAnswer
-} from "../chunk-CCCJ6BPW.js";
+} from "../chunk-EXMUM226.js";
 import "../chunk-RN3NOEJF.js";
 import "../chunk-BSZYIAZL.js";
 import "../chunk-SAF6HGAA.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.84.1",
+  "version": "0.85.0",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "keywords": [
     "pushary",
@@ -68,7 +68,8 @@
     "pushary-suggestions": "./dist/bin/pushary-suggestions.js",
     "pushary-upgrade": "./dist/bin/pushary-upgrade.js",
     "pushary-bell": "./dist/bin/pushary-bell.js",
-    "pushary-bell-hook": "./dist/bin/pushary-bell-hook.js"
+    "pushary-bell-hook": "./dist/bin/pushary-bell-hook.js",
+    "pushary-disconnect": "./dist/bin/pushary-disconnect.js"
   },
   "files": [
     "dist",