@pushary/agent-hooks 1.7.3 → 1.8.0

package/dist/{chunk-U6RVDUJ5.js → chunk-CULUZTWQ.js}

@@ -11,35 +11,43 @@ import {
   savePendingCommand
 } from "./chunk-N6IOSZOE.js";
 import {
+  IDLE_PROMPT_NOTIFICATION,
   NOTIFICATION_PUSH_TYPES,
   POSTTOOLUSE_MIRROR_ONLY_TOOLS
-} from "./chunk-EUGNVLMG.js";
+} from "./chunk-EPCXUP3P.js";
 import {
   cancelQuestion,
   isPolicyConfig,
   sendNotification,
   waitForAnswer
-} from "./chunk-YC27PROF.js";
+} from "./chunk-NGDD6TXY.js";
 import {
   clientErrorKindOf,
   reportClientError
-} from "./chunk-N5MZH5A6.js";
+} from "./chunk-CVQYGMSR.js";
 import {
   withRetry
-} from "./chunk-VE7TXLR4.js";
+} from "./chunk-M5ICYGHT.js";
 import {
   getMachineId
-} from "./chunk-OVC5QXN5.js";
+} from "./chunk-LXQ5FBBD.js";
 import {
   reportedInstallSource
-} from "./chunk-62CVUUNU.js";
+} from "./chunk-DB3ONZB4.js";
+import {
+  canonicalJson
+} from "./chunk-A2A2YTMG.js";
+import {
+  writeFileAtomic
+} from "./chunk-T7E75EKA.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-R6OYCUNK.js";
+} from "./chunk-GPEGOGRJ.js";
 import {
   ACTION_BODY_MAX,
   AGENT_LABELS_BY_TYPE,
+  BLOCKED_ACTION_GRANT_TTL_SECONDS,
   DECISION_LINE_MAX,
   FILE_TARGET_TOOLS,
   GATE_MAX_TOOL_INPUTS,
@@ -47,6 +55,7 @@ import {
   HOOK_SOURCES,
   PENDING_COMMAND_PREFIX,
   REPO_AWARE_AGENTS,
+  blockedActionIdentity,
   canonicalToolName,
   gateOutputFor,
   hookCompatibleProfileBySource,
@@ -59,8 +68,9 @@ import {
   redactSecretsDeep,
   resolveAutoResolveOrigin,
   resolvePolicy,
-  toToolLookup
-} from "./chunk-G4GLCLKK.js";
+  toToolLookup,
+  truncateLine
+} from "./chunk-NQTHFF4W.js";
 
 // src/policy.ts
 import { createHash } from "crypto";
@@ -550,7 +560,7 @@ var scopePathFor = (toolName, toolInput, cwd) => {
 };
 var firstString = (...values) => values.find((v) => typeof v === "string" && v.length > 0);
 var ACTION_BODY_TRUNCATION_MARKER = "\n\u2026 [truncated]";
-var capActionBody = (text) => text.length <= ACTION_BODY_MAX ? text : `${text.slice(0, ACTION_BODY_MAX - ACTION_BODY_TRUNCATION_MARKER.length)}${ACTION_BODY_TRUNCATION_MARKER}`;
+var capActionBody = (text) => truncateLine(text, ACTION_BODY_MAX, ACTION_BODY_TRUNCATION_MARKER);
 var rawActionBody = (toolName, toolInput) => {
   if (toolName === "Edit" || toolName === "replace") {
     const before = firstString(toolInput.old_string);
@@ -577,7 +587,7 @@ var deriveActionBody = (toolName, toolInput) => {
     return void 0;
   }
 };
-var deriveAction = (toolName, toolInput) => describeToolCall(toolName, toolInput, "hook").slice(0, DECISION_LINE_MAX);
+var deriveAction = (toolName, toolInput) => truncateLine(describeToolCall(toolName, toolInput, "hook"), DECISION_LINE_MAX);
 var BLOCKER_BY_MODE = {
   push_only: "Approval required before this runs",
   push_first: "Paused for your approval before continuing",
@@ -585,7 +595,7 @@ var BLOCKER_BY_MODE = {
 };
 var deriveBlocker = (mode, reason) => {
   const text = reason?.replace(/\s+/g, " ").trim() || BLOCKER_BY_MODE[mode] || "Waiting for your approval";
-  return text.slice(0, DECISION_LINE_MAX);
+  return truncateLine(text, DECISION_LINE_MAX);
 };
 
 // ../hook-mapping/src/map.ts
@@ -1203,6 +1213,96 @@ var permissionTimeoutDecision = (timeoutAction) => {
 };
 var preToolUseTimeoutDecision = (timeoutAction, denyReason = "No response within timeout") => timeoutAction === "deny" ? codexDeny(denyReason) : codexPass();
 
+// src/codex-call-decision.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync, rmSync, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir as tmpdir3, userInfo } from "os";
+import { join as join4 } 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 = () => join4(tmpdir3(), `pushary-codex-decisions-${userScope()}`);
+var decisionFile = (key) => join4(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 createHash3("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 = join4(dir, name);
+      try {
+        if (nowMs - statSync3(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 (!existsSync3(dir)) mkdirSync2(dir, { recursive: true, mode: 448 });
+    else sweepExpired(dir, Date.now());
+    writeFileSync3(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() - statSync3(path).mtimeMs < CODEX_DECISION_TTL_MS;
+    const raw = readFileSync4(path, "utf-8");
+    rmSync(path, { force: true });
+    return fresh ? parseDecision(raw) : null;
+  } catch {
+    return null;
+  }
+};
+
 // src/driver.ts
 var DRIVER_ENV = "PUSHARY_DRIVER";
 var PHONE_DRIVER = "phone";
@@ -1213,50 +1313,182 @@ var phoneDrivenEnv = (base) => ({
 });
 
 // src/throttle.ts
-import { join as join4 } from "path";
-import { tmpdir as tmpdir3 } from "os";
-import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, statSync as statSync3, writeFileSync as writeFileSync3, rmSync } from "fs";
-var THROTTLE_DIR = join4(tmpdir3(), "pushary-throttle");
-var markerPath = (key) => join4(THROTTLE_DIR, createHash3("sha256").update(key).digest("hex").slice(0, 16));
+import { join as join5 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, statSync as statSync4, writeFileSync as writeFileSync4, rmSync as rmSync2 } from "fs";
+var THROTTLE_DIR = join5(tmpdir4(), "pushary-throttle");
+var markerPath = (key) => join5(THROTTLE_DIR, createHash4("sha256").update(key).digest("hex").slice(0, 16));
 var claimThrottle = (key, windowMs) => {
   try {
     const path = markerPath(key);
-    if (existsSync3(path) && Date.now() - statSync3(path).mtimeMs < windowMs) return "throttled";
-    mkdirSync2(THROTTLE_DIR, { recursive: true });
-    writeFileSync3(path, "", "utf-8");
+    if (existsSync4(path) && Date.now() - statSync4(path).mtimeMs < windowMs) return "throttled";
+    mkdirSync3(THROTTLE_DIR, { recursive: true });
+    writeFileSync4(path, "", "utf-8");
     return "passed";
   } catch {
     return "unavailable";
   }
 };
 var releaseThrottle = (key) => {
-  rmSync(markerPath(key), { force: true });
+  rmSync2(markerPath(key), { force: true });
+};
+
+// src/blocked-action-hint.ts
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, rmSync as rmSync3, statSync as statSync5, utimesSync } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join6 } 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 ? createHash5("sha256").update(blockedActionIdentity(subject), "utf8").digest("hex") : null;
+};
+var hintDir = () => join6(tmpdir5(), `pushary-blocked-action-hints-${userScope()}`);
+var hintFile = (fingerprint) => join6(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 = join6(dir, name);
+      try {
+        if (isExpired(statSync5(path).mtimeMs, nowMs)) rmSync3(path, { force: true });
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return;
+  }
+};
+var recordBlockedActionHint = (fingerprint, approved) => {
+  if (!isFingerprint(fingerprint)) return false;
+  try {
+    const dir = hintDir();
+    if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true, mode: 448 });
+    else sweepExpired2(dir, Date.now());
+    writeFileAtomic(hintFile(fingerprint), JSON.stringify({ fingerprint, ...approved }), 384);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var readLiveHint = (fingerprint) => {
+  const path = hintFile(fingerprint);
+  try {
+    const stat = statSync5(path);
+    if (!stat.isFile()) return null;
+    if (isExpired(stat.mtimeMs, Date.now())) {
+      rmSync3(path, { force: true });
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    return parsed?.fingerprint === fingerprint ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+var hasBlockedActionHint = (fingerprint) => isFingerprint(fingerprint) && readLiveHint(fingerprint) !== null;
+var approvalIn = (fingerprint, sessionId) => {
+  const hint = readLiveHint(fingerprint);
+  if (hint?.sessionId !== sessionId || typeof hint.toolName !== "string") return null;
+  return { fingerprint, sessionId, toolName: hint.toolName, reminded: hint.reminded === true };
+};
+var approvalAwaitingRetry = (sessionId) => {
+  if (!sessionId) return null;
+  try {
+    for (const name of readdirSync2(hintDir())) {
+      const approval = isFingerprint(name) ? approvalIn(name, sessionId) : null;
+      if (approval) return approval;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var markApprovalReminded = (approval) => {
+  const path = hintFile(approval.fingerprint);
+  try {
+    const { atime, mtime } = statSync5(path);
+    const { fingerprint, sessionId, toolName } = approval;
+    writeFileAtomic(path, JSON.stringify({ fingerprint, sessionId, toolName, reminded: true }), 384);
+    utimesSync(path, atime, mtime);
+  } catch {
+    return;
+  }
+};
+var forgetBlockedActionHint = (fingerprint) => {
+  if (!isFingerprint(fingerprint)) return;
+  try {
+    rmSync3(hintFile(fingerprint), { force: true });
+  } catch {
+    return;
+  }
+};
+
+// src/background-work.ts
+import { createHash as createHash6 } from "crypto";
+import { mkdirSync as mkdirSync5, rmSync as rmSync4, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir as tmpdir6 } from "os";
+import { join as join7 } from "path";
+var BACKGROUND_WORK_TTL_MS = 60 * 60 * 1e3;
+var backgroundWorkDir = () => join7(tmpdir6(), "pushary-background-work");
+var markerFor = (sessionKey) => join7(backgroundWorkDir(), createHash6("sha256").update(sessionKey).digest("hex"));
+var hasRunningBackgroundTasks = (backgroundTasks) => Array.isArray(backgroundTasks) && backgroundTasks.length > 0;
+var noteBackgroundWork = (sessionKey, running) => {
+  try {
+    if (!running) {
+      rmSync4(markerFor(sessionKey), { force: true });
+      return;
+    }
+    mkdirSync5(backgroundWorkDir(), { recursive: true, mode: 448 });
+    writeFileSync5(markerFor(sessionKey), "", { mode: 384 });
+  } catch {
+    return;
+  }
+};
+var isWaitingOnBackgroundWork = (sessionKey, nowMs = Date.now()) => {
+  try {
+    return nowMs - statSync6(markerFor(sessionKey)).mtimeMs < BACKGROUND_WORK_TTL_MS;
+  } catch {
+    return false;
+  }
 };
 
 // src/events.ts
-import { basename as basename3, join as join5 } from "path";
-import { existsSync as existsSync4, mkdirSync as mkdirSync3, readFileSync as readFileSync4, statSync as statSync4, writeFileSync as writeFileSync4 } from "fs";
-import { tmpdir as tmpdir4 } from "os";
-var INTENT_DIR = join5(tmpdir4(), "pushary-intent");
+import { basename as basename3, join as join8 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, statSync as statSync7, writeFileSync as writeFileSync6 } from "fs";
+import { tmpdir as tmpdir7 } from "os";
+var INTENT_DIR = join8(tmpdir7(), "pushary-intent");
 var INTENT_MAX_BYTES = 2048;
 var INTENT_GRACE_MS = 10 * 60 * 1e3;
 var sanitizeSession = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
-var intentFile = (sessionId) => join5(INTENT_DIR, sanitizeSession(sessionId));
+var intentFile = (sessionId) => join8(INTENT_DIR, sanitizeSession(sessionId));
 var saveLastPrompt = (sessionId, prompt) => {
   try {
     const trimmed = prompt.replace(/\s+/g, " ").trim().slice(0, INTENT_MAX_BYTES);
     if (!trimmed) return;
-    mkdirSync3(INTENT_DIR, { recursive: true });
-    writeFileSync4(intentFile(sessionId), trimmed, "utf-8");
+    mkdirSync6(INTENT_DIR, { recursive: true });
+    writeFileSync6(intentFile(sessionId), trimmed, "utf-8");
   } catch {
   }
 };
 var readLastPrompt = (sessionId) => {
   try {
     const path = intentFile(sessionId);
-    if (isDefaultSession(sessionId) && statSync4(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
-    const value = readFileSync4(path, "utf-8").trim();
+    if (isDefaultSession(sessionId) && statSync7(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
+    const value = readFileSync6(path, "utf-8").trim();
     return value.length > 0 ? value : void 0;
   } catch {
     return void 0;
@@ -1320,8 +1552,8 @@ var POLICY_CACHE_TTL_MS = 5 * 60 * 1e3;
 var readFreshCachedPolicy = (apiKey, agentType, sessionId) => {
   const request = policyRequestFor(agentType);
   const path = policyCacheFile(apiKey, request.agent, request.repoAware);
-  if (!existsSync4(path)) return null;
-  const cached = JSON.parse(readFileSync4(path, "utf-8"));
+  if (!existsSync6(path)) return null;
+  const cached = JSON.parse(readFileSync6(path, "utf-8"));
   if (!isPolicyConfig(cached)) return null;
   if ((cached._sessionId ?? null) !== (sessionId ?? null)) return null;
   if (!cached._cachedAt || Date.now() - cached._cachedAt >= POLICY_CACHE_TTL_MS) return null;
@@ -1618,12 +1850,15 @@ var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
     return void 0;
   }
 };
+var UNUSED_APPROVAL_INSTRUCTION = "The person allowed, from Pushary, the call auto mode blocked. Send that call again now, exactly as it was with nothing changed, to use their approval. It covers only that exact call.";
+var phoneInstructionOf = (pendingCommand) => typeof pendingCommand === "string" && pendingCommand.trim().length > 0 ? `The user sent a new instruction from their phone via Pushary: ${pendingCommand.trim()}` : null;
 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 = basename3(input.cwd ?? process.cwd());
     const sessionKey = input.session_id || DEFAULT_SESSION;
+    noteBackgroundWork(sessionKey, hasRunningBackgroundTasks(input.background_tasks));
     const late = await reconcilePendingQuestions(sessionKey, void 0, signal);
     const tasks = [
       reportEvent({
@@ -1642,13 +1877,9 @@ var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
     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) {
-      return {
-        decision: "block",
-        reason: `The user sent a new instruction from their phone via Pushary: ${pendingCommand.trim()}`
-      };
-    }
-    return void 0;
+    const unusedApproval = !input.stop_hook_active && approvalAwaitingRetry(input.session_id) !== null;
+    const instructions = [unusedApproval ? UNUSED_APPROVAL_INSTRUCTION : null, phoneInstructionOf(pendingCommand)].filter((instruction) => instruction !== null);
+    return instructions.length > 0 ? { decision: "block", reason: instructions.join("\n\n") } : void 0;
   } catch {
     return void 0;
   }
@@ -1726,6 +1957,7 @@ var handleSessionEnd = async (input, agent = CLAUDE_CODE_AGENT, options = {}) =>
   }
 };
 var NOTIFICATION_THROTTLE_MS = 60 * 1e3;
+var pushesNotification = (notifType, sessionKey) => NOTIFICATION_PUSH_TYPES.has(notifType) && !(notifType === IDLE_PROMPT_NOTIFICATION && isWaitingOnBackgroundWork(sessionKey));
 var handleNotification = async (input, agent = CLAUDE_CODE_AGENT) => {
   const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
   try {
@@ -1757,7 +1989,7 @@ var handleNotification = async (input, agent = CLAUDE_CODE_AGENT) => {
       // 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 (!teammateIdle && pushesNotification(notifType, sessionKey)) {
       if (claimThrottle(`notify:${sessionKey}:${notifType}`, NOTIFICATION_THROTTLE_MS) !== "passed") return;
       let apiKey;
       try {
@@ -1856,6 +2088,16 @@ export {
   toPolicyLookups,
   permissionTimeoutDecision,
   preToolUseTimeoutDecision,
+  userScope,
+  codexCallKey,
+  recordCodexCallDecision,
+  consumeCodexCallDecision,
+  blockedActionFingerprint,
+  recordBlockedActionHint,
+  hasBlockedActionHint,
+  approvalAwaitingRetry,
+  markApprovalReminded,
+  forgetBlockedActionHint,
   readLastPrompt,
   CLAUDE_CODE_AGENT,
   AUTO_DECISION_WINDOW_MS,

package/dist/{chunk-N5MZH5A6.js → chunk-CVQYGMSR.js}

@@ -4,18 +4,18 @@ import {
 } from "./chunk-POFBE6ZY.js";
 import {
   isNetworkFailure
-} from "./chunk-DUQO4C4I.js";
+} from "./chunk-2OY3ZZ5N.js";
 import {
   clientReportClaims
-} from "./chunk-MZBRL5H5.js";
+} from "./chunk-A2A2YTMG.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-R6OYCUNK.js";
+} from "./chunk-GPEGOGRJ.js";
 import {
   CLIENT_REPORT_PATH,
   degradedLine
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/client-report-claim.ts
 import { createHash } from "crypto";

package/dist/{chunk-VKVSRCBO.js → chunk-D2FX3EPW.js}

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

package/dist/{chunk-62CVUUNU.js → chunk-DB3ONZB4.js}

@@ -1,9 +1,9 @@
 import {
   configFilePath
-} from "./chunk-R6OYCUNK.js";
+} from "./chunk-GPEGOGRJ.js";
 import {
   normalizeInstallSource
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/install-source.ts
 import { readFileSync } from "fs";

package/dist/{chunk-WGMW7OXW.js → chunk-DE4Y6TCC.js}

@@ -2,27 +2,27 @@ import {
   detectProviderLiveCapabilities,
   hasSpawnProvider,
   resolveControlPolicy
-} from "./chunk-Y4ZH64UK.js";
+} from "./chunk-HQ6G3B5R.js";
 import {
   daemonHasRemoteProof,
   daemonServiceManagerAvailable,
   hasDaemonServiceDefinition,
   readDaemonNeedsLogin,
   readDaemonStatus
-} from "./chunk-ZKJ34T2F.js";
+} from "./chunk-WE2J62NC.js";
 import {
   readControlMode,
   readKeySource
-} from "./chunk-D6OODZCM.js";
+} from "./chunk-P7WQEVWA.js";
 import {
   getMachineId
-} from "./chunk-OVC5QXN5.js";
+} from "./chunk-LXQ5FBBD.js";
 import {
   getBaseUrl
-} from "./chunk-R6OYCUNK.js";
+} from "./chunk-GPEGOGRJ.js";
 import {
   getPackageVersion
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/machines.ts
 import { hostname } from "os";

package/dist/{chunk-YYCTF4Q5.js → chunk-E4FJTUH4.js}

@@ -1,6 +1,6 @@
 import {
   SETUP_AGENT_CHOICES
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/cli/commands.ts
 var NPX_LATEST_COMMAND = "npx @pushary/agent-hooks@latest";

package/dist/{chunk-EUGNVLMG.js → chunk-EPCXUP3P.js}

@@ -1,12 +1,13 @@
 import {
   PRETOOLUSE_GATED_TOOLS
-} from "./chunk-G4GLCLKK.js";
+} from "./chunk-NQTHFF4W.js";
 
 // src/claude-tools.ts
 var POSTTOOLUSE_MIRROR_ONLY_TOOLS = ["TodoWrite", "Task", "WebFetch", "WebSearch"];
 var POSTTOOLUSE_MIRRORED_TOOLS = [...PRETOOLUSE_GATED_TOOLS, ...POSTTOOLUSE_MIRROR_ONLY_TOOLS];
 
 // src/claude-notifications.ts
+var IDLE_PROMPT_NOTIFICATION = "idle_prompt";
 var NOTIFICATION_MATCHED_TYPES = [
   // Blocks. The agent, or one of its workers, is waiting on a person.
   "permission_prompt",
@@ -34,6 +35,7 @@ var NOTIFICATION_PUSH_TYPES = /* @__PURE__ */ new Set([
 export {
   POSTTOOLUSE_MIRROR_ONLY_TOOLS,
   POSTTOOLUSE_MIRRORED_TOOLS,
+  IDLE_PROMPT_NOTIFICATION,
   NOTIFICATION_MATCHED_TYPES,
   NOTIFICATION_PUSH_TYPES
 };

package/dist/{chunk-PRNFSORD.js → chunk-EX3GAPA4.js}

@@ -4,7 +4,7 @@ import {
 import {
   describeKeyCheck,
   keyCheckFromResponse
-} from "./chunk-EEEJ2JIL.js";
+} from "./chunk-2ABTSGFT.js";
 import {
   EXIT
 } from "./chunk-KZERVKTD.js";

package/dist/{chunk-TCVMK6GI.js → chunk-EYK3GSRH.js}

@@ -1,15 +1,15 @@
 import {
   AGENT_CHOICES
-} from "./chunk-BGBLLHZ4.js";
+} from "./chunk-ZVSKMPBZ.js";
 import {
   isBridgeLocator
-} from "./chunk-3EUBQARL.js";
+} from "./chunk-C2WCPBF7.js";
 import {
   pusharyHookExecutable
-} from "./chunk-WTJM7PSL.js";
+} from "./chunk-6J2JC2RT.js";
 import {
   BELL_HOOK_BINARY
-} from "./chunk-NOI3XTCY.js";
+} from "./chunk-OKXS7WDZ.js";
 
 // src/setup/hook-ownership.ts
 var commandsIn = (value) => {

package/dist/{chunk-R6OYCUNK.js → chunk-GPEGOGRJ.js}

@@ -1,6 +1,6 @@
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-YYCTF4Q5.js";
+} from "./chunk-E4FJTUH4.js";
 
 // src/config.ts
 import { readFileSync } from "fs";

package/dist/chunk-GU3EJCVV.js

@@ -0,0 +1,43 @@
+// src/diagnostics/service-runtime.ts
+var unescapeXml = (value) => value.replaceAll("&quot;", '"').replaceAll("&apos;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
+var unquoteSystemd = (value) => value.replaceAll('\\"', '"').replaceAll("\\\\", "\\").replaceAll("%%", "%");
+var readServiceExecPath = (contents, platform) => {
+  if (platform === "darwin") {
+    const program = contents.match(/<key>ProgramArguments<\/key>\s*<array>\s*<string>([^<]*)<\/string>/)?.[1];
+    return program ? unescapeXml(program) : null;
+  }
+  if (platform === "linux") {
+    const exec = contents.match(/^ExecStart="((?:[^"\\]|\\.)*)"/m)?.[1];
+    return exec ? unquoteSystemd(exec) : null;
+  }
+  if (platform === "win32") {
+    const command = contents.match(/<Command>([^<]*)<\/Command>/)?.[1];
+    return command ? unescapeXml(command) : null;
+  }
+  return null;
+};
+var MANAGER_SEGMENTS = [
+  [".nvm", "nvm"],
+  ["nvm", "nvm"],
+  ["fnm", "fnm"],
+  [".fnm", "fnm"],
+  [".volta", "volta"],
+  ["volta", "volta"],
+  [".asdf", "asdf"],
+  ["asdf", "asdf"]
+];
+var versionManagerOf = (execPath) => {
+  const segments = execPath.split(/[/\\]/);
+  for (const segment of segments) {
+    const hit = MANAGER_SEGMENTS.find(([name]) => name === segment);
+    if (hit) return hit[1];
+  }
+  return null;
+};
+var describeVersionManagerPin = (execPath, manager) => `The background service is pinned to ${execPath}, which ${manager} manages. Switching Node versions strands it; run pushary daemon install afterwards.`;
+
+export {
+  readServiceExecPath,
+  versionManagerOf,
+  describeVersionManagerPin
+};