@pushary/agent-hooks 1.9.64 → 1.9.66

package/dist/{chunk-CCNH4PJ2.js → chunk-AWGBL4P3.js}

@@ -4,19 +4,24 @@ import {
   outcomeOfFailedAsk,
   reportMachineDenial,
   storedWaitDeadline
-} from "./chunk-XF3AWNMO.js";
+} from "./chunk-V4EOFOB2.js";
 import {
   isGatingMoment,
   recordKeylessMoment
-} from "./chunk-XJIIU36L.js";
+} from "./chunk-6BGVSV2Q.js";
+import {
+  isAdmitted,
+  readAdmissionRules
+} from "./chunk-QN25WBXL.js";
 import {
   isDeferAnswer,
   oncePerSession
-} from "./chunk-TR3GP5MH.js";
+} from "./chunk-ZJV7SFIJ.js";
 import {
   activeHookSource,
-  activeIdentity
-} from "./chunk-ML2Q6WWE.js";
+  activeIdentity,
+  namedSource
+} from "./chunk-3EZP5ZPS.js";
 import {
   DEFAULT_SESSION,
   UNNAMED_ACTION,
@@ -40,10 +45,10 @@ import {
   reportEvent,
   scopePathFor,
   settleQuestionsForToolUse
-} from "./chunk-MIPJ2VXP.js";
+} from "./chunk-2BL6KWN7.js";
 import {
   repoKeyFor
-} from "./chunk-3KXBRSL3.js";
+} from "./chunk-XXIJBYNW.js";
 import {
   askUser,
   cancelQuestion,
@@ -58,21 +63,22 @@ import {
   requestGate,
   sendNotification,
   waitForQuestion,
-  waitsForThePhone
-} from "./chunk-E23RKH3T.js";
+  waitsForThePhone,
+  withdrawQuestion
+} from "./chunk-ZAZUDYSF.js";
 import {
   getMachineId
-} from "./chunk-ADRPW7KU.js";
+} from "./chunk-IA5VWIHV.js";
 import {
   claudeConfigDir
-} from "./chunk-H4BKC2GN.js";
+} from "./chunk-GDLT32I4.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-Y64JGYTB.js";
+} from "./chunk-A47UKPC7.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-BAGBCSXA.js";
+} from "./chunk-GO7YKPT3.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-EJR5JXMV.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 {
@@ -194,6 +299,8 @@ import { basename } from "path";
 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 allow = (reason) => claudePreToolUseOutput("allow", reason);
@@ -302,6 +409,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 +495,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;
@@ -358,7 +523,11 @@ var dispatchModeHandler = async (apiKey, input, toolPolicy, machineId, trainingC
   };
   const signals = {};
   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);
       case "terminal_only":
@@ -403,6 +572,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 +778,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 +796,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 +822,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 +838,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-LMC5UPL7.js → chunk-B6JC676X.js}

@@ -1,7 +1,7 @@
 import {
   HOOK_HOLD_BUDGET_ENV,
   hookHoldBudgetProof
-} from "./chunk-MNKIR2ZB.js";
+} from "./chunk-EJR5JXMV.js";
 
 // src/hold-budget.ts
 var takeHookHoldBudget = (args = process.argv.slice(2), env = process.env) => {

package/dist/{chunk-QPPBH5NY.js → chunk-CN6JFM62.js}

@@ -1,18 +1,18 @@
 import {
   macAppBridgeAvailable
-} from "./chunk-VNRWQCGU.js";
+} from "./chunk-7LK3Y6ET.js";
 import {
   keyPrefix
-} from "./chunk-BLAIETMP.js";
+} from "./chunk-CNJ7SI5V.js";
 import {
   bridgeAgentKey
-} from "./chunk-H4BKC2GN.js";
+} from "./chunk-GDLT32I4.js";
 import {
   readJsonSafe
-} from "./chunk-BSZIPIFA.js";
+} from "./chunk-KS3O6O7E.js";
 import {
   isValidApiKey
-} from "./chunk-MNKIR2ZB.js";
+} from "./chunk-EJR5JXMV.js";
 
 // src/shared-mcp-key.ts
 var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;

