@pushary/agent-hooks 0.95.8 → 0.98.0

package/dist/bin/pushary-upgrade.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import {
   reapplyAllAgents
-} from "../chunk-R6LBGKWQ.js";
-import "../chunk-4DUEIUUO.js";
+} from "../chunk-JQU6PMH4.js";
+import "../chunk-K6CH5NVW.js";
 import {
   waitForMachineReadiness
-} from "../chunk-RE25RJ5A.js";
-import "../chunk-ATKGKAP6.js";
+} from "../chunk-B35OCFXH.js";
+import "../chunk-QXIF6R4P.js";
 import {
   detectProviderLiveCapabilities,
   hasSpawnProvider,
   resolveControlPolicy
-} from "../chunk-54W7ELDQ.js";
-import "../chunk-QD73WATQ.js";
+} from "../chunk-TZHDKRMG.js";
+import "../chunk-6LRGZJFB.js";
 import {
   daemonHasRemoteProof,
   daemonServiceManagerAvailable,
@@ -23,26 +23,23 @@ import {
   replaceDaemonService,
   stopDaemonService,
   waitForDaemonRemoteProof
-} from "../chunk-I7LKI4WO.js";
-import "../chunk-QV266EGS.js";
-import "../chunk-3AJIK5AO.js";
+} from "../chunk-DOD3A6EU.js";
+import "../chunk-HFQ7WSHZ.js";
 import {
   needsShell
 } from "../chunk-XHKBHWLX.js";
-import {
-  execNpm,
-  npmErrorMessage,
-  resolveGlobalBinary
-} from "../chunk-L4ZCFMWW.js";
-import "../chunk-XUTSZYYJ.js";
-import "../chunk-E47WV7BJ.js";
+import "../chunk-OPR2BPD4.js";
+import "../chunk-WU6LSXJ6.js";
 import {
   claudeJson,
   codexConfigToml,
   cursorPluginDir,
+  execNpm,
   geminiSettings,
+  npmErrorMessage,
+  resolveGlobalBinary,
   vscodePluginDir
-} from "../chunk-NOVA7KZ2.js";
+} from "../chunk-XL3RKJYQ.js";
 import {
   exitOnHelpFlag
 } from "../chunk-GOQHN2UH.js";
@@ -52,13 +49,13 @@ import {
 } from "../chunk-DINDL2CF.js";
 import {
   readControlMode
-} from "../chunk-VMQU7YEJ.js";
+} from "../chunk-SJLGOVC6.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-L7NOG547.js";
+import "../chunk-VZD2GEKB.js";
 import {
   getApiKey
 } from "../chunk-2UMNXADU.js";
-import "../chunk-MC5WUOJJ.js";
+import "../chunk-OUAE3GKO.js";
 
 // bin/pushary-upgrade.ts
 import { existsSync } from "fs";

package/dist/bin/pushary-wait.js

@@ -4,8 +4,8 @@ import {
 } from "../chunk-CVWG2N3Y.js";
 import {
   exitOnFailedResponse
-} from "../chunk-SDNTRS76.js";
-import "../chunk-BQL7UDIB.js";
+} from "../chunk-6C6MS57P.js";
+import "../chunk-3RVCQDC4.js";
 import {
   createIo
 } from "../chunk-5RUIFDTP.js";
@@ -28,7 +28,7 @@ import {
   getApiKey,
   getBaseUrl
 } from "../chunk-2UMNXADU.js";
-import "../chunk-MC5WUOJJ.js";
+import "../chunk-OUAE3GKO.js";
 
 // bin/pushary-wait.ts
 exitOnHelpFlag("wait");

package/dist/{chunk-GOPIMNVC.js → chunk-2GLOHBYB.js}

@@ -1,6 +1,6 @@
 import {
   guardBinary
-} from "./chunk-3AJIK5AO.js";
+} from "./chunk-XL3RKJYQ.js";
 
 // src/bell/install.ts
 import { join } from "path";

package/dist/{chunk-BQL7UDIB.js → chunk-3RVCQDC4.js}

@@ -13,7 +13,7 @@ import {
 import {
   isValidApiKey,
   normalizeKeyScope
-} from "./chunk-MC5WUOJJ.js";
+} from "./chunk-OUAE3GKO.js";
 
 // src/session.ts
 var samePusharyAccount = (left, right) => left.kind === "ok" && right.kind === "ok" && left.identity.workspaceId !== "" && left.identity.workspaceId === right.identity.workspaceId && left.identity.siteId === right.identity.siteId;

