@pushary/agent-hooks 0.92.1 → 0.93.0

package/dist/{chunk-YXDYKECP.js → chunk-G5L3WVFV.js}

@@ -13,14 +13,18 @@ import {
   savePendingCommand,
   sendNotification,
   waitForAnswer
-} from "./chunk-F7OURW3C.js";
+} from "./chunk-RER3FRTD.js";
 import {
   AGENT_IDENTITIES,
+  TEAMMATE_IDLE_ACTION,
   compactionAction,
   deriveReceiptMeta,
   deriveToolTarget,
+  describeStopFailure,
   describeToolCall,
   isToolResultError,
+  notificationAction,
+  notificationTypeOf,
   parseApplyPatchFiles,
   parseApplyPatchOps,
   sessionEndAction,
@@ -30,13 +34,17 @@ import {
   summarizeStop,
   taskTitleFrom,
   toolResultErrorText
-} from "./chunk-L4E2BIJ2.js";
+} from "./chunk-UAFQC35P.js";
+import {
+  NOTIFICATION_PUSH_TYPES,
+  POSTTOOLUSE_MIRROR_ONLY_TOOLS
+} from "./chunk-QQSQWLFR.js";
 import {
   getMachineId
-} from "./chunk-2ACC5M7F.js";
+} from "./chunk-72FWXLW2.js";
 import {
   withRetry
-} from "./chunk-BSZYIAZL.js";
+} from "./chunk-EYRGBYZG.js";
 import {
   reportedInstallSource
 } from "./chunk-JW4KO5AF.js";
@@ -174,7 +182,7 @@ var readReusableMode = (apiKey, sessionId, maxAgeMs) => {
   if (Date.now() - last.at >= maxAgeMs) return null;
   return { ...last.state, degraded: false };
 };