package/dist/{chunk-BLAIETMP.js → chunk-CNJ7SI5V.js}

@@ -1,19 +1,19 @@
 import {
   resolveInstallSourceFor
-} from "./chunk-2VADJ6JH.js";
+} from "./chunk-XIJTXRWB.js";
 import {
   backupFile,
   readJsonSafe,
   writeFileAtomic,
   writeJsonAtomic
-} from "./chunk-BSZIPIFA.js";
+} from "./chunk-KS3O6O7E.js";
 import {
   configFilePath
-} from "./chunk-Y64JGYTB.js";
+} from "./chunk-A47UKPC7.js";
 import {
   API_KEY_PREFIX_PATTERN,
   isRecord
-} from "./chunk-MNKIR2ZB.js";
+} from "./chunk-EJR5JXMV.js";
 
 // src/shell-alias.ts
 import { homedir } from "os";

package/dist/{chunk-DVYVGBPB.js → chunk-DBUHSUL7.js}

@@ -1,6 +1,6 @@
 import {
   writeJsonAtomicDurable
-} from "./chunk-BSZIPIFA.js";
+} from "./chunk-KS3O6O7E.js";
 
 // src/transcript-recipient-pin.ts
 import { existsSync, mkdirSync, readFileSync, rmSync } from "fs";

package/dist/{chunk-CJADXAJU.js → chunk-DIUTSF6I.js}

@@ -12,7 +12,7 @@ import {
   reachVerdict,
   reachesYou,
   verifyDelivery
-} from "./chunk-JTOBQUIL.js";
+} from "./chunk-MNNQEUQC.js";
 import {
   humanIsTty,
   writeHuman
@@ -24,14 +24,14 @@ import {
 } from "./chunk-FO3MDD26.js";
 import {
   reportedInstallSource
-} from "./chunk-2VADJ6JH.js";
+} from "./chunk-XIJTXRWB.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-BAGBCSXA.js";
+} from "./chunk-GO7YKPT3.js";
 import {
   NO_PAIRING_COMPUTER,
   PAIR_TTL_SECONDS
-} from "./chunk-MNKIR2ZB.js";
+} from "./chunk-EJR5JXMV.js";
 
 // src/onboarding.ts
 import qrcodeTerminal from "qrcode-terminal";

package/dist/{chunk-JX3DHGZX.js → chunk-DKMVVBXO.js}

@@ -1,46 +1,46 @@
 import {
   ensureCodexTrustsPusharyHooks
-} from "./chunk-LV6DX4P6.js";
+} from "./chunk-JL3SZJJP.js";
 import {
   fxIgnoresInstructionsFile,
   fxInstructionsBody,
   fxServerHolder,
   macAppFxBridge,
   refreshClineKey
-} from "./chunk-MPPTIZ2G.js";
+} from "./chunk-6ZXCWK27.js";
 import {
   OPENCODE_HOOK_BINARY,
   agentHookOwner,
   installOpenCodePlugin,
   macAppBridgeAvailable,
+  openCodeConfigFile,
   openCodeHookArgv,
   openCodeInstructionsFile,
   openCodePluginDir,
-  openCodeWired
-} from "./chunk-VNRWQCGU.js";
+  openCodeWired,
+  withOpenCodeAskRules
+} from "./chunk-7LK3Y6ET.js";
 import {
   detectClaudeVersion
-} from "./chunk-IZTDX2MX.js";
+} from "./chunk-MDIGG3Q7.js";
 import {
   addCompatibleHooks,
   compatibleConfigFile,
   compatibleInstructionsFile,
   hasCompatibleHooks
-} from "./chunk-ML2Q6WWE.js";
+} from "./chunk-3EZP5ZPS.js";
 import {
+  GEMINI_HOOK_BINARY,
+  addGeminiHooks,
+  addGeminiMcpServer,
   claudeUnprovenHolds,
   claudeWired,
   codexUnprovenHolds,
   codexWired,
   geminiWired,
+  hasGeminiHooks,
   planHooks
-} from "./chunk-KA7JIMTG.js";
-import {
-  GEMINI_HOOK_BINARY,
-  addGeminiHooks,
-  addGeminiMcpServer,
-  hasGeminiHooks
-} from "./chunk-6QPDBD7Q.js";
+} from "./chunk-YQDCTID4.js";
 import {
   CLAUDE_HOOK_BINARY,
   CLAUDE_HOOK_EVENTS,
@@ -85,7 +85,7 @@ import {
   renderAgentInstructions,
   supportedClaudeEvents,
   vscodePluginMcp
-} from "./chunk-H4BKC2GN.js";
+} from "./chunk-GDLT32I4.js";
 import {
   formatVersion,
   readJsonSafe,
@@ -93,12 +93,12 @@ import {
   resolveGlobalBinary,
   writeFileAtomic,
   writeJsonAtomic
-} from "./chunk-BSZIPIFA.js";
+} from "./chunk-KS3O6O7E.js";
 import {
   HOOK_COMPATIBLE_PROFILES,
   isCompatibleAgentType,
   isRecord
-} from "./chunk-MNKIR2ZB.js";
+} from "./chunk-EJR5JXMV.js";
 
 // src/reapply.ts
 import { dirname, join } from "path";