package/dist/chunk-53QCTSWY.js

@@ -0,0 +1,202 @@
+import {
+  canonicalGateInputs
+} from "./chunk-A76GNRIK.js";
+import {
+  canonicalJson
+} from "./chunk-XL3RKJYQ.js";
+import {
+  writeFileAtomic
+} from "./chunk-VZD2GEKB.js";
+import {
+  BLOCKED_ACTION_GRANT_TTL_SECONDS,
+  blockedActionIdentity,
+  shouldDeferToNativeMode
+} from "./chunk-OUAE3GKO.js";
+
+// src/native-defer.ts
+var nativeDeferOptions = () => {
+  const respect = process.env.PUSHARY_RESPECT_PERMISSION_MODE;
+  const bypass = process.env.PUSHARY_DEFER_BYPASS;
+  return {
+    respectPermissionMode: !(respect === "0" || respect === "false"),
+    deferBypass: bypass === "1" || bypass === "true"
+  };
+};
+var defersToNativeMode = (permissionMode, toolName) => shouldDeferToNativeMode(permissionMode, toolName, nativeDeferOptions());
+
+// src/codex-call-decision.ts
+import { createHash } from "crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "fs";
+import { tmpdir, userInfo } from "os";
+import { join } from "path";
+var CODEX_DECISION_TTL_MS = 60 * 1e3;
+var userScope = () => {
+  try {
+    const info = userInfo();
+    const id = typeof info.uid === "number" && info.uid >= 0 ? String(info.uid) : info.username;
+    return id.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || "default";
+  } catch {
+    return "default";
+  }
+};
+var decisionDir = () => join(tmpdir(), `pushary-codex-decisions-${userScope()}`);
+var decisionFile = (key) => join(decisionDir(), key);
+var PRESENTATION_ONLY_INPUT_KEYS = ["description"];
+var identifyingToolInput = (toolInput) => {
+  if (!toolInput) return {};
+  const identifying = {};
+  for (const [key, value] of Object.entries(toolInput)) {
+    if (PRESENTATION_ONLY_INPUT_KEYS.includes(key)) continue;
+    identifying[key] = value;
+  }
+  return identifying;
+};
+var codexCallKey = (identity) => {
+  if (!identity.sessionId || !identity.turnId || !identity.toolName) return null;
+  const material = canonicalJson([
+    identity.sessionId,
+    identity.turnId,
+    identity.toolName,
+    identifyingToolInput(identity.toolInput)
+  ]);
+  return createHash("sha256").update(material, "utf-8").digest("hex").slice(0, 32);
+};
+var parseDecision = (raw) => {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.kind === "approved") {
+      return typeof parsed.toolUseId === "string" && parsed.toolUseId ? { kind: "approved", toolUseId: parsed.toolUseId } : null;
+    }
+    if (parsed.kind === "handled") return { kind: "handled" };
+    if (parsed.kind === "denied") {
+      return { kind: "denied", reason: typeof parsed.reason === "string" ? parsed.reason : "" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var sweepExpired = (dir, nowMs) => {
+  try {
+    for (const name of readdirSync(dir)) {
+      const path = join(dir, name);
+      try {
+        if (nowMs - statSync(path).mtimeMs >= CODEX_DECISION_TTL_MS) rmSync(path, { force: true });
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return;
+  }
+};
+var recordCodexCallDecision = (key, decision) => {
+  if (!key) return;
+  try {
+    const dir = decisionDir();
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true, mode: 448 });
+    else sweepExpired(dir, Date.now());
+    writeFileSync(decisionFile(key), JSON.stringify(decision), { encoding: "utf-8", mode: 384 });
+  } catch {
+    return;
+  }
+};
+var consumeCodexCallDecision = (key) => {
+  if (!key) return null;
+  const path = decisionFile(key);
+  try {
+    const fresh = Date.now() - statSync(path).mtimeMs < CODEX_DECISION_TTL_MS;
+    const raw = readFileSync(path, "utf-8");
+    rmSync(path, { force: true });
+    return fresh ? parseDecision(raw) : null;
+  } catch {
+    return null;
+  }
+};
+
+// src/blocked-action-hint.ts
+import { createHash as createHash2 } from "crypto";
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync as readdirSync2, rmSync as rmSync2, statSync as statSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+var BLOCKED_ACTION_HINT_TTL_MS = BLOCKED_ACTION_GRANT_TTL_SECONDS * 1e3;
+var FINGERPRINT = /^[0-9a-f]{64}$/;
+var isFingerprint = (value) => typeof value === "string" && FINGERPRINT.test(value);
+var blockedActionSubject = (source, sessionId, toolName, toolInput, cwd) => {
+  if (source !== "claude") return { source, sessionId, toolName, toolInput };
+  return cwd ? { source, sessionId, cwd, toolName, toolInput } : null;
+};
+var blockedActionFingerprint = ({ source = "claude", sessionId, toolName, toolInput, cwd }) => {
+  if (!sessionId || !toolInput) return null;
+  const canonical = canonicalGateInputs(source, toolName, [toolInput], cwd);
+  if (!canonical || canonical.toolInputs.length !== 1) return null;
+  const [canonicalInput] = canonical.toolInputs;
+  if (!canonicalInput) return null;
+  const subject = blockedActionSubject(source, sessionId, canonical.toolName, canonicalInput, cwd);
+  return subject ? createHash2("sha256").update(blockedActionIdentity(subject), "utf8").digest("hex") : null;
+};
+var hintDir = () => join2(tmpdir2(), `pushary-blocked-action-hints-${userScope()}`);
+var hintFile = (fingerprint) => join2(hintDir(), fingerprint);
+var isExpired = (mtimeMs, nowMs) => nowMs - mtimeMs >= BLOCKED_ACTION_HINT_TTL_MS;
+var sweepExpired2 = (dir, nowMs) => {
+  try {
+    for (const name of readdirSync2(dir)) {
+      const path = join2(dir, name);
+      try {
+        if (isExpired(statSync2(path).mtimeMs, nowMs)) rmSync2(path, { force: true });
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return;
+  }
+};
+var recordBlockedActionHint = (fingerprint) => {
+  if (!isFingerprint(fingerprint)) return false;
+  try {
+    const dir = hintDir();
+    if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true, mode: 448 });
+    else sweepExpired2(dir, Date.now());
+    writeFileAtomic(hintFile(fingerprint), JSON.stringify({ fingerprint }), 384);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var hasBlockedActionHint = (fingerprint) => {
+  if (!isFingerprint(fingerprint)) return false;
+  const path = hintFile(fingerprint);
+  try {
+    const stat = statSync2(path);
+    if (!stat.isFile()) return false;
+    if (isExpired(stat.mtimeMs, Date.now())) {
+      rmSync2(path, { force: true });
+      return false;
+    }
+    const parsed = JSON.parse(readFileSync2(path, "utf-8"));
+    return parsed?.fingerprint === fingerprint;
+  } catch {
+    return false;
+  }
+};
+var forgetBlockedActionHint = (fingerprint) => {
+  if (!isFingerprint(fingerprint)) return;
+  try {
+    rmSync2(hintFile(fingerprint), { force: true });
+  } catch {
+    return;
+  }
+};
+
+export {
+  defersToNativeMode,
+  userScope,
+  codexCallKey,
+  recordCodexCallDecision,
+  consumeCodexCallDecision,
+  blockedActionFingerprint,
+  recordBlockedActionHint,
+  hasBlockedActionHint,
+  forgetBlockedActionHint
+};

package/dist/{chunk-3YFJGKJQ.js → chunk-5B5QV3KC.js}

@@ -3,19 +3,19 @@ import {
   loadPin,
   savePin,
   verifyRecipients
-} from "./chunk-EMGGUO2Q.js";
+} from "./chunk-OBYC6SN4.js";
 import {
   hookOwnerOf
-} from "./chunk-R3OZ5ISU.js";
+} from "./chunk-W2MG2P46.js";
 import {
   ensureDaemonRunning
-} from "./chunk-I7LKI4WO.js";
+} from "./chunk-DOD3A6EU.js";
 import {
   buildTranscriptRecords,
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-SKPXQRKN.js";
+} from "./chunk-XPPXOKIG.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
@@ -23,17 +23,17 @@ import {
 import {
   transcriptEnvironmentPreference,
   transcriptsEnabled
-} from "./chunk-VERXHIQF.js";
+} from "./chunk-NQGYPTJQ.js";
 import {
   codexHome,
   pusharyDir
-} from "./chunk-NOVA7KZ2.js";
+} from "./chunk-XL3RKJYQ.js";
 import {
   readTranscriptPreference
-} from "./chunk-VMQU7YEJ.js";
+} from "./chunk-SJLGOVC6.js";
 import {
   writeJsonAtomic
-} from "./chunk-L7NOG547.js";
+} from "./chunk-VZD2GEKB.js";
 import {
   getApiKey,
   getBaseUrl

package/dist/{chunk-FRXZMCVA.js → chunk-5KLAETSU.js}

@@ -3,7 +3,7 @@ import {
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-SKPXQRKN.js";
+} from "./chunk-XPPXOKIG.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords

package/dist/{chunk-SDNTRS76.js → chunk-6C6MS57P.js}

@@ -1,7 +1,7 @@
 import {
   describeKeyCheck,
   keyCheckFromResponse
-} from "./chunk-BQL7UDIB.js";
+} from "./chunk-3RVCQDC4.js";
 import {
   createIo
 } from "./chunk-5RUIFDTP.js";