-var fetchModeState = async (apiKey, sessionId, reuseWithinMs = 0) => {
+var fetchModeState = async (apiKey, sessionId, reuseWithinMs = 0, signal) => {
   if (reuseWithinMs > 0) {
     const reusable = readReusableMode(apiKey, sessionId, reuseWithinMs);
     if (reusable) return reusable;
@@ -184,7 +192,7 @@ var fetchModeState = async (apiKey, sessionId, reuseWithinMs = 0) => {
     const url = sessionId ? `${baseUrl}/api/mcp/mode?session=${encodeURIComponent(sessionId)}` : `${baseUrl}/api/mcp/mode`;
     const response = await fetch(url, {
       headers: { "Authorization": `Bearer ${apiKey}` },
-      signal: AbortSignal.timeout(3e3)
+      signal: AbortSignal.any([AbortSignal.timeout(3e3), ...signal ? [signal] : []])
     });
     if (!response.ok) {
       return degradedFallback(apiKey, response.status === 401 || response.status === 403);
@@ -569,20 +577,21 @@ var pendingQuestionsToSettle = (sessionId, toolUseId) => {
   const settledElsewhere = toolUseId ? listPendingQuestionsForToolUse(sessionId, toolUseId) : [];
   return [.../* @__PURE__ */ new Set([...settledElsewhere, ...listPendingQuestions(sessionId)])];
 };
-var reconcileQuestions = async (sessionId, files) => {
+var reconcileQuestions = async (sessionId, files, signal) => {
   const late = [];
   try {
     if (files.length === 0) return late;
     const apiKey = getApiKey();
+    if (signal) signal = AbortSignal.any([signal, AbortSignal.timeout(2e3)]);
     for (const correlationId of files) {
+      if (signal?.aborted) break;
       try {
-        const answer = await waitForAnswer(apiKey, correlationId, 1e3);
+        const answer = await waitForAnswer(apiKey, correlationId, 1e3, signal);
         if (answer.answered) {
           late.push({ correlationId, value: answer.value });
           continue;
         }
-        await cancelQuestion(apiKey, correlationId).catch(() => {
-        });
+        await cancelQuestion(apiKey, correlationId, signal);
       } catch {
         continue;
       }
@@ -592,7 +601,7 @@ var reconcileQuestions = async (sessionId, files) => {
   }
   return late;
 };
-var reconcilePendingQuestions = (sessionId, toolUseId) => reconcileQuestions(sessionId, pendingQuestionsToSettle(sessionId, toolUseId));
+var reconcilePendingQuestions = (sessionId, toolUseId, signal) => reconcileQuestions(sessionId, pendingQuestionsToSettle(sessionId, toolUseId), signal);
 var describeLateAnswer = (value) => {
   const v = (value ?? "").trim();
   if (v === "yes") return "approved it";
@@ -605,7 +614,7 @@ var buildLateAnswerContext = (late) => {
   const parts = late.map((l) => `you ${describeLateAnswer(l.value)} on your phone`);
   return `Pushary: a permission prompt you were sent was answered late \u2014 ${parts.join("; ")} \u2014 after the terminal already took over. Treat this as the user's latest intent; do not assume the earlier terminal decision matched it.`;
 };
-var notifyLateAnswers = async (apiKey, late, agentName, sessionId) => {
+var notifyLateAnswers = async (apiKey, late, agentName, sessionId, signal) => {
   if (late.length === 0) return;
   const summary = late.map((l) => describeLateAnswer(l.value)).join(", ");
   await sendNotification(apiKey, {
@@ -613,7 +622,7 @@ var notifyLateAnswers = async (apiKey, late, agentName, sessionId) => {
     body: `You ${summary} after the agent had already moved on.`,
     agentName,
     sessionId
-  }, 2500).catch(() => {
+  }, 2500, signal).catch(() => {
   });
 };
 var CLAUDE_CODE_AGENT = { type: "claude_code", label: "Claude Code" };
@@ -687,8 +696,10 @@ var consumesActivityContext = (agentType) => {
   return pendingCommandEvents(source).some((event) => event !== "Stop");
 };
 var detectInstallMode = () => (process.argv[1] ?? "").includes("_npx") ? "npx" : "cli";
-var acknowledgePendingCommand = async (apiKey, baseUrl, commandId, sessionId, machineId, timeoutMs, state = "delivered") => {
+var acknowledgePendingCommand = async (apiKey, baseUrl, commandId, sessionId, machineId, timeoutMs, state = "delivered", signal) => {
   try {
+    signal?.throwIfAborted();
+    if (timeoutMs <= 0) return false;
     const response = await fetch(`${baseUrl}/api/agent/command/ack`, {
       method: "POST",
       headers: {
@@ -702,13 +713,14 @@ var acknowledgePendingCommand = async (apiKey, baseUrl, commandId, sessionId, ma
         state,
         ...state === "failed" ? { failureCode: "consumer_rejected" } : {}
       }),
-      signal: AbortSignal.timeout(timeoutMs)
+      signal: AbortSignal.any([AbortSignal.timeout(timeoutMs), ...signal ? [signal] : []])
     });
     return response.ok;
   } catch {
     return false;
   }
 };
+var ACK_RESERVE_MS = 1500;
 var reportEvent = async (event, options = {}) => {
   const apiKey = options.apiKey ?? getApiKey();
   const baseUrl = getBaseUrl();
@@ -716,7 +728,14 @@ var reportEvent = async (event, options = {}) => {
   const sessionKey = event.sessionId || DEFAULT_SESSION;
   const receiptNamespace = `${apiKey}:${machineId}:${event.agentType}`;
   const clientCanDrain = consumesActivityContext(event.agentType) && options.timeoutMs === void 0;
+  const deadlineMs = options.budgetMs === void 0 ? void 0 : Date.now() + options.budgetMs;
+  const ackReserveMs = deadlineMs === void 0 ? 0 : Math.min(ACK_RESERVE_MS, Math.floor((options.budgetMs ?? 0) * 0.4));
+  const postTimeoutMs = (fallback) => deadlineMs === void 0 ? fallback : Math.max(0, Math.min(fallback, deadlineMs - ackReserveMs - Date.now()));
+  const ackTimeoutMs = (fallback) => deadlineMs === void 0 ? fallback : Math.max(0, Math.min(fallback, deadlineMs - Date.now()));
   return withRetry(async () => {
+    options.signal?.throwIfAborted();
+    const timeoutMs = postTimeoutMs(options.timeoutMs ?? 1e4);
+    if (timeoutMs <= 0) return null;
     const storedCommand = clientCanDrain ? readPendingCommand(sessionKey, receiptNamespace) : null;
     const res = await fetch(`${baseUrl}/api/agent/event`, {
       method: "POST",
@@ -744,9 +763,9 @@ var reportEvent = async (event, options = {}) => {
         ...driverFromEnv(process.env) ? { driver: driverFromEnv(process.env) } : {},
         canDrainCommand: clientCanDrain && !storedCommand,
         ackMode: clientCanDrain && !storedCommand,
-        skipCommandDrain: storedCommand != null
+        skipCommandDrain: options.skipDrain === true || storedCommand != null
       }),
-      signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
+      signal: AbortSignal.any([AbortSignal.timeout(timeoutMs), ...options.signal ? [options.signal] : []])
     });
     if (options.requireOk && !res.ok) throw new Error(`/api/agent/event rejected (${res.status})`);
     try {
@@ -760,8 +779,9 @@ var reportEvent = async (event, options = {}) => {
           storedCommand.id,
           event.sessionId,
           machineId,
-          options.timeoutMs ?? 1e4,
-          failed ? "failed" : "delivered"
+          ackTimeoutMs(options.timeoutMs ?? 1e4),
+          failed ? "failed" : "delivered",
+          options.signal
         );
         if (!acknowledged) return withoutPending();
         if (storedCommand.delivered || failed) {
@@ -785,7 +805,9 @@ var reportEvent = async (event, options = {}) => {
           result.pendingCommandId,
           event.sessionId,
           machineId,
-          options.timeoutMs ?? 1e4
+          ackTimeoutMs(options.timeoutMs ?? 1e4),
+          "delivered",
+          options.signal
         );
         if (!acknowledged || !markPendingCommandDelivered(sessionKey, result.pendingCommandId, receiptNamespace)) {
           return withoutPending();
@@ -797,13 +819,17 @@ var reportEvent = async (event, options = {}) => {
     }
   }, { maxAttempts: options.maxAttempts ?? 2, baseDelayMs: 300 });
 };
-var NON_GATED_MIRROR_TOOLS = /* @__PURE__ */ new Set(["TodoWrite"]);
+var NON_GATED_MIRROR_TOOLS = new Set(POSTTOOLUSE_MIRROR_ONLY_TOOLS);
+var HOOK_BUDGET_MS = 9e3;
+var DRAINING_REPORT_BUDGET_MS = 8e3;
 var settleQuestionsForToolUse = async (sessionId, toolUseId) => {
   if (!toolUseId) return;
   const late = await reconcileQuestions(sessionId, listPendingQuestionsForToolUse(sessionId, toolUseId));
   for (const answer of late) removePendingQuestion(sessionId, answer.correlationId);
 };
 var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const deadline = Date.now() + HOOK_BUDGET_MS;
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
   try {
     const projectName = basename2(input.cwd ?? process.cwd());
     const action = describeToolCall(input.tool_name, input.tool_input, "event");
@@ -812,8 +838,10 @@ var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
     const isError = isToolResultError(toolResult);
     const receiptsEnabled = process.env.PUSHARY_RECEIPTS !== "off";
     const sessionKey = input.session_id || DEFAULT_SESSION;
-    const liveMode = await fetchModeState(getApiKey(), input.session_id, MODE_REUSE_MS);
-    const late = await reconcilePendingQuestions(sessionKey, input.tool_use_id);
+    const [liveMode, late] = await Promise.all([
+      fetchModeState(getApiKey(), input.session_id, MODE_REUSE_MS, signal),
+      reconcilePendingQuestions(sessionKey, input.tool_use_id, signal)
+    ]);
     let additionalContext;
     if (late.length > 0 && agent.type === CLAUDE_CODE_AGENT.type) {
       additionalContext = buildLateAnswerContext(late);
@@ -833,7 +861,7 @@ var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
       ...beacon ? { decisionOrigin: beacon.decisionOrigin, toolName: beacon.toolName, toolTarget: beacon.toolTarget } : {},
       meta: receiptsEnabled ? deriveReceiptMeta(lookup.tool, lookup.input, toolResult, input.cwd ?? process.cwd()) : void 0,
       usage: deriveUsage(input.transcript_path, input.session_id)
-    }, { maxAttempts: 1 });
+    }, { maxAttempts: 1, budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())), signal });
     const extraReports = [];
     if (throttlePass(`hookactive:${sessionKey}`, HOOK_ACTIVE_WINDOW_MS)) {
       extraReports.push(
@@ -844,7 +872,7 @@ var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
             agentName: `${agent.label} - ${projectName}`,
             sessionId: input.session_id
           },
-          { maxAttempts: 1, timeoutMs: 800 }
+          { maxAttempts: 1, timeoutMs: 800, signal }
         )
       );
     }
@@ -858,13 +886,15 @@ var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
   }
 };
 var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const deadline = Date.now() + HOOK_BUDGET_MS;
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
   try {
     const projectName = basename2(input.cwd ?? process.cwd());
     const sessionKey = input.session_id || DEFAULT_SESSION;
     const titlesEnabled = process.env.PUSHARY_TASK_TITLES !== "off";
     const taskTitle = titlesEnabled ? taskTitleFrom(input.prompt) : void 0;
     if (input.prompt) saveLastPrompt(sessionKey, input.prompt);
-    const late = await reconcilePendingQuestions(sessionKey);
+    const late = await reconcilePendingQuestions(sessionKey, void 0, signal);
     let additionalContext;
     if (late.length > 0 && agent.type === CLAUDE_CODE_AGENT.type) {
       additionalContext = buildLateAnswerContext(late);
@@ -877,7 +907,7 @@ var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
         agentName: `${agent.label} - ${projectName}`,
         sessionId: input.session_id,
         taskTitle
-      }, { maxAttempts: 1, timeoutMs: 800 })
+      }, { maxAttempts: 1, budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())), signal })
     ]);
     if (consumesActivityContext(agent.type)) {
       additionalContext = mergeAdditionalContext(additionalContext, reported);
@@ -888,10 +918,12 @@ var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
   }
 };
 var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const deadline = Date.now() + HOOK_BUDGET_MS;
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
   try {
     const projectName = basename2(input.cwd ?? process.cwd());
     const sessionKey = input.session_id || DEFAULT_SESSION;
-    const late = await reconcilePendingQuestions(sessionKey);
+    const late = await reconcilePendingQuestions(sessionKey, void 0, signal);
     const tasks = [
       reportEvent({
         event: "session_end",
@@ -900,13 +932,13 @@ var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
         action: summarizeStop(input),
         ...sessionIdentityOf(input),
         usage: deriveUsage(input.transcript_path, input.session_id)
-      }, { maxAttempts: 1 })
+      }, { maxAttempts: 1, budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())), signal })
     ];
     if (late.length > 0) {
-      tasks.push(notifyLateAnswers(getApiKey(), late, `${agent.label} - ${projectName}`, input.session_id));
+      tasks.push(notifyLateAnswers(getApiKey(), late, `${agent.label} - ${projectName}`, input.session_id, signal));
       for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
     }