@@ -354,15 +354,28 @@ var reapplyCursorPlugin = (apiKey, paths = {}) => reapplyPluginMcp(
   apiKey
 );
 var reapplyVsCodePlugin = (apiKey, paths = {}) => reapplyPluginMcp(paths.pluginMcpPath ?? vscodePluginMcp(), apiKey);
+var addOpenCodeAskRulesWhereUnset = (configFile) => {
+  const read = readJsonSafe(configFile);
+  if (read.kind !== "ok" || !isRecord(read.value)) return false;
+  const { config: withRules, change } = withOpenCodeAskRules(read.value);
+  if (change.kind !== "added") return false;
+  writeJsonAtomic(configFile, withRules, modeToPreserve(configFile));
+  return true;
+};
 var reapplyOpenCodePlugin = (paths = {}) => {
   const pluginDir = paths.pluginDir ?? openCodePluginDir();
   if (!openCodeWired(pluginDir)) return { configured: false, reapplied: false, hooks: false, mcp: false };
   try {
     installOpenCodePlugin(openCodeHookArgv((paths.resolveBinary ?? resolveGlobalBinary)(OPENCODE_HOOK_BINARY)), pluginDir);
-    return { configured: true, reapplied: true, hooks: true, mcp: false };
   } catch {
     return { configured: true, reapplied: false, hooks: false, mcp: false, failed: true };
   }
+  try {
+    const addedRules = addOpenCodeAskRulesWhereUnset(paths.configFile ?? openCodeConfigFile());
+    return { configured: true, reapplied: true, hooks: true, mcp: false, ...addedRules ? { approvalRules: true } : {} };
+  } catch {
+    return { configured: true, reapplied: true, hooks: true, mcp: false, failed: true };
+  }
 };
 var NOT_CONFIGURED = { configured: false, reapplied: false, hooks: false, mcp: false };
 var CONFIGURED_BUT_FAILED = { configured: true, reapplied: false, hooks: false, mcp: false, failed: true };

package/dist/{chunk-2CEVEMJE.js → chunk-DPU6H4JY.js}

@@ -8,20 +8,20 @@ import {
   everyProgramFileIsThere,
   installedCodexApp,
   shellQuoted
-} from "./chunk-5TNGBDIE.js";
+} from "./chunk-AVWECJSN.js";
 import {
   writeHuman
 } from "./chunk-QCGNGEGE.js";
 import {
   xml
-} from "./chunk-5NP3OJ5P.js";
+} from "./chunk-57NTMVMI.js";
 import {
   CODEX_APP_LAUNCH_AT_LOGIN_VERB,
   CODEX_APP_LAUNCH_VARIABLE
 } from "./chunk-E46NE7FB.js";
 import {
   writeFileAtomic
-} from "./chunk-BSZIPIFA.js";
+} from "./chunk-KS3O6O7E.js";
 
 // src/codex-app-cards-switch.ts
 import { execFileSync as execFileSync2 } from "child_process";