package/dist/{chunk-A22VQ5ZL.js → chunk-6CYB77VD.js}

@@ -1,10 +1,14 @@
 import {
-  defersToNativeMode
-} from "./chunk-VDI645ZX.js";
+  blockedActionFingerprint,
+  defersToNativeMode,
+  forgetBlockedActionHint,
+  hasBlockedActionHint,
+  recordBlockedActionHint
+} from "./chunk-53QCTSWY.js";
 import {
   isGatingMoment,
   recordKeylessMoment
-} from "./chunk-5GKNAQTG.js";
+} from "./chunk-XOOWC62T.js";
 import {
   denyReasonFrom,
   isDeferAnswer
@@ -20,7 +24,7 @@ import {
   reportEvent,
   settleQuestionsForToolUse,
   throttlePass
-} from "./chunk-HUGIKB5O.js";
+} from "./chunk-YJDRHQLG.js";
 import {
   UNNAMED_ACTION,
   deriveAction,
@@ -30,37 +34,46 @@ import {
   describeToolCall,
   permissionDeniedAction,
   scopePathFor
-} from "./chunk-Z4JVEL7R.js";
+} from "./chunk-A76GNRIK.js";
 import {
   DECISION_STOP_REASON,
   askUser,
+  cancelQuestion,
+  claimBlockedAction,
   isDecisionStopped,
   isLocalQuestionHandoff,
+  pollForAnswer,
+  requestGate,
   sendNotification,
   waitForQuestion
-} from "./chunk-XS33QBJA.js";
+} from "./chunk-LGXUGYUH.js";
 import {
   getMachineId
-} from "./chunk-E47WV7BJ.js";
+} from "./chunk-WU6LSXJ6.js";
 import {
   getApiKey,
   getBaseUrl
 } from "./chunk-2UMNXADU.js";
 import {
+  GATE_BLOCK_REASON_MAX_LENGTH,
+  GATE_WIRE,
   buildDecisionEpisodeFeatures,
+  claudePermissionDeniedOutput,
   claudePermissionRequestOutput,
   claudePreToolUseOutput,
   effectiveWaitSeconds,
+  hookHoldWindowMs,
   hookWaitClamped,
   hookWaitDeadline,
   hookWritePath,
+  isBlockedActionRequest,
   isPermissionRequestOwnedByPreToolUse,
   isPusharyOwnTool,
   parseAgentQuestionAnswers,
   parseAgentQuestions,
   resolveGate,
   stoppedOutput
-} from "./chunk-MC5WUOJJ.js";
+} from "./chunk-OUAE3GKO.js";
 
 // src/decision-episode.ts
 var EPISODE_PATH = "/api/agent/decision-episode";