-    if (!isDefaultSession(sessionKey)) removePendingSession(sessionKey);
+    if (!isDefaultSession(sessionKey) && listPendingQuestions(sessionKey).length === 0) removePendingSession(sessionKey);
     const [reported] = await Promise.allSettled(tasks);
     const pendingCommand = reported.status === "fulfilled" ? reported.value?.pendingCommand : void 0;
     if (typeof pendingCommand === "string" && pendingCommand.trim().length > 0) {
@@ -931,7 +963,10 @@ var handleSubagentStop = async (input, agent = CLAUDE_CODE_AGENT) => {
       agentName: `${agent.label} - ${projectName}`,
       action: subagentStopSummary(input),
       ...sessionIdentityOf(input)
-    }, { maxAttempts: 1, timeoutMs: SUBAGENT_STOP_REPORT_TIMEOUT_MS });
+      // A subagent's end is a `session_end` like any other as far as the route is
+      // concerned, and this caller discards the response, so without this the
+      // parent's queued instruction is popped and thrown away.
+    }, { maxAttempts: 1, timeoutMs: SUBAGENT_STOP_REPORT_TIMEOUT_MS, skipDrain: true });
   } catch {
   }
 };
@@ -945,7 +980,7 @@ var handleCompaction = async (input, agent = CLAUDE_CODE_AGENT) => {
       agentType: agent.type,
       agentName: `${agent.label} - ${projectName}`,
       action: compactionAction(input.hook_event_name, input.trigger),
-      sessionId: input.session_id
+      ...sessionIdentityOf(input)
     }, { maxAttempts: 1, timeoutMs: COMPACTION_REPORT_TIMEOUT_MS });
   } catch {
   }
