@pushary/agent-hooks 0.84.1 → 0.85.1

package/dist/chunk-EZPRY2ZY.js

@@ -0,0 +1,70 @@
+import {
+  parseVersion
+} from "./chunk-GM54KC62.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-MQMPG5X4.js → chunk-G3LXA2ZP.js}

@@ -65,6 +65,7 @@ var hookWaitDeadline = (startMs, policyWaitSeconds, agent, nowMs) => {
 };
 var hookWaitClamped = (startMs, policyWaitSeconds, agent, nowMs) => startMs + hookMaxWaitSeconds(agent) * 1e3 < nowMs + Math.max(policyWaitSeconds, 0) * 1e3;
 var effectiveWaitSeconds = (timeoutAction, policySeconds, agent) => timeoutAction === "wait" ? hookMaxWaitSeconds(agent) : policySeconds;
+var HOOK_BATCH_MAX_BYTES = 4 * 1024 * 1024;
 var REPO_KEY_MAX_LENGTH = 200;
 var isRepoKeyMatch = (ruleRepoKey, currentRepoKey) => {
   if (!ruleRepoKey) return true;
@@ -635,6 +636,88 @@ var SECRET_REDACTION_RULES = [
 var HIGH_ENTROPY_RULE = { pattern: /[A-Za-z0-9+/]{40,}={0,2}/g, replacement: "[redacted]" };
 var redactSecrets = (text) => SECRET_REDACTION_RULES.reduce((acc, rule) => acc.replace(rule.pattern, rule.replacement), text);
 var redactSecretsDeep = (text) => redactSecrets(text).replace(HIGH_ENTROPY_RULE.pattern, HIGH_ENTROPY_RULE.replacement);
+var AUTHORIZATION_CANONICAL_VERSION = "pushary.authz.v1";
+var AUTHORIZATION_CANONICAL_FIXTURE = [
+  {
+    subject: { toolName: "refund.create" },
+    canonical: `${AUTHORIZATION_CANONICAL_VERSION}
+action:13:refund.create
+target:0:
+actor:0:
+environment:0:
+externalId:0:`
+  },
+  {
+    subject: {
+      toolName: "refund.create",
+      toolTarget: "ord_991",
+      actor: "user:u_44",
+      environment: "production",
+      externalId: "cust_7",
+      parameters: { currency: "EUR", amount: 4800, expedited: true, rate: 1.5 }
+    },
+    canonical: `${AUTHORIZATION_CANONICAL_VERSION}
+action:13:refund.create
+target:7:ord_991
+actor:9:user:u_44
+environment:10:production
+externalId:6:cust_7
+p:13:amount=n:4800
+p:14:currency=s:EUR
+p:16:expedited=b:true
+p:10:rate=n:1.5`
+  },
+  {
+    // Parameter order is not part of the subject. The same facts written in a
+    // different order are the same authorization.
+    subject: { toolName: "refund.create", parameters: { b: 2, a: 1 } },
+    canonical: `${AUTHORIZATION_CANONICAL_VERSION}
+action:13:refund.create
+target:0:
+actor:0:
+environment:0:
+externalId:0:
+p:5:a=n:1
+p:5:b=n:2`
+  },
+  {
+    // An integral float is the same number as the integer.
+    subject: { toolName: "a", parameters: { n: 49 } },
+    canonical: `${AUTHORIZATION_CANONICAL_VERSION}
+action:1:a
+target:0:
+actor:0:
+environment:0:
+externalId:0:
+p:6:n=n:49`
+  },
+  {
+    // Delimiters inside a value cannot forge another subject.
+    subject: { toolName: "a", parameters: { "x\ny": "1" } },
+    canonical: `${AUTHORIZATION_CANONICAL_VERSION}
+action:1:a
+target:0:
+actor:0:
+environment:0:
+externalId:0:
+p:7:x
+y=s:1`
+  },
+  {
+    // Every finite number, including the ones another language would render
+    // differently. One runtime computes both sides of the comparison.
+    subject: { toolName: "a", parameters: { small: 1e-7, big: 1e21 } },
+    canonical: `${AUTHORIZATION_CANONICAL_VERSION}
+action:1:a
+target:0:
+actor:0:
+environment:0:
+externalId:0:
+p:11:big=n:1e+21
+p:12:small=n:1e-7`
+  }
+];
+var AUTHORIZATION_PERMIT_TTL_SECONDS = 60 * 60;
 var classifyDecisionRisk = (toolName, toolTarget) => {
   const parts = [toolName, toolTarget ?? ""];
   const matchesAny = (patterns) => parts.some((part) => patterns.some((re) => re.test(part)));
@@ -833,9 +916,127 @@ var isScopeContract = (value) => {
   const strings = (v) => Array.isArray(v) && v.every((x) => typeof x === "string");
   return strings(c.allowedPaths) && strings(c.offLimitsPaths) && typeof c.doneWhen === "string";
 };
+var autoApprove = (tool) => ({
+  tool,
+  timeoutSeconds: 0,
+  timeoutAction: "approve",
+  mode: "terminal_only",
+  pushFirstSeconds: 0
+});
+var resolveAutoResolveOrigin = (config, toolName, toolInput, cwd, repoKey, sessionId) => {
+  const args = toolInput ? policyArgForms(toolName, toolInput, cwd) : [];
+  const arg = args[0];
+  const match = selectGoverningRule(config.policies, toolName, args, repoKey, sessionId);
+  const governedBySpecificRule = match?.rank === "exact" || match?.rank === "prefix";
+  if (!governedBySpecificRule && toolName === "Bash" && typeof arg === "string" && isSafeReadOnlyCommand(arg)) {
+    return "safe_readonly";
+  }
+  return "policy_timeout";
+};
+var resolvePolicy = (config, toolName, modeOverride, toolInput, cwd, repoKey, sessionId) => {
+  const args = toolInput ? policyArgForms(toolName, toolInput, cwd) : [];
+  const arg = args[0];
+  const match = selectGoverningRule(config.policies, toolName, args, repoKey, sessionId);
+  let base = match?.policy ?? config.policies.find((p) => p.tool === "*") ?? {
+    tool: toolName,
+    timeoutSeconds: config.defaultTimeoutSeconds,
+    timeoutAction: config.defaultTimeoutAction,
+    mode: config.defaultMode ?? "push_first",
+    pushFirstSeconds: config.defaultPushFirstSeconds ?? 20
+  };
+  const governedBySpecificRule = match?.rank === "exact" || match?.rank === "prefix";
+  if (!governedBySpecificRule && toolName === "Bash" && typeof arg === "string" && isSafeReadOnlyCommand(arg)) {
+    base = autoApprove(base.tool);
+  }
+  const wouldAutoApprove = isAutoApprove(base);
+  if (!governedBySpecificRule && wouldAutoApprove && toolName === "Bash" && typeof arg === "string" && classifyDecisionRisk(toolName, arg) === "destructive") {
+    base = {
+      tool: base.tool,
+      timeoutSeconds: config.defaultTimeoutSeconds,
+      timeoutAction: "wait",
+      mode: "push_first",
+      pushFirstSeconds: config.defaultPushFirstSeconds ?? 20
+    };
+  }
+  const effectiveOverride = modeOverride ?? config.modeOverride;
+  if (effectiveOverride) {
+    return { ...base, mode: effectiveOverride };
+  }
+  return base;
+};
+var restraintRank = (policy) => {
+  if (isAutoDeny(policy)) return 4;
+  if (isAutoApprove(policy)) return 0;
+  if (policy.mode === "push_only") return 3;
+  return policy.mode === "terminal_only" || policy.mode === "notify_only" ? 1 : 2;
+};
+var strictestPolicy = (a, b) => restraintRank(b) > restraintRank(a) ? b : a;
+var resolvePolicyAcross = (config, toolName, modeOverride, toolInputs, cwd, repoKey, sessionId) => {
+  if (toolInputs.length === 0) return resolvePolicy(config, toolName, modeOverride, void 0, cwd, repoKey, sessionId);
+  return toolInputs.map((input) => resolvePolicy(config, toolName, modeOverride, input, cwd, repoKey, sessionId)).reduce(strictestPolicy);
+};
+var isModeStateDegraded = (state) => state?.degraded === true;
+var KILL_REASON = "Stopped by user, this agent was halted from Pushary";
+var strictestScopeVerdict = (scope, paths) => {
+  if (paths.length === 0) return evaluateScope(scope, void 0);
+  let worst = { outcome: "in_scope" };
+  for (const path of paths) {
+    const verdict = evaluateScope(scope, path);
+    if (verdict.outcome === "off_limits") return verdict;
+    if (verdict.outcome === "out_of_scope") worst = verdict;
+  }
+  return worst;
+};
+var survivesDegraded = (config, toolName, toolInputs, cwd, repoKey, sessionId) => toolInputs.length === 1 && resolveAutoResolveOrigin(config, toolName, toolInputs[0], cwd, repoKey, sessionId) === "safe_readonly";
+var resolveGate = (input) => {
+  const { modeState, config, toolName, toolInputs, cwd, repoKey, sessionId } = input;
+  if (modeState.kill) return { kind: "kill", reason: KILL_REASON };
+  const policy = resolvePolicyAcross(config, toolName, modeState.mode, toolInputs, cwd, repoKey, sessionId);
+  const verdict = verdictForPolicy(policy);
+  const autoApproves = verdict === "allow";
+  const autoDenies = verdict === "deny";
+  if (autoDenies) return { kind: "deny", policy, reason: `Denied by policy for ${policy.tool}` };
+  if (isModeStateDegraded(modeState)) {
+    if (autoApproves) {
+      return survivesDegraded(config, toolName, toolInputs, cwd, repoKey, sessionId) ? { kind: "allow", policy, source: "allowlist" } : { kind: "defer", policy };
+    }
+    return { kind: "gate", policy };
+  }
+  const scopeVerdict = modeState.scope ? strictestScopeVerdict(modeState.scope, input.scopePaths ?? []) : { outcome: "no_contract" };
+  if (autoApproves) {
+    if (!scopeRequiresHuman(scopeVerdict)) {
+      return {
+        kind: "allow",
+        policy,
+        source: toolInputs.length === 1 && resolveAutoResolveOrigin(config, toolName, toolInputs[0], cwd, repoKey, sessionId) === "safe_readonly" ? "allowlist" : "policy"
+      };
+    }
+  }
+  const scopeReason = scopeChangeReason(scopeVerdict);
+  return {
+    kind: "gate",
+    policy,
+    scopeReason,
+    scopePath: scopeReason && "path" in scopeVerdict ? scopeVerdict.path : void 0
+  };
+};
+var toPolicyVersion = (value) => typeof value === "string" || typeof value === "number" ? String(value) : null;
+var modeStateFromResponse = (data) => {
+  const mode = data.override?.mode;
+  return {
+    mode: isApprovalMode(mode) ? mode : null,
+    kill: data.kill === true,
+    policyVersion: toPolicyVersion(data.policyVersion),
+    relayUrl: typeof data.relayUrl === "string" && data.relayUrl.length > 0 ? data.relayUrl : null,
+    trainingConsent: data.trainingConsent === true,
+    // Validated rather than cast: a malformed contract must read as no contract,
+    // never as one that silently matches nothing.
+    scope: isScopeContract(data.scope) ? data.scope : null,
+    degraded: false
+  };
+};
 
 export {
-  isApprovalMode,
   parseAgentQuestionAnswers,
   normalizeInstallSource,
   HOOK_BUDGETS,
@@ -844,21 +1045,17 @@ export {
   effectiveWaitSeconds,
   normalizeRepoRemote,
   localRepoKey,
-  policyArgForms,
   isSafeReadOnlyCommand,
   isAutoApprove,
-  isAutoDeny,
-  verdictForPolicy,
-  selectGoverningRule,
   isValidApiKey,
   ACTION_BODY_MAX,
   DECISION_LINE_MAX,
   redactSecrets,
   redactSecretsDeep,
-  classifyDecisionRisk,
   buildDecisionEpisodeFeatures,
-  evaluateScope,
-  scopeRequiresHuman,
-  scopeChangeReason,
-  isScopeContract
+  resolveAutoResolveOrigin,
+  resolvePolicy,
+  KILL_REASON,
+  resolveGate,
+  modeStateFromResponse
 };

package/dist/chunk-GM54KC62.js

@@ -0,0 +1,187 @@
+import {
+  guardBinary
+} from "./chunk-HSGEEBBL.js";
+import {
+  HOOK_BUDGETS
+} from "./chunk-G3LXA2ZP.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, delivery: "approval", since: ESTABLISHED },
+  { event: "PostToolUse", binary: "pushary-post-hook", matcher: MIRRORED_TOOLS, timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Stop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "UserPromptSubmit", binary: "pushary-prompt-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Notification", binary: "pushary-notification-hook", matcher: "permission_prompt|idle_prompt|agent_needs_input|agent_completed", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionStart", binary: "pushary-session-start-hook", matcher: "startup|resume|clear", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionEnd", binary: "pushary-session-end-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "StopFailure", binary: "pushary-stopfailure-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "PermissionRequest", binary: "pushary-permission-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: ESTABLISHED },
+  { event: "PermissionDenied", binary: "pushary-permission-denied-hook", timeout: 60, delivery: "telemetry", 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, delivery: "telemetry", since: OBSERVED },
+  { event: "SubagentStop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PreCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PostCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "TeammateIdle", binary: "pushary-notification-hook", timeout: 10, delivery: "telemetry", 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-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-HSGEEBBL.js

@@ -0,0 +1,37 @@
+import {
+  quoteIfNeeded
+} from "./chunk-VT4IVERX.js";
+
+// src/hook-command.ts
+var HOOK_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 HOOK_GUARD_SCRIPTS = {
+  native_binary: `${LOCATE}; exec "$B"`,
+  node_binary: `${LOCATE}; ${NODE_PRESENT}; exec "$B"`,
+  node_script: `[ -f "$0" ] || exit 0; ${NODE_PRESENT}; exec node "$0"`
+};
+var BINARY_GUARDS = {
+  native: "native_binary",
+  node: "node_binary"
+};
+var guardKindOf = (target) => {
+  switch (target.kind) {
+    case "node":
+      return "node_script";
+    case "binary":
+      return BINARY_GUARDS[target.runtime];
+  }
+};
+var guardHookCommand = (target, platform = process.platform) => {
+  const path = quoteIfNeeded(target.kind === "node" ? target.script : target.path);
+  if (platform === "win32") return target.kind === "node" ? `node ${path}` : path;
+  return `${HOOK_SHELL} '${HOOK_GUARD_SCRIPTS[guardKindOf(target)]}' ${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-UXWEE3QI.js → chunk-IGV4KL7B.js}

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

package/dist/{chunk-GCKAWHFP.js → chunk-JDQY47OW.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-2UMNXADU.js";
 import {
   redactSecrets
-} from "./chunk-MQMPG5X4.js";
+} from "./chunk-G3LXA2ZP.js";
 
 // src/crypto.ts
 import nacl from "tweetnacl";

package/dist/{chunk-7PZPJSWI.js → chunk-KTKIZEFT.js}

@@ -1,6 +1,6 @@
 import {
   readConfigFileKey
-} from "./chunk-K7CSRGKZ.js";
+} from "./chunk-CIVG746V.js";
 
 // src/bell/fleet.ts
 import { closeSync, constants, futimesSync, lstatSync, mkdirSync, openSync, readdirSync, unlinkSync } from "fs";

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

@@ -1,15 +1,14 @@
 import {
   PRETOOLUSE_HANDLED_TOOLS
-} from "./chunk-UKSQWTBH.js";
+} from "./chunk-GM54KC62.js";
 import {
   isGatingMoment,
   recordKeylessMoment
-} from "./chunk-NJ7JT26G.js";
+} from "./chunk-VGADRFG6.js";
 import {
   denyReasonFrom,
-  isDeferAnswer,
-  resolveGate
-} from "./chunk-BLDDXHHA.js";
+  isDeferAnswer
+} from "./chunk-YHG74UFF.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -29,7 +28,7 @@ import {
   sendNotification,
   throttlePass,
   waitForAnswer
-} from "./chunk-CCCJ6BPW.js";
+} from "./chunk-Y7BALRVB.js";
 import {
   getMachineId
 } from "./chunk-RN3NOEJF.js";
@@ -42,8 +41,9 @@ import {
   effectiveWaitSeconds,
   hookWaitClamped,
   hookWaitDeadline,
-  parseAgentQuestionAnswers
-} from "./chunk-MQMPG5X4.js";
+  parseAgentQuestionAnswers,
+  resolveGate
+} from "./chunk-G3LXA2ZP.js";
 
 // src/decision-episode.ts
 var EPISODE_PATH = "/api/agent/decision-episode";
@@ -513,14 +513,16 @@ var handlePreToolUse = async (input) => {
     if (input.tool_name === "AskUserQuestion") {
       return handleAskUserQuestion(apiKey, input);
     }
+    if (verdict.kind === "deny") return deny(verdict.reason);
     if (shouldDeferToNativeMode(input.permission_mode, input.tool_name)) {
       return void 0;
     }
     switch (verdict.kind) {
       case "allow":
         return allow();
-      case "deny":
-        return deny(verdict.reason);
+      // No `deny` case: it is handled above the defer, and the compiler enforces
+      // that it stays there. Restoring one here would type-error as unreachable.
+      //
       // State we could not establish, with an auto-approve on the table. No
       // opinion, so Claude Code's own flow runs as if the hook were absent.
       case "defer":

package/dist/{chunk-DOXSWT4Q.js → chunk-OZKRF7MS.js}

@@ -1,16 +1,16 @@
 import {
   HOOK_BUDGETS
-} from "./chunk-MQMPG5X4.js";
+} from "./chunk-G3LXA2ZP.js";
 
 // src/gemini-config.ts
 var GEMINI_HOOK_BINARY = "pushary-gemini-hook";
 var GEMINI_MCP_URL = "https://pushary.com/api/mcp/mcp";
 var GEMINI_HOOK_EVENTS = [
-  { event: "BeforeTool", matcher: "run_shell_command|write_file|replace", timeoutMs: HOOK_BUDGETS.gemini.budgetSeconds * 1e3 },
-  { event: "AfterTool", matcher: "run_shell_command|write_file|replace", timeoutMs: 1e4 },
-  { event: "BeforeAgent", timeoutMs: 1e4 },
-  { event: "SessionStart", timeoutMs: 1e4 },
-  { event: "SessionEnd", timeoutMs: 1e4 }
+  { event: "BeforeTool", matcher: "run_shell_command|write_file|replace", delivery: "approval", timeoutMs: HOOK_BUDGETS.gemini.budgetSeconds * 1e3 },
+  { event: "AfterTool", matcher: "run_shell_command|write_file|replace", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "BeforeAgent", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "SessionStart", delivery: "telemetry", timeoutMs: 1e4 },
+  { event: "SessionEnd", delivery: "telemetry", timeoutMs: 1e4 }
 ];
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 var ensureRecord = (target, key) => {