@pushary/agent-hooks 1.9.65 → 1.9.67

package/dist/{chunk-XZCJC3QO.js → chunk-B3V2WOJX.js}

@@ -4,19 +4,24 @@ import {
   outcomeOfFailedAsk,
   reportMachineDenial,
   storedWaitDeadline
-} from "./chunk-RRHHWYPX.js";
+} from "./chunk-6H4E5UBA.js";
 import {
   isGatingMoment,
   recordKeylessMoment
-} from "./chunk-XJIIU36L.js";
+} from "./chunk-7YJSDXLM.js";
+import {
+  isAdmitted,
+  readAdmissionRules
+} from "./chunk-EQR6JSFE.js";
 import {
   isDeferAnswer,
   oncePerSession
-} from "./chunk-UMTMFDL2.js";
+} from "./chunk-CPLQ5OHX.js";
 import {
   activeHookSource,
-  activeIdentity
-} from "./chunk-WY6YAMZW.js";
+  activeIdentity,
+  namedSource
+} from "./chunk-ICQCQAUO.js";
 import {
   DEFAULT_SESSION,
   UNNAMED_ACTION,
@@ -40,10 +45,10 @@ import {
   reportEvent,
   scopePathFor,
   settleQuestionsForToolUse
-} from "./chunk-3UNAPXED.js";
+} from "./chunk-XFDWLDHG.js";
 import {
   repoKeyFor
-} from "./chunk-3KXBRSL3.js";
+} from "./chunk-GMHQYX3D.js";
 import {
   askUser,
   cancelQuestion,
@@ -58,21 +63,22 @@ import {
   requestGate,
   sendNotification,
   waitForQuestion,
-  waitsForThePhone
-} from "./chunk-DTVHZDYM.js";
+  waitsForThePhone,
+  withdrawQuestion
+} from "./chunk-D3U6CN7T.js";
 import {
   getMachineId
-} from "./chunk-FWS2KLV2.js";
+} from "./chunk-PIBWX3EF.js";
 import {
   claudeConfigDir
-} from "./chunk-ATPJGHUP.js";
+} from "./chunk-TI4JYPGQ.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-Y64JGYTB.js";
+} from "./chunk-32OSSYGZ.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-BAGBCSXA.js";
+} from "./chunk-X2MTVD4W.js";
 import {
   AGENT_QUESTION_STRATEGY,
   AGENT_QUESTION_TOOL,
@@ -81,11 +87,13 @@ import {
   GATE_WIRE,
   HANDED_BACK_REASON,
   PLAN_DECLINED_REASON,
+  PRETOOLUSE_HANDLED_TOOLS,
   QUESTION_LIMIT_PROMPT_REASON,
   SCOPE_BATCH_REASON,
   SOLE_GATE_SIGNED_OUT_REASON,
   SOLE_GATE_SUBSCRIPTION_REASON,
   SOLE_GATE_UNDECIDED_REASON,
+  TERMINAL_AND_PHONE_REASON,
   UNREADABLE_CALL_REASON,
   UNVERIFIABLE_APPROVAL_REASON,
   WITHDRAWN_APPROVAL_REASON,
@@ -99,6 +107,7 @@ import {
   claudePermissionRequestOutput,
   claudePermissionRulesFromSettings,
   claudePreToolUseOutput,
+  claudePromptTakesTheCall,
   claudeStoppedPermissionRequestOutput,
   claudeStoppedPreToolUseOutput,
   denyReasonFrom,
@@ -114,17 +123,113 @@ import {
   isCursorHookPayload,
   isPermissionRequestOwnedByPreToolUse,
   isPusharyOwnTool,
+  isRecord,
   parseAgentQuestions,
   questionHandedToTheTerminal,
   questionLimitHandBack,
   refusesWhenUnanswered,
   resolveGate,
+  terminalLiveWait,
+  terminalStaysLiveForTheCall,
   timeoutActionWithoutLocalPrompt,
   unansweredRefusalReason
-} from "./chunk-MNKIR2ZB.js";
+} from "./chunk-RQOT6QL3.js";
+
+// src/terminal-answer-watch.ts
+import { closeSync, openSync, readSync, statSync } from "fs";
+import { StringDecoder } from "string_decoder";
+var INITIAL_TAIL_BYTES = 1048576;
+var DEFAULT_POLL_MS = 500;
+var sortedKeys = (value) => {
+  if (Array.isArray(value)) return value.map(sortedKeys);
+  if (!isRecord(value)) return value;
+  return Object.fromEntries(Object.keys(value).sort().map((key) => [key, sortedKeys(value[key])]));
+};
+var stableJson = (value) => JSON.stringify(sortedKeys(value) ?? null);
+var parsedLine = (line) => {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+};
+var messageParts = (line) => {
+  const row = parsedLine(line);
+  const content = isRecord(row) && isRecord(row.message) ? row.message.content : void 0;
+  return Array.isArray(content) ? content.filter(isRecord) : [];
+};
+var isToolUse = (part) => part.type === "tool_use" && typeof part.id === "string" && typeof part.name === "string";
+var isToolResultFor = (toolUseId) => (part) => part.type === "tool_result" && part.tool_use_id === toolUseId;
+var matchingToolUseIds = (lines, call) => {
+  const wanted = stableJson(call.toolInput);
+  return lines.flatMap(messageParts).filter(isToolUse).filter((part) => part.name === call.toolName && stableJson(part.input ?? {}) === wanted).map((part) => part.id);
+};
+var toolUseIdOf = (lines, call) => matchingToolUseIds(lines, call).at(-1);
+var toolResultArrived = (lines, toolUseId) => lines.some((line) => messageParts(line).some(isToolResultFor(toolUseId)));
+var writtenAtMs = (line) => {
+  const row = parsedLine(line);
+  return isRecord(row) && typeof row.timestamp === "string" ? Date.parse(row.timestamp) : Number.NaN;
+};
+var answeredBefore = (lines, toolUseId, startedAtMs) => lines.some((line) => messageParts(line).some(isToolResultFor(toolUseId)) && !(writtenAtMs(line) >= startedAtMs));
+var openToolUseIdOf = (lines, call, startedAtMs) => matchingToolUseIds(lines, call).filter((id) => !answeredBefore(lines, id, startedAtMs)).at(-1);
+var readTranscriptFrom = (path, offset) => {
+  try {
+    const size = statSync(path).size;
+    if (size <= offset) return { bytes: Buffer.alloc(0), endOffset: size };
+    const descriptor = openSync(path, "r");
+    try {
+      const buffer = Buffer.alloc(size - offset);
+      readSync(descriptor, buffer, 0, buffer.length, offset);
+      return { bytes: buffer, endOffset: size };
+    } finally {
+      closeSync(descriptor);
+    }
+  } catch {
+    return null;
+  }
+};
+var startingOffset = (path) => {
+  try {
+    return Math.max(statSync(path).size - INITIAL_TAIL_BYTES, 0);
+  } catch {
+    return 0;
+  }
+};
+var watchForTerminalAnswer = (transcriptPath, call, startedAtMs, signal, pollMs = DEFAULT_POLL_MS) => new Promise((resolve) => {
+  if (!transcriptPath || signal.aborted) return;
+  let offset = startingOffset(transcriptPath);
+  const decoder = new StringDecoder("utf8");
+  let carry = "";
+  let readingHistory = true;
+  let toolUseId;
+  let timer;
+  const stop = () => {
+    if (timer) clearTimeout(timer);
+  };
+  signal.addEventListener("abort", stop, { once: true });
+  const tick = () => {
+    if (signal.aborted) return;
+    const chunk = readTranscriptFrom(transcriptPath, offset);
+    if (chunk) {
+      offset = chunk.endOffset;
+      const pieces = `${carry}${decoder.write(chunk.bytes)}`.split("\n");
+      carry = pieces.pop() ?? "";
+      toolUseId = toolUseId ?? (readingHistory ? openToolUseIdOf(pieces, call, startedAtMs) : toolUseIdOf(pieces, call));
+      readingHistory = false;
+      if (toolUseId && toolResultArrived(pieces, toolUseId)) {
+        signal.removeEventListener("abort", stop);
+        resolve();
+        return;
+      }
+    }
+    timer = setTimeout(tick, pollMs);
+    timer.unref?.();
+  };
+  tick();
+});
 
 // src/claude-permission-rules.ts
-import { readFileSync, statSync } from "fs";
+import { readFileSync, statSync as statSync2 } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 var MANAGED_CLAUDE_SETTINGS_BY_PLATFORM = {
@@ -146,15 +251,15 @@ var claudeSettingsSources = (location) => [
     { path: join(location.projectDir, ".claude", "settings.local.json"), trust: "grants" }
   ] : []
 ];
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var restrictionsOnly = (document) => {
-  if (!isRecord(document) || !isRecord(document.permissions)) return null;
+  if (!isRecord2(document) || !isRecord2(document.permissions)) return null;
   const { ask: ask2, deny: deny2 } = document.permissions;
   return { permissions: { ask: ask2, deny: deny2 } };
 };
 var readSettingsDocument = (path) => {
   try {
-    const stats = statSync(path);
+    const stats = statSync2(path);
     if (!stats.isFile() || stats.size > MAX_CLAUDE_SETTINGS_BYTES) return null;
     return JSON.parse(readFileSync(path, "utf8"));
   } catch {
@@ -191,34 +296,45 @@ var reportDecisionEpisode = async (apiKey, input) => {
 
 // src/hook.ts
 import { basename } from "path";
-var START_MS = Date.now();
-var ACTIVE_AGENT = activeIdentity(process.argv);
-var ACTIVE_SOURCE = activeHookSource(process.argv);
-var PUSHARY_IS_SOLE_GATE = ACTIVE_SOURCE !== null && hookCompatibleProfileBySource(ACTIVE_SOURCE)?.soleGate != null;
-var agentNameIn = (projectName) => `${ACTIVE_AGENT.label} - ${projectName}`;
+
+// src/pre-tool-use-output.ts
 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);
 var halted = (reason) => claudeStoppedPreToolUseOutput(reason);
-var undecidedCall = (reason) => PUSHARY_IS_SOLE_GATE ? deny(reason) : void 0;
+
+// src/permission-ask-outcome.ts
 var questionLimitOutput = (handBack) => handBack.kind === "refuse" ? deny(handBack.reason) : ask(QUESTION_LIMIT_PROMPT_REASON);
-var outcomeOfFailedPermissionAsk = (error, sessionId, questionLimitFacts) => {
+var outcomeOfFailedPermissionAsk = (error, sessionId, questionLimitFacts, subscriptionRequiredOutput) => {
   if (isQuestionLimitRefusal(error)) return questionLimitOutput(questionLimitHandBack(questionLimitFacts));
-  return outcomeOfFailedAsk(error, sessionId, halted(UNVERIFIABLE_APPROVAL_REASON)) ?? undecidedCall(SOLE_GATE_SUBSCRIPTION_REASON);
+  return outcomeOfFailedAsk(error, sessionId, halted(UNVERIFIABLE_APPROVAL_REASON)) ?? subscriptionRequiredOutput;
 };
-var handlePushOnly = async (apiKey, description, projectName, timeoutSeconds, timeoutAction, sessionId, machineId, toolName, toolTarget, decision, signals, agentPromptFollows) => {
+var handlePushOnly = async (apiKey, call, timeoutSeconds, timeoutAction, signals) => {
+  const {
+    description,
+    projectName,
+    agentName,
+    sessionId,
+    machineId,
+    toolName,
+    toolTarget,
+    decision,
+    agentPromptFollows,
+    startMs,
+    subscriptionRequiredOutput,
+    announceWait: announceWait2
+  } = call;
   const effectiveWait = effectiveWaitSeconds(timeoutAction, timeoutSeconds, "claude");
   const now = Date.now();
-  const requestedDeadline = hookWaitDeadline(START_MS, effectiveWait, "claude", now);
-  const clampCut = hookWaitClamped(START_MS, effectiveWait, "claude", now);
+  const requestedDeadline = hookWaitDeadline(startMs, effectiveWait, "claude", now);
+  const clampCut = hookWaitClamped(startMs, effectiveWait, "claude", now);
   let result;
   try {
     result = await askUser(apiKey, {
       question: `Allow ${description || UNNAMED_ACTION}?`,
       type: "confirm",
       context: `Agent wants to run this in ${projectName}`,
-      agentName: agentNameIn(projectName),
+      agentName,
       sessionId,
       machineId,
       toolName,
@@ -230,11 +346,11 @@ var handlePushOnly = async (apiKey, description, projectName, timeoutSeconds, ti
     return outcomeOfFailedPermissionAsk(error, sessionId, {
       refusesUnanswered: refusesWhenUnanswered({ mode: "push_only", timeoutAction }),
       agentPromptFollows
-    });
+    }, subscriptionRequiredOutput);
   }
   if (isDecisionStopped(result)) return halted(DECISION_STOP_REASON);
   const deadline = storedWaitDeadline(result, requestedDeadline);
-  if (waitsForThePhone(result)) announceWait(effectiveWait, result.answerUrl, sessionId);
+  if (waitsForThePhone(result)) announceWait2(effectiveWait, result.answerUrl, sessionId);
   const answer = await waitForQuestion(apiKey, result, deadline);
   if (isDecisionStopped(answer)) return halted(DECISION_STOP_REASON);
   if (!answer.answered && isLocalQuestionHandoff(result)) return ask("Approve in the current client.");
@@ -255,18 +371,29 @@ var handlePushOnly = async (apiKey, description, projectName, timeoutSeconds, ti
       return ask("No push response, asking in terminal");
   }
 };
-var handleTerminalOnly = () => {
-  return ask();
-};
-var handlePushFirst = async (apiKey, description, projectName, pushFirstSeconds, sessionId, machineId, toolName, toolTarget, decision, signals, agentPromptFollows) => {
-  const requestedDeadline = hookWaitDeadline(START_MS, pushFirstSeconds, "claude", Date.now());
+var handlePushFirst = async (apiKey, call, pushFirstSeconds, signals) => {
+  const {
+    description,
+    projectName,
+    agentName,
+    sessionId,
+    machineId,
+    toolName,
+    toolTarget,
+    decision,
+    agentPromptFollows,
+    startMs,
+    subscriptionRequiredOutput,
+    announceWait: announceWait2
+  } = call;
+  const requestedDeadline = hookWaitDeadline(startMs, pushFirstSeconds, "claude", Date.now());
   let result;
   try {
     result = await askUser(apiKey, {
       question: `Allow ${description || UNNAMED_ACTION}?`,
       type: "confirm",
       context: `Agent wants to run this in ${projectName}`,
-      agentName: agentNameIn(projectName),
+      agentName,
       sessionId,
       machineId,
       toolName,
@@ -275,10 +402,10 @@ var handlePushFirst = async (apiKey, description, projectName, pushFirstSeconds,
       ...decision
     });
   } catch (error) {
-    return outcomeOfFailedPermissionAsk(error, sessionId, { refusesUnanswered: false, agentPromptFollows });
+    return outcomeOfFailedPermissionAsk(error, sessionId, { refusesUnanswered: false, agentPromptFollows }, subscriptionRequiredOutput);
   }
   if (isDecisionStopped(result)) return halted(DECISION_STOP_REASON);
-  if (waitsForThePhone(result)) announceWait(pushFirstSeconds, result.answerUrl, sessionId);
+  if (waitsForThePhone(result)) announceWait2(pushFirstSeconds, result.answerUrl, sessionId);
   const deadline = storedWaitDeadline(result, requestedDeadline);
   const answer = await waitForQuestion(apiKey, result, deadline, 1500);
   if (isDecisionStopped(answer)) return halted(DECISION_STOP_REASON);
@@ -289,6 +416,20 @@ var handlePushFirst = async (apiKey, description, projectName, pushFirstSeconds,
   }
   return ask(WITHDRAWN_APPROVAL_REASON);
 };
+
+// src/hook.ts
+var START_MS = Date.now();
+var ACTIVE_AGENT = activeIdentity(process.argv);
+var ACTIVE_SOURCE = activeHookSource(process.argv);
+var HANDED_DOWN_BY_THE_MAC_BRIDGE = namedSource(process.argv) !== void 0;
+var CLAUDE_SESSION_ATTENDED_ENV = "CLAUDE_CODE_SESSION_ATTENDED";
+var PUSHARY_IS_SOLE_GATE = ACTIVE_SOURCE !== null && hookCompatibleProfileBySource(ACTIVE_SOURCE)?.soleGate != null;
+var agentNameIn = (projectName) => `${ACTIVE_AGENT.label} - ${projectName}`;
+var allowWithInput = (updatedInput) => claudePreToolUseOutput("allow", void 0, updatedInput);
+var undecidedCall = (reason) => PUSHARY_IS_SOLE_GATE ? deny(reason) : void 0;
+var handleTerminalOnly = () => {
+  return ask();
+};
 var handleNotifyOnly = async (apiKey, description, projectName, sessionId, machineId) => {
   try {
     await sendNotification(apiKey, {
@@ -302,6 +443,64 @@ var handleNotifyOnly = async (apiKey, description, projectName, sessionId, machi
   }
   return ask();
 };
+var TERMINAL_ANSWERED = /* @__PURE__ */ Symbol("terminal-answered");
+var terminalAnswered = (input, signal) => watchForTerminalAnswer(input.transcript_path, { toolName: input.tool_name, toolInput: input.tool_input ?? {} }, START_MS, signal).then(() => TERMINAL_ANSWERED);
+var terminalLiveTimeoutOutput = (onTimeout, question) => {
+  switch (onTimeout) {
+    case "allow":
+      return allow();
+    case "deny":
+      return deny(unansweredRefusalReason(isAwayPaused(question)));
+    case "leave_to_terminal":
+      return ask(WITHDRAWN_APPROVAL_REASON);
+  }
+};
+var outcomeOfFailedTerminalLiveAsk = (error, sessionId, refusesUnanswered) => isQuestionLimitRefusal(error) ? questionLimitOutput(questionLimitHandBack({ refusesUnanswered, agentPromptFollows: true })) : outcomeOfFailedAsk(error, sessionId, void 0);
+var handleTerminalLive = async (apiKey, input, description, projectName, toolPolicy, holdBudgetSeconds, machineId, toolTarget, decision, signals) => {
+  const plan = terminalLiveWait(toolPolicy, holdBudgetSeconds);
+  const sessionId = input.session_id;
+  const stop = new AbortController();
+  const terminal = terminalAnswered(input, stop.signal);
+  let question;
+  const servedEndsAt = Date.now() + plan.waitSeconds * 1e3;
+  const requestedDeadline = Math.min(servedEndsAt, START_MS + plan.holdSeconds * 1e3);
+  try {
+    question = await askUser(apiKey, {
+      question: `Allow ${description || UNNAMED_ACTION}?`,
+      type: "confirm",
+      context: `Agent wants to run this in ${projectName}`,
+      agentName: agentNameIn(projectName),
+      sessionId,
+      machineId,
+      toolName: input.tool_name,
+      toolTarget,
+      waitEndsAt: plan.onTimeout === "leave_to_terminal" ? new Date(requestedDeadline).toISOString() : void 0,
+      ...decision
+    });
+  } catch (error) {
+    stop.abort();
+    return outcomeOfFailedTerminalLiveAsk(error, sessionId, plan.onTimeout === "deny");
+  }
+  if (isDecisionStopped(question)) {
+    stop.abort();
+    return void 0;
+  }
+  const deadline = storedWaitDeadline(question, requestedDeadline);
+  const first = await Promise.race([waitForQuestion(apiKey, question, deadline, 2e3, stop.signal), terminal]).finally(() => stop.abort());
+  if (first === TERMINAL_ANSWERED) {
+    await withdrawQuestion(apiKey, question.correlationId);
+    return void 0;
+  }
+  if (isDecisionStopped(first)) return void 0;
+  if (!first.answered && isLocalQuestionHandoff(question)) return ask("Approve in the current client.");
+  if (first.answered) {
+    if (isDeferAnswer(first.value)) return ask(HANDED_BACK_REASON);
+    signals.humanDecision = true;
+    return first.value === "yes" ? allow() : deny(denyReasonFrom(first.value, first.note));
+  }
+  return terminalLiveTimeoutOutput(deadline < servedEndsAt ? "leave_to_terminal" : plan.onTimeout, question);
+};
+var pushesToThePhone = (mode) => mode !== "terminal_only" && mode !== "notify_only";
 var emitDecisionEpisode = (apiKey, input, toolPolicy, machineId, toolTarget, decision, result) => {
   const verdict = result?.hookSpecificOutput?.permissionDecision;
   const outcome = verdict === "allow" ? "approve" : verdict === "deny" ? "deny" : null;
@@ -330,7 +529,7 @@ var emitDecisionEpisode = (apiKey, input, toolPolicy, machineId, toolTarget, dec
     machineId
   });
 };
-var dispatchModeHandler = async (apiKey, input, toolPolicy, machineId, trainingConsent = false, scopeReason, scopePath) => {
+var dispatchModeHandler = async (apiKey, input, toolPolicy, machineId, trainingConsent = false, scopeReason, scopePath, terminalLive) => {
   const description = describeToolCall(input.tool_name, input.tool_input, "hook");
   const projectName = basename(input.cwd ?? process.cwd());
   const sessionId = input.session_id;
@@ -357,18 +556,36 @@ var dispatchModeHandler = async (apiKey, input, toolPolicy, machineId, trainingC
     permissionMode: input.permission_mode
   };
   const signals = {};
+  const permissionAsk = {
+    description,
+    projectName,
+    agentName: agentNameIn(projectName),
+    sessionId,
+    machineId,
+    toolName: input.tool_name,
+    toolTarget,
+    decision,
+    agentPromptFollows,
+    startMs: START_MS,
+    subscriptionRequiredOutput: undecidedCall(SOLE_GATE_SUBSCRIPTION_REASON),
+    announceWait
+  };
   const runHandler = () => {
-    switch (ownPrompt ? toolPolicy.mode : approvalModeWithoutLocalPrompt(toolPolicy.mode)) {
+    const mode = ownPrompt ? toolPolicy.mode : approvalModeWithoutLocalPrompt(toolPolicy.mode);
+    if (terminalLive && pushesToThePhone(mode)) {
+      return handleTerminalLive(apiKey, input, description, projectName, { ...toolPolicy, mode }, terminalLive.holdBudgetSeconds, machineId, toolTarget, decision, signals);
+    }
+    switch (mode) {
       case "push_only":
-        return handlePushOnly(apiKey, description, projectName, toolPolicy.timeoutSeconds, ownPrompt ? toolPolicy.timeoutAction : timeoutActionWithoutLocalPrompt(toolPolicy), sessionId, machineId, input.tool_name, toolTarget, decision, signals, agentPromptFollows);
+        return handlePushOnly(apiKey, permissionAsk, toolPolicy.timeoutSeconds, ownPrompt ? toolPolicy.timeoutAction : timeoutActionWithoutLocalPrompt(toolPolicy), signals);
       case "terminal_only":
         return Promise.resolve(handleTerminalOnly());
       case "push_first":
-        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds, sessionId, machineId, input.tool_name, toolTarget, decision, signals, agentPromptFollows);
+        return handlePushFirst(apiKey, permissionAsk, toolPolicy.pushFirstSeconds, signals);
       case "notify_only":
         return handleNotifyOnly(apiKey, description, projectName, sessionId, machineId);
       default:
-        return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds, sessionId, machineId, input.tool_name, toolTarget, decision, signals, agentPromptFollows);
+        return handlePushFirst(apiKey, permissionAsk, toolPolicy.pushFirstSeconds, signals);
     }
   };
   const result = await runHandler();
@@ -403,6 +620,16 @@ var keylessNoticeOnce = (sessionId) => {
   }
 };
 var shouldDeferToNativeMode = defersToNativeMode;
+var terminalLiveFactsOf = (input) => ({
+  source: ACTIVE_SOURCE,
+  sessionAttended: process.env[CLAUDE_SESSION_ATTENDED_ENV] === "1",
+  permissionHookAdmitted: isAdmitted(readAdmissionRules(), "claude", "PermissionRequest"),
+  handedDownByTheMacBridge: HANDED_DOWN_BY_THE_MAC_BRIDGE,
+  fromCursor: isCursorHookPayload(input),
+  permissionMode: input.permission_mode,
+  toolName: input.tool_name
+});
+var preToolUseHandsOff = (input, gateInput, verdict) => claudePromptTakesTheCall(terminalLiveFactsOf(input), gateInput, verdict);
 var handleAskUserQuestion = async (apiKey, input, modeState) => {
   if (questionHandedToTheTerminal(input.tool_name, modeState)) return void 0;
   const questions = parseAgentQuestions(input.tool_input ?? {});
@@ -599,6 +826,7 @@ var handlePreToolUse = async (input, canonical) => {
       case "defer":
         return undecidedCall(SOLE_GATE_UNDECIDED_REASON);
       default:
+        if (preToolUseHandsOff(input, gateInput, verdict)) return ask(TERMINAL_AND_PHONE_REASON);
         return await dispatchModeHandler(apiKey, input, verdict.policy, getMachineId(), modeState.trainingConsent, verdict.scopeReason, verdict.scopePath);
     }
   } catch (error) {
@@ -616,9 +844,9 @@ var toPermissionRequestOutput = (hookOutput) => {
   if (d.permissionDecision === "deny") return permReqDeny(d.permissionDecisionReason);
   return void 0;
 };
-var handlePermissionRequest = async (input, canonical) => {
+var handlePermissionRequest = async (input, canonical, holdBudgetSeconds) => {
   const claudeRules = claudePermissionRulesFor(input);
-  if (canonical === void 0 && !claudeRulesMayCover(input, claudeRules) && isPermissionRequestOwnedByPreToolUse(input.tool_name, input.permission_mode, shouldDeferToNativeMode)) return void 0;
+  if (canonical === void 0 && !claudeRulesMayCover(input, claudeRules) && isPermissionRequestOwnedByPreToolUse(input.tool_name, input.permission_mode, shouldDeferToNativeMode) && !terminalStaysLiveForTheCall(terminalLiveFactsOf(input))) return void 0;
   if (isPusharyOwnTool(input.tool_name)) return void 0;
   let apiKey;
   try {
@@ -642,7 +870,14 @@ var handlePermissionRequest = async (input, canonical) => {
     if (canonical === null) return permReqDeny(UNREADABLE_CALL_REASON);
     if (agentQuestionStrategy(ACTIVE_SOURCE, "PermissionRequest", input.tool_name) === AGENT_QUESTION_STRATEGY.native) return void 0;
     if (verdict.kind === "gate" && verdict.scopeReason && (canonical?.toolInputs.length ?? 0) > 1) return permReqDeny(SCOPE_BATCH_REASON);
-    if (!(verdict.kind === "gate" && verdict.scopeReason) && !claudeAllowlistOwnsCall(gateInput, verdict, input.permission_mode, claudeRules) && isPermissionRequestOwnedByPreToolUse(input.tool_name, input.permission_mode, shouldDeferToNativeMode)) return void 0;
+    const handedOff = preToolUseHandsOff(input, gateInput, verdict);
+    const terminalLive = terminalStaysLiveForTheCall(terminalLiveFactsOf(input));
+    const scopeQuestion = verdict.kind === "gate" && Boolean(verdict.scopeReason);
+    const preToolUseRanForTheCall = PRETOOLUSE_HANDLED_TOOLS.has(input.tool_name) && isAdmitted(readAdmissionRules(), "claude", "PreToolUse");
+    const preToolUseAskedTheScopeQuestion = scopeQuestion && terminalLive && preToolUseRanForTheCall;
+    const preToolUseOwnsTheCall = !scopeQuestion && !claudeAllowlistOwnsCall(gateInput, verdict, input.permission_mode, claudeRules) && isPermissionRequestOwnedByPreToolUse(input.tool_name, input.permission_mode, shouldDeferToNativeMode);
+    if (!handedOff && (preToolUseAskedTheScopeQuestion || preToolUseOwnsTheCall)) return void 0;
+    const terminalLiveDispatch = handedOff ? { holdBudgetSeconds } : void 0;
     switch (verdict.kind) {
       case "allow":
         return permReqAllow();
@@ -651,7 +886,7 @@ var handlePermissionRequest = async (input, canonical) => {
         return void 0;
       default:
         return toPermissionRequestOutput(
-          await dispatchModeHandler(apiKey, input, verdict.policy, getMachineId(), modeState.trainingConsent, verdict.scopeReason, verdict.scopePath)
+          await dispatchModeHandler(apiKey, input, verdict.policy, getMachineId(), modeState.trainingConsent, verdict.scopeReason, verdict.scopePath, terminalLiveDispatch)
         );
     }
   } catch (error) {

package/dist/{chunk-RABLE5R6.js → chunk-BBFGDYYI.js}

@@ -1,6 +1,6 @@
 import {
   isFile
-} from "./chunk-SCMEVDAR.js";
+} from "./chunk-WJLHZ6E6.js";
 
 // src/claude-native-install.ts
 import { accessSync, constants } from "fs";