@@ -988,14 +1023,39 @@ var handleSessionEnd = async (input, agent = CLAUDE_CODE_AGENT, options = {}) =>
   } catch {
   }
 };
-var NOTIFICATION_PUSH_TYPES = /* @__PURE__ */ new Set(["idle_prompt", "agent_needs_input"]);
 var NOTIFICATION_THROTTLE_MS = 60 * 1e3;
 var handleNotification = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
   try {
     const projectName = basename2(input.cwd ?? process.cwd());
-    const notifType = input.notification_type ?? input.type ?? "";
+    const notifType = notificationTypeOf(input) ?? "";
     const sessionKey = input.session_id || DEFAULT_SESSION;
-    if (NOTIFICATION_PUSH_TYPES.has(notifType)) {
+    const teammateIdle = input.hook_event_name === "TeammateIdle";
+    const action = teammateIdle ? TEAMMATE_IDLE_ACTION : notificationAction(input);
+    const failed = !teammateIdle && notifType === "error";
+    await reportEvent({
+      event: teammateIdle ? "teammate_idle" : failed ? "error" : "notification",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action,
+      sessionId: input.session_id,
+      error: failed ? action : void 0
+      // `timeoutMs` is not decoration. It is this file's way of saying "side
+      // report", and it sets `clientCanDrain` false. Without it this call
+      // advertises itself as able to consume a phone-queued instruction, and the
+      // stored-command replay inside `reportEvent` hands one back, acknowledges it
+      // as delivered and marks the local receipt delivered, to a caller that
+      // discards the return value. The notification hook prints nothing, so the
+      // instruction is destroyed rather than delayed. Hoisting this report out of
+      // the else-branch put every notification type on that path, not just the
+      // quiet ones.
+      //
+      // 2.5s rather than the 4s a side report usually gets: on the push branch
+      // this is followed by a ~3s `fetchModeState` and a 4s `sendNotification`,
+      // and all three have to fit inside Claude Code's 10s Notification budget.
+    }, { maxAttempts: 1, timeoutMs: 2500, signal }).catch(() => {
+    });
+    if (!teammateIdle && NOTIFICATION_PUSH_TYPES.has(notifType)) {
       if (!throttlePass(`notify:${sessionKey}:${notifType}`, NOTIFICATION_THROTTLE_MS)) return;
       let apiKey;
       try {
@@ -1003,61 +1063,24 @@ var handleNotification = async (input, agent = CLAUDE_CODE_AGENT) => {
       } catch {
         return;
       }
-      const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS).catch(() => null);
+      const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS, signal).catch(() => null);
       if (mode?.kill || mode?.mode === "terminal_only") return;
       await sendNotification(apiKey, {
         title: `${agent.label} is waiting`,
-        body: (input.message ?? "Your agent is waiting for you.").slice(0, 200),
+        body: input.message ? action.slice(0, 200) : "Your agent is waiting for you.",
         agentName: `${agent.label} - ${projectName}`,
         sessionId: input.session_id,
         // Makes this an `update` server-side, so resolveSiteMode gates it on
         // the wildcard policy too. `info` because nothing finished.
         context: { type: "info" }
-      }, 4e3).catch(() => {
+      }, 4e3, signal).catch(() => {
       });
-      return;
     }
-    await reportEvent({
-      event: notifType === "error" ? "error" : "notification",
-      agentType: agent.type,
-      agentName: `${agent.label} - ${projectName}`,
-      action: input.message ?? input.title ?? "Notification",
-      sessionId: input.session_id,
-      error: notifType === "error" ? input.message ?? input.title : void 0
-    }).catch(() => {
-    });
   } catch {
   }
 };