@@ -89,7 +102,7 @@ import { basename, join } from "path";
 import { tmpdir } from "os";
 import { existsSync, writeFileSync } from "fs";
 var START_MS = Date.now();
-var allow = () => claudePreToolUseOutput("allow");
+var allow = (reason) => claudePreToolUseOutput("allow", reason);
 var deny = (reason) => claudePreToolUseOutput("deny", reason);
 var allowWithInput = (updatedInput) => claudePreToolUseOutput("allow", void 0, updatedInput);
 var ask = (reason) => claudePreToolUseOutput("ask", reason);
@@ -449,6 +462,45 @@ var claudeGateInput = (modeState, config, input) => {
     sessionId: input.session_id
   };
 };
+var BLOCKED_ACTION_GATE_TIMEOUT_MS = 15e3;
+var BLOCKED_ACTION_CLAIM_TIMEOUT_MS = 4e3;
+var BLOCKED_ACTION_ALLOW_REASON = "Approved from Pushary after auto mode blocked it";
+var blockReasonOf = (reason) => typeof reason === "string" ? reason.trim().slice(0, GATE_BLOCK_REASON_MAX_LENGTH).trim() || void 0 : void 0;
+var blockedActionFingerprintFor = (input) => blockedActionFingerprint({
+  sessionId: input.session_id,
+  toolName: input.tool_name,
+  toolInput: input.tool_input,
+  cwd: input.cwd
+});
+var blockedActionGateRequest = (input, event) => ({
+  v: GATE_WIRE,
+  source: "claude",
+  event,
+  toolName: input.tool_name,
+  toolInputs: [input.tool_input ?? {}],
+  sessionId: input.session_id,
+  toolUseId: input.tool_use_id,
+  machineId: getMachineId(),
+  cwd: input.cwd,
+  repoKey: repoKeyFor(input.cwd),
+  permissionMode: input.permission_mode,
+  ...event === "PermissionDenied" ? { createDecision: true, localSurfaceAvailable: false, blockReason: blockReasonOf(input.reason) } : {}
+});
+var claimedBlockedActionRetry = async (apiKey, input) => {
+  const fingerprint = blockedActionFingerprintFor(input);
+  if (!fingerprint || !hasBlockedActionHint(fingerprint)) return false;
+  try {
+    const granted = await claimBlockedAction(
+      apiKey,
+      blockedActionGateRequest(input, "PreToolUse"),
+      BLOCKED_ACTION_CLAIM_TIMEOUT_MS
+    );
+    if (granted !== null) forgetBlockedActionHint(fingerprint);
+    return granted === true;
+  } catch {
+    return false;
+  }
+};
 var handlePreToolUse = async (input) => {
   if (isPusharyOwnTool(input.tool_name)) return void 0;
   let apiKey;
@@ -469,6 +521,7 @@ var handlePreToolUse = async (input) => {
     if (input.tool_name === "ExitPlanMode") {
       return handleExitPlanMode(apiKey, input);
     }
+    if (await claimedBlockedActionRetry(apiKey, input)) return allow(BLOCKED_ACTION_ALLOW_REASON);
     if (shouldDeferToNativeMode(input.permission_mode, input.tool_name)) {
       return void 0;
     }
@@ -531,12 +584,6 @@ var handlePermissionRequest = async (input) => {
     return void 0;
   }
 };
-var PERMISSION_DENIED_WINDOW_MS = 5 * 60 * 1e3;
-var PERMISSION_DENIED_WAIT_SECONDS = 25;
-var automodeRetryEnabled = () => {
-  const flag = process.env.PUSHARY_AUTOMODE_RETRY;
-  return flag === "1" || flag === "true";
-};
 var reportPermissionDenied = (input) => reportEvent({
   event: "permission_denied",
   occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -548,9 +595,48 @@ var reportPermissionDenied = (input) => reportEvent({
   // Side report, not a command carrier. Without timeoutMs this takes the phone's
   // queued instruction and acknowledges it delivered, and this hook can print
   // only {retry}. 4s rather than the Notification path's 2.5s because
-  // PermissionDenied is given a 60s budget, not 10s.
+  // PermissionDenied holds the agent for the full hook budget, not 10s.
 }, { timeoutMs: 4e3 }).catch(() => void 0);
-var handlePermissionDenied = async (input) => {
+var isAffirmativeAnswer = (answer) => answer.answered && !isDecisionStopped(answer) && answer.value === "yes";
+var PERMISSION_DENIED_NOTICE_WINDOW_MS = 5 * 60 * 1e3;
+var blockedActionHoldEndsAt = (holdBudgetSeconds) => START_MS + hookHoldWindowMs("claude", holdBudgetSeconds);
+var notifyPermissionDenied = async (apiKey, input) => {
+  const sessionKey = input.session_id || DEFAULT_SESSION;
+  if (!throttlePass(`permdenied:${sessionKey}:${input.tool_name}`, PERMISSION_DENIED_NOTICE_WINDOW_MS)) return;
+  const mode = await fetchModeState(apiKey, input.session_id).catch(() => null);
+  if (mode?.kill || mode?.mode === "terminal_only") return;
+  const projectName = basename(input.cwd ?? process.cwd());
+  await sendNotification(apiKey, {
+    title: `Auto mode blocked ${input.tool_name}`,
+    body: `Your agent was denied ${input.tool_name} in ${projectName}.`,
+    agentName: `Claude Code - ${projectName}`,
+    sessionId: input.session_id
+  }, 4e3).catch(() => void 0);
+};
+var isRetryOutput = (output) => {
+  if (!output) return false;
+  try {
+    const parsed = JSON.parse(output);
+    return parsed?.hookSpecificOutput?.hookEventName === "PermissionDenied" && parsed.hookSpecificOutput.retry === true;
+  } catch {
+    return false;
+  }
+};
+var retryOnce = (fingerprint) => recordBlockedActionHint(fingerprint) ? claudePermissionDeniedOutput("allow") : void 0;
+var askAboutBlockedAction = async (apiKey, input, fingerprint, holdEndsAt) => {
+  const reply = await requestGate(apiKey, blockedActionGateRequest(input, "PermissionDenied"), BLOCKED_ACTION_GATE_TIMEOUT_MS);
+  if (!reply) return void 0;
+  if (reply.kind === "no_opinion") return isRetryOutput(reply.output) ? retryOnce(fingerprint) : void 0;
+  if (reply.kind !== "ask" || !reply.correlationId || reply.deadlineSeconds === void 0) return void 0;
+  if (reply.noDevices) {
+    await cancelQuestion(apiKey, reply.correlationId, AbortSignal.timeout(4e3)).catch(() => void 0);
+    return void 0;
+  }
+  const deadline = Math.min(hookWaitDeadline(START_MS, reply.deadlineSeconds, "claude", Date.now()), holdEndsAt);
+  const answer = await pollForAnswer(apiKey, reply.correlationId, deadline);
+  return isAffirmativeAnswer(answer) ? retryOnce(fingerprint) : void 0;
+};
+var handlePermissionDenied = async (input, holdBudgetSeconds) => {
   await reportPermissionDenied(input);
   if (isPusharyOwnTool(input.tool_name)) return void 0;
   let apiKey;
@@ -560,46 +646,16 @@ var handlePermissionDenied = async (input) => {
     return void 0;
   }
   try {
-    const projectName = basename(input.cwd ?? process.cwd());
-    const sessionKey = input.session_id || DEFAULT_SESSION;
-    await settleQuestionsForToolUse(sessionKey, input.tool_use_id);
-    if (!throttlePass(`permdenied:${sessionKey}:${input.tool_name}`, PERMISSION_DENIED_WINDOW_MS)) return void 0;
-    const mode = await fetchModeState(apiKey, input.session_id).catch(() => null);
-    if (mode?.kill || mode?.mode === "terminal_only") return void 0;
-    if (!automodeRetryEnabled()) {
-      await sendNotification(apiKey, {
-        title: `Auto-mode blocked ${input.tool_name}`,
-        body: `Your agent was denied ${input.tool_name} in ${projectName}.`,
-        agentName: `Claude Code - ${projectName}`,
-        sessionId: input.session_id
-      }, 4e3).catch(() => {
-      });
+    await settleQuestionsForToolUse(input.session_id || DEFAULT_SESSION, input.tool_use_id);
+    if (!isBlockedActionRequest({ source: "claude", event: "PermissionDenied", toolName: input.tool_name })) return void 0;
+    const fingerprint = blockedActionFingerprintFor(input);
+    if (!fingerprint) return void 0;
+    const holdEndsAt = blockedActionHoldEndsAt(holdBudgetSeconds);
+    if (holdEndsAt - Date.now() <= BLOCKED_ACTION_GATE_TIMEOUT_MS) {
+      await notifyPermissionDenied(apiKey, input);
       return void 0;
     }
-    let result;
-    try {
-      result = await askUser(apiKey, {
-        question: `Auto-mode blocked ${input.tool_name} in ${projectName}. Let the agent retry it?`,
-        type: "confirm",
-        context: "Your agent hit a permission wall in auto mode",
-        agentName: `Claude Code - ${projectName}`,
-        sessionId: input.session_id,
-        machineId: getMachineId(),
-        toolName: input.tool_name,
-        // Suffixed because the PreToolUse gate may already have asked about this
-        // same tool call. Without it, the retry prompt would collide with that
-        // decision and hand back its answer instead of asking a new question.
-        toolUseId: input.tool_use_id ? `${input.tool_use_id}#retry` : void 0
-      });
-    } catch {
-      return void 0;
-    }
-    const deadline = hookWaitDeadline(START_MS, PERMISSION_DENIED_WAIT_SECONDS, "claude", Date.now());
-    const answer = await waitForQuestion(apiKey, result, deadline);
-    if (answer.answered && answer.value === "yes") {
-      return { hookSpecificOutput: { hookEventName: "PermissionDenied", retry: true } };
-    }
-    return void 0;
+    return await askAboutBlockedAction(apiKey, input, fingerprint, holdEndsAt);
   } catch {
     return void 0;
   }