-var STOPFAILURE_MAX_ERROR_LENGTH = 300;
-var STOPFAILURE_REASONS = {
-  rate_limit: "Rate limited by the API",
-  overloaded: "The API is overloaded right now",
-  authentication_failed: "Authentication failed",
-  billing_error: "A billing error stopped the turn"
-};
-var describeStopFailure = (error) => {
-  const fromString = (s) => {
-    const v = s.trim();
-    if (!v) return void 0;
-    return STOPFAILURE_REASONS[v] ?? v.slice(0, STOPFAILURE_MAX_ERROR_LENGTH);
-  };
-  if (typeof error === "string") {
-    const described = fromString(error);
-    if (described) return described;
-  } else if (error && typeof error === "object") {
-    const e = error;
-    for (const key of ["type", "message", "error", "code"]) {
-      const val = e[key];
-      if (typeof val === "string") {
-        const described = fromString(val);
-        if (described) return described;
-      }
-    }
-  }
-  return "The turn ended on an API error (rate limit, billing, or auth).";
-};
 var handleStopFailure = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
   try {
     let apiKey;
     try {
@@ -1066,16 +1089,29 @@ var handleStopFailure = async (input, agent = CLAUDE_CODE_AGENT) => {
       return;
     }
     const projectName = basename2(input.cwd ?? process.cwd());
-    const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS).catch(() => null);
-    if (mode?.kill || mode?.mode === "terminal_only") return;
     const reason = describeStopFailure(input.error);
+    await reportEvent({
+      event: "turn_error",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action: reason,
+      error: reason,
+      sessionId: input.session_id
+      // Same reason as the Notification report above, and the same budget shape:
+      // this is followed by a ~3s fetchModeState and a 4s sendNotification inside
+      // Claude Code's 10s StopFailure budget. The stopfailure hook prints nothing,
+      // so without this the phone's queued instruction is taken and destroyed.
+    }, { maxAttempts: 1, timeoutMs: 2500, signal }).catch(() => {
+    });
+    const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS, signal).catch(() => null);
+    if (mode?.kill || mode?.mode === "terminal_only") return;
     await sendNotification(apiKey, {
       title: `${agent.label} stopped on an error`,
       body: reason,
       agentName: `${agent.label} - ${projectName}`,
       sessionId: input.session_id,
       context: { type: "error", errorMessage: reason }
-    }, 4e3).catch(() => {
+    }, 4e3, signal).catch(() => {
     });
   } catch {
   }
@@ -1101,6 +1137,7 @@ export {
   permissionTimeoutDecision,
   preToolUseTimeoutDecision,
   readLastPrompt,
+  CLAUDE_CODE_AGENT,
   reportEvent,
   settleQuestionsForToolUse,
   handlePostToolUse,

package/dist/{chunk-4TFXV5MW.js → chunk-GKMQMSTB.js}

@@ -1,6 +1,6 @@
 import {
   pusharyDir
-} from "./chunk-CV2YD2JR.js";
+} from "./chunk-N3TF3RQ2.js";
 import {
   readJsonSafe
 } from "./chunk-4LL6LG5X.js";

package/dist/{chunk-RQPQSJJH.js → chunk-HCLSTQ3N.js}

@@ -1,7 +1,3 @@
-import {
-  PRETOOLUSE_HANDLED_TOOLS,
-  PRETOOLUSE_PHONE_ANSWERED_TOOLS
-} from "./chunk-2LAHXHBR.js";
 import {
   defersToNativeMode
 } from "./chunk-I463AEG3.js";
@@ -14,14 +10,16 @@ import {
   isDeferAnswer
 } from "./chunk-YHG74UFF.js";
 import {
+  CLAUDE_CODE_AGENT,
   fetchModeState,
   getPolicy,
   readLastPrompt,
   readLastUserPrompt,
   repoKeyFor,
+  reportEvent,
   settleQuestionsForToolUse,
   throttlePass
-} from "./chunk-YXDYKECP.js";
+} from "./chunk-G5L3WVFV.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -29,7 +27,7 @@ import {
   pollForAnswer,
   savePendingQuestion,
   sendNotification
-} from "./chunk-F7OURW3C.js";
+} from "./chunk-RER3FRTD.js";
 import {
   UNNAMED_ACTION,
   deriveAction,
@@ -37,11 +35,16 @@ import {
   deriveBlocker,
   deriveToolTarget,
   describeToolCall,
+  permissionDeniedAction,
   scopePathFor
-} from "./chunk-L4E2BIJ2.js";
+} from "./chunk-UAFQC35P.js";
+import {
+  PRETOOLUSE_HANDLED_TOOLS,
+  PRETOOLUSE_PHONE_ANSWERED_TOOLS
+} from "./chunk-QQSQWLFR.js";
 import {
   getMachineId
-} from "./chunk-2ACC5M7F.js";
+} from "./chunk-72FWXLW2.js";
 import {
   getApiKey,
   getBaseUrl
@@ -582,7 +585,19 @@ var automodeRetryEnabled = () => {
   const flag = process.env.PUSHARY_AUTOMODE_RETRY;
   return flag === "1" || flag === "true";
 };
+var reportPermissionDenied = (input) => reportEvent({
+  event: "permission_denied",
+  agentType: CLAUDE_CODE_AGENT.type,
+  agentName: `${CLAUDE_CODE_AGENT.label} - ${basename(input.cwd ?? process.cwd())}`,
+  action: permissionDeniedAction(input.tool_name),
+  sessionId: input.session_id
+  // 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.
+}, { timeoutMs: 4e3 }).catch(() => void 0);
 var handlePermissionDenied = async (input) => {
+  await reportPermissionDenied(input);
   if (isPusharyOwnTool(input.tool_name)) return void 0;
   let apiKey;
   try {

package/dist/{chunk-CNPAT3HL.js → chunk-KHTFHUL3.js}

@@ -7,7 +7,7 @@ import {
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
-} from "./chunk-QZCFVWA7.js";
+} from "./chunk-EQRS3SGM.js";
 
 // src/live-session.ts
 var MAX_TRANSCRIPT_QUEUE = 100;

package/dist/{chunk-CV2YD2JR.js → chunk-N3TF3RQ2.js}

@@ -34,11 +34,23 @@ var CODEX_HOOK_EVENTS = [
   { event: "PostToolUse", matcher: "Bash|apply_patch", delivery: "telemetry", timeout: 10 },
   { event: "UserPromptSubmit", delivery: "telemetry", timeout: 10 },
   { event: "Stop", delivery: "telemetry", timeout: 10 },
-  { event: "SessionStart", matcher: "startup|resume", delivery: "telemetry", timeout: 10 },
+  // `clear` alongside startup and resume, matching what we already do on Claude
+  // Code. Codex names all three in its own SessionStart sources, and without it a
+  // session the person started by clearing is one we never see begin.
+  { event: "SessionStart", matcher: "startup|resume|clear", delivery: "telemetry", timeout: 10 },
   // Codex caps SessionEnd at 3s and defaults it to 1s, unlike every other event
   // here. It also runs synchronously whatever `async` says, so the handler must
   // fit the window rather than assume the 10s Claude Code allows.
-  { event: "SessionEnd", delivery: "telemetry", timeout: 3 }
+  { event: "SessionEnd", delivery: "telemetry", timeout: 3 },
+  // Observability only, and the four Codex names we were not registering at all.
+  // Every one is in codex-cli 0.151.0's own `HookEventName` enum
+  // (subagent_start, subagent_stop, pre_compact, post_compact), and we already
+  // carry all four on Claude Code, so the island showed subagent and compaction
+  // shape for one agent and not the other. None of them decides anything.
+  { event: "SubagentStart", delivery: "telemetry", timeout: 5 },
+  { event: "SubagentStop", delivery: "telemetry", timeout: 5 },
+  { event: "PreCompact", matcher: "manual|auto", delivery: "telemetry", timeout: 5 },
+  { event: "PostCompact", matcher: "manual|auto", delivery: "telemetry", timeout: 5 }
 ];
 var CODEX_EVENT_KEY = {
   PermissionRequest: "permission_request",
@@ -47,7 +59,11 @@ var CODEX_EVENT_KEY = {
   UserPromptSubmit: "user_prompt_submit",
   Stop: "stop",
   SessionStart: "session_start",
-  SessionEnd: "session_end"
+  SessionEnd: "session_end",
+  SubagentStart: "subagent_start",
+  SubagentStop: "subagent_stop",
+  PreCompact: "pre_compact",
+  PostCompact: "post_compact"
 };
 var codexEventKeyOf = (event) => event.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
@@ -209,14 +225,30 @@ var restoreCodexHookTrust = (config, hooksJsonPath, positions, snapshot) => {
   }
   return true;
 };
-var untrustedCodexHookEvents = (config, hooksJsonPath, command, positions) => {
+var codexTrustGaps = (config, hooksConfig, hooksJsonPath, command, positions) => {
   const state = asRecord(asRecord(config.hooks)?.state);
-  return CODEX_HOOK_EVENTS.filter((definition) => {
+  const hooks = asRecord(hooksConfig?.hooks);
+  const gaps = [];
+  for (const definition of CODEX_HOOK_EVENTS) {
     const position = positions[definition.event];
-    if (!position) return false;
-    const entry = asRecord(state?.[codexHookStateKey(hooksJsonPath, definition.event, position)]);
-    return entry?.trusted_hash !== codexHookTrustHash(definition, command);
-  }).map((definition) => definition.event);
+    if (!position) continue;
+    const stored = asRecord(state?.[codexHookStateKey(hooksJsonPath, definition.event, position)])?.trusted_hash;
+    const eventKey = CODEX_EVENT_KEY[definition.event] ?? definition.event;
+    const onDisk = asRecord(
+      asRecord(hooks?.[definition.event]) ?? (Array.isArray(hooks?.[definition.event]) ? hooks[definition.event][position[0]] : void 0)
+    );
+    const diskHash = onDisk ? codexEntryTrustHash(eventKey, onDisk) : void 0;
+    if (stored !== void 0 && diskHash !== void 0 && stored === diskHash) {
+      if (diskHash !== codexHookTrustHash(definition, command)) {
+        gaps.push({ event: definition.event, kind: "stale" });
+      }
+      continue;
+    }
+    if (stored !== (diskHash ?? codexHookTrustHash(definition, command))) {
+      gaps.push({ event: definition.event, kind: "untrusted" });
+    }
+  }
+  return gaps;
 };
 var removeCodexMcpServer = (config) => {
   const servers = asRecord(config.mcp_servers);
@@ -318,7 +350,7 @@ export {
   codexHookPositions,
   captureCodexHookTrust,
   restoreCodexHookTrust,
-  untrustedCodexHookEvents,
+  codexTrustGaps,
   removeCodexHookTrust,
   removeCodexSettings,
   addCodexHookTrust,

package/dist/{chunk-3HS4YGHB.js → chunk-NXZYC3B3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-CELX75MW.js";
 import {
   codexHomeFrom
-} from "./chunk-CV2YD2JR.js";
+} from "./chunk-N3TF3RQ2.js";
 import {
   HOOK_LOCATOR_BINARY
 } from "./chunk-VNMKIJZB.js";

package/dist/{chunk-QCXKQJTG.js → chunk-NZQTIDXN.js}

@@ -1,9 +1,9 @@
 import {
   isBridgeLocator
-} from "./chunk-3HS4YGHB.js";
+} from "./chunk-NXZYC3B3.js";
 import {
   pusharyHookExecutable
-} from "./chunk-ZMKKK6DC.js";
+} from "./chunk-6Y4IKMQT.js";
 import {
   BELL_HOOK_BINARY
 } from "./chunk-DSTLA2TC.js";