@pushary/agent-hooks 0.78.0 → 0.80.0

package/dist/chunk-22EQOB2T.js

@@ -0,0 +1,212 @@
+import {
+  readConfigFileKey
+} from "./chunk-E6I3DBJW.js";
+
+// src/bell/fleet.ts
+import { mkdirSync, readdirSync, statSync, utimesSync, writeFileSync, unlinkSync } from "fs";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { join } from "path";
+var BELL_DIR = join(tmpdir(), "pushary-bell");
+var SESSION_TTL_MS = 10 * 60 * 1e3;
+var sessionFile = (sessionId) => join(BELL_DIR, createHash("sha256").update(sessionId).digest("hex").slice(0, 16));
+var heartbeat = (sessionId, now = Date.now()) => {
+  try {
+    mkdirSync(BELL_DIR, { recursive: true });
+    const path = sessionFile(sessionId);
+    writeFileSync(path, "", "utf-8");
+    const seconds = now / 1e3;
+    utimesSync(path, seconds, seconds);
+  } catch {
+  }
+};
+var liveAgentCount = (now = Date.now()) => {
+  try {
+    let live = 0;
+    for (const name of readdirSync(BELL_DIR)) {
+      const path = join(BELL_DIR, name);
+      try {
+        if (now - statSync(path).mtimeMs < SESSION_TTL_MS) live += 1;
+        else unlinkSync(path);
+      } catch {
+      }
+    }
+    return live;
+  } catch {
+    return 0;
+  }
+};
+var recordAndCount = (sessionId, now = Date.now()) => {
+  heartbeat(sessionId, now);
+  return Math.max(1, liveAgentCount(now));
+};
+
+// src/bell/ring.ts
+import { execFile } from "child_process";
+import { openSync, writeSync, closeSync } from "fs";
+var platformOf = (value = process.platform) => value === "darwin" || value === "linux" || value === "win32" ? value : "other";
+var writeBell = () => {
+  try {
+    const fd = openSync("/dev/tty", "w");
+    try {
+      writeSync(fd, "\x07");
+      return true;
+    } finally {
+      closeSync(fd);
+    }
+  } catch {
+    try {
+      process.stderr.write("\x07");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var noticeCommand = (notice, platform = platformOf()) => {
+  const clean = (text) => text.replace(/["\\]/g, " ").replace(/\s+/g, " ").trim().slice(0, 120);
+  const title = clean(notice.title);
+  const body = clean(notice.body);
+  switch (platform) {
+    case "darwin":
+      return ["osascript", "-e", `display notification "${body}" with title "${title}"`];
+    case "linux":
+      return ["notify-send", title, body];
+    default:
+      return null;
+  }
+};
+var spawnNotifier = (argv) => {
+  const child = execFile(argv[0], argv.slice(1), { timeout: 5e3 }, () => {
+  });
+  child.unref?.();
+};
+var ring = (notice, deps = {}) => {
+  const bell = deps.bell ?? writeBell;
+  const notify = deps.notify ?? spawnNotifier;
+  const rang = bell();
+  const argv = noticeCommand(notice, deps.platform ?? platformOf());
+  if (!argv) return { rang, notified: false };
+  try {
+    notify(argv);
+    return { rang, notified: true };
+  } catch {
+    return { rang, notified: false };
+  }
+};
+
+// src/bell/upgrade.ts
+import { existsSync, mkdirSync as mkdirSync2, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join2 } from "path";
+var DEFAULT_UPGRADE_THRESHOLD = 3;
+var UPGRADE_MARKER = join2(tmpdir2(), "pushary-bell-upgrade-shown");
+var ONCE_PER = 24 * 60 * 60 * 1e3;
+var upgradeThreshold = (env = process.env) => {
+  const raw = Number(env.PUSHARY_BELL_UPGRADE_AT);
+  if (!Number.isFinite(raw) || raw < 1) return DEFAULT_UPGRADE_THRESHOLD;
+  return Math.floor(raw);
+};
+var readLastShown = () => {
+  try {
+    return existsSync(UPGRADE_MARKER) ? statSync2(UPGRADE_MARKER).mtimeMs : null;
+  } catch {
+    return null;
+  }
+};
+var writeLastShown = (at) => {
+  try {
+    mkdirSync2(tmpdir2(), { recursive: true });
+    writeFileSync2(UPGRADE_MARKER, String(at), "utf-8");
+  } catch {
+  }
+};
+var upgradeLine = (context) => `  ${context.liveAgents} agents running. A bell can't tell you which one needs you, and it can't reach your pocket.
+  pushary connect`;
+var upgradeNotice = (context, deps = {}) => {
+  const env = deps.env ?? process.env;
+  if (env.PUSHARY_BELL_QUIET === "1" || env.PUSHARY_BELL_QUIET === "true") return null;
+  if (context.connected) return null;
+  if (context.liveAgents < upgradeThreshold(env)) return null;
+  const now = (deps.now ?? Date.now)();
+  const last = (deps.lastShown ?? readLastShown)();
+  if (last !== null && now - last < ONCE_PER) return null;
+  (deps.markShown ?? writeLastShown)(now);
+  return upgradeLine(context);
+};
+
+// src/bell/handler.ts
+import { basename } from "path";
+var FINISHED_NOTIFICATIONS = /* @__PURE__ */ new Set(["agent_completed"]);
+var BLOCKED_NOTIFICATIONS = /* @__PURE__ */ new Set(["idle_prompt", "agent_needs_input"]);
+var SUMMARY_MAX = 100;
+var summarize = (message, fallback) => {
+  if (typeof message !== "string") return fallback;
+  const collapsed = message.replace(/\s+/g, " ").trim();
+  return collapsed ? collapsed.slice(0, SUMMARY_MAX) : fallback;
+};
+var decideBell = (input) => {
+  const project = basename(input.cwd ?? process.cwd());
+  const notifType = input.notification_type ?? input.type ?? "";
+  if (FINISHED_NOTIFICATIONS.has(notifType)) {
+    return {
+      reason: "finished",
+      title: `${project}: done`,
+      body: summarize(input.message ?? input.last_assistant_message, "Your agent finished.")
+    };
+  }
+  if (BLOCKED_NOTIFICATIONS.has(notifType)) {
+    return {
+      reason: "needs-input",
+      title: `${project}: your agent needs you`,
+      body: summarize(input.message, "Waiting for your input.")
+    };
+  }
+  return null;
+};
+var handleBell = (input, deps = {}) => {
+  const idle = { rang: false, reason: null, liveAgents: 0, upgrade: null };
+  try {
+    const decision = decideBell(input);
+    if (!decision) return idle;
+    const count = deps.count ?? ((sessionId) => recordAndCount(sessionId));
+    const liveAgents = count(input.session_id || "default");
+    const result = (deps.ring ?? ring)({ title: decision.title, body: decision.body }, deps.ringDeps);
+    const notice = upgradeNotice(
+      {
+        agentName: decision.title,
+        liveAgents,
+        connected: (deps.connected ?? hasKey)()
+      },
+      deps.upgradeDeps
+    );
+    if (notice) (deps.write ?? writeStderr)(`
+${notice}
+`);
+    return { rang: result.rang, reason: decision.reason, liveAgents, upgrade: notice };
+  } catch {
+    return idle;
+  }
+};
+var writeStderr = (line) => {
+  try {
+    process.stderr.write(line);
+  } catch {
+  }
+};
+var hasKey = () => {
+  try {
+    if (process.env.PUSHARY_API_KEY?.trim()) return true;
+    return Boolean(readConfigFileKey());
+  } catch {
+    return false;
+  }
+};
+
+export {
+  liveAgentCount,
+  ring,
+  DEFAULT_UPGRADE_THRESHOLD,
+  upgradeThreshold,
+  handleBell
+};

package/dist/{chunk-CC2K2SST.js → chunk-7DYFAM32.js}

@@ -1,6 +1,6 @@
 import {
   HOOK_BUDGETS
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 
 // src/gemini-config.ts
 var GEMINI_HOOK_BINARY = "pushary-gemini-hook";

package/dist/{chunk-FWWBEB6L.js → chunk-A5DAEWBZ.js}

@@ -4,12 +4,12 @@ import {
   isModeStateDegraded,
   resolveAutoResolveOrigin,
   resolvePolicyAcross
-} from "./chunk-HPDLDQC5.js";
+} from "./chunk-DUYM5SHH.js";
 import {
   evaluateScope,
   scopeChangeReason,
   scopeRequiresHuman
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 
 // src/answer.ts
 var denyReasonFrom = (value, note) => {

package/dist/{chunk-MGFZXUUR.js → chunk-BOMF4C2Q.js}

@@ -6,6 +6,9 @@ import {
 import {
   callMcpTool
 } from "./chunk-BSZYIAZL.js";
+import {
+  reportedInstallSource
+} from "./chunk-PPD3HHNJ.js";
 
 // src/reach.ts
 var reachVerdict = (channels) => {
@@ -67,19 +70,6 @@ var describeAppRepair = (verdict) => {
   }
 };
 
-// src/cli/human.ts
-var stream = process.stdout;
-var setHumanStream = (target) => {
-  stream = target;
-};
-var writeHuman = (text) => {
-  stream.write(text);
-};
-var humanIsTty = () => stream === process.stdout && process.stdout.isTTY === true;
-
-// src/onboarding.ts
-import qrcodeTerminal from "qrcode-terminal";
-
 // src/setup/verify.ts
 var plural2 = (count, one) => `${count} ${one}${count === 1 ? "" : "s"}`;
 var describeRecipients = (push, channels) => {
@@ -168,8 +158,111 @@ var describeVerifyOutcome = (outcome) => {
       };
   }
 };
+var ROUND_TRIP_QUESTION = "Setup is nearly done. Tap Yes and this machine is connected.";
+var ROUND_TRIP_TIMEOUT_MS = 55e3;
+var defaultAsk = (apiKey, agentName) => (
+  // wait:false so the poll is ours: the blocking form returns on the SITE's
+  // policy timeout, which a user may have set to seconds, and a setup check
+  // reporting "unanswered" after three seconds would be a lie about the product.
+  callMcpTool(apiKey, "ask_user", {
+    question: ROUND_TRIP_QUESTION,
+    type: "confirm",
+    agentName,
+    wait: false
+  }, { timeoutMs: 15e3 })
+);
+var defaultWait = (apiKey, correlationId) => callMcpTool(apiKey, "wait_for_answer", {
+  correlationId,
+  timeoutMs: ROUND_TRIP_TIMEOUT_MS
+}, { timeoutMs: ROUND_TRIP_TIMEOUT_MS + 5e3 });
+var defaultCancel = async (apiKey, correlationId) => {
+  await callMcpTool(apiKey, "cancel_question", { correlationId }, { timeoutMs: 1e4 }).catch(() => {
+  });
+};
+var verifyRoundTrip = async (apiKey, agentName = "Pushary setup", deps = {}) => {
+  const ask = deps.ask ?? defaultAsk;
+  const wait = deps.wait ?? defaultWait;
+  const cancel = deps.cancel ?? defaultCancel;
+  const now = deps.now ?? Date.now;
+  const started = now();
+  let asked;
+  try {
+    asked = await ask(apiKey, agentName);
+  } catch (err) {
+    return { kind: "error", detail: err instanceof Error ? err.message : "ask failed" };
+  }
+  if (asked.noDevices || asked.warning) return { kind: "no-recipients" };
+  if (asked.mode === "notify_only" || asked.status === "notified") return { kind: "notify-only" };
+  if (!asked.correlationId) return { kind: "error", detail: "no correlationId returned" };
+  if (asked.answered === true) {
+    return { kind: "answered", value: asked.value ?? "yes", latencyMs: now() - started };
+  }
+  let answer;
+  try {
+    answer = await wait(apiKey, asked.correlationId);
+  } catch (err) {
+    await cancel(apiKey, asked.correlationId);
+    return { kind: "error", detail: err instanceof Error ? err.message : "wait failed" };
+  }
+  if (answer.answered === true) {
+    return { kind: "answered", value: answer.value ?? "yes", latencyMs: now() - started };
+  }
+  await cancel(apiKey, asked.correlationId);
+  return { kind: "unanswered" };
+};
+var describeRoundTrip = (outcome) => {
+  switch (outcome.kind) {
+    case "answered":
+      return {
+        ok: true,
+        message: `Answered "${outcome.value}" in ${(outcome.latencyMs / 1e3).toFixed(1)}s. Your agent can reach you and you can answer it.`,
+        next: []
+      };
+    case "unanswered":
+      return {
+        ok: false,
+        message: "The question was sent and nothing came back.",
+        next: [
+          "A push that arrives and cannot be answered is the most common way this breaks, so this is worth resolving now.",
+          "Check the notification actually opened something you could tap, then run pushary doctor --roundtrip."
+        ]
+      };
+    case "notify-only":
+      return {
+        ok: true,
+        message: "Sent. This site is in notify-only mode, so questions never wait for an answer.",
+        next: ["Switch with pushary mode push_first if you want approvals to hold for your phone."]
+      };
+    case "no-recipients":
+      return {
+        ok: false,
+        message: "Nothing to ask. No phone or browser is connected to this site.",
+        next: [
+          "Run pushary connect to add your phone.",
+          "Or pushary connect --app if you already have the Pushary app."
+        ]
+      };
+    case "error":
+      return {
+        ok: false,
+        message: `Could not complete the round trip (${outcome.detail}).`,
+        next: ["Agents are configured. Run pushary doctor --roundtrip once the connection is back."]
+      };
+  }
+};
+
+// src/cli/human.ts
+var stream = process.stdout;
+var setHumanStream = (target) => {
+  stream = target;
+};
+var writeHuman = (text) => {
+  stream.write(text);
+};
+var humanIsTty = () => stream === process.stdout && process.stdout.isTTY === true;
 
 // src/onboarding.ts
+import qrcodeTerminal from "qrcode-terminal";
 var dim = (s) => `\x1B[2m${s}\x1B[0m`;
 var bold = (s) => `\x1B[1m${s}\x1B[0m`;
 var green = (s) => `\x1B[32m${s}\x1B[0m`;
@@ -528,7 +621,12 @@ var startPairing = async (cliPublicKey) => {
     const res = await fetch(`${apiBase()}/api/mobile/pair/start`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ cliPublicKey }),
+      // The only moment this fact can be carried across the handshake. This
+      // terminal knows which front door it came through and has no session; the
+      // phone that authorizes has the session and mints the key but never saw
+      // this terminal. Sending it here is what lets the minted key name its
+      // origin. An older server ignores the extra field.
+      body: JSON.stringify({ cliPublicKey, installSource: reportedInstallSource() }),
       signal: AbortSignal.timeout(1e4)
     });
     if (!res.ok) return null;
@@ -687,6 +785,8 @@ var connectViaAppPairing = async (options = {}) => {
 export {
   reachVerdict,
   describeReach,
+  verifyRoundTrip,
+  describeRoundTrip,
   setHumanStream,
   fetchChannels,
   connectDevice,

package/dist/{chunk-HPDLDQC5.js → chunk-DUYM5SHH.js}

@@ -5,6 +5,9 @@ import {
 import {
   installProxyDispatcher
 } from "./chunk-SAF6HGAA.js";
+import {
+  reportedInstallSource
+} from "./chunk-PPD3HHNJ.js";
 import {
   ACTION_BODY_MAX,
   DECISION_LINE_MAX,
@@ -20,7 +23,7 @@ import {
   policyArgForms,
   redactSecrets,
   redactSecretsDeep
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 import {
   getMachineId
 } from "./chunk-RN3NOEJF.js";
@@ -1033,6 +1036,12 @@ var reportEvent = async (event, options = {}) => {
         pid: event.pid ?? process.pid,
         repoKey: event.repoKey ?? repoKeyFor(),
         installMode: detectInstallMode(),
+        // How the binary was INVOKED this time and which front door produced the
+        // install are different questions, and only the second is attribution.
+        // A machine installed from the plugin marketplace that later runs
+        // `npx ... doctor` reports npx for that invocation and claude_plugin as
+        // its origin, permanently.
+        installSource: reportedInstallSource(),
         // Link-back for a phone-spawned session: forward the spawn id the daemon
         // set in the environment so the server can map spawnId -> sessionId.
         ...process.env.PUSHARY_SPAWN_ID ? { spawnId: process.env.PUSHARY_SPAWN_ID } : {},

package/dist/{chunk-NHKWU7MN.js → chunk-E6I3DBJW.js}

@@ -7,6 +7,9 @@ import {
 import {
   resolveShellRc
 } from "./chunk-BC3VCZ3E.js";
+import {
+  resolveInstallSourceFor
+} from "./chunk-PPD3HHNJ.js";
 import {
   configFilePath
 } from "./chunk-2UMNXADU.js";
@@ -116,7 +119,11 @@ var writeKey = (apiKey, options = {}) => {
   } else if (existing.kind === "unparseable") {
     configBackupPath = backupFile(configPath);
   }
-  writeJsonAtomic(configPath, { ...current, apiKey }, KEY_FILE_MODE);
+  writeJsonAtomic(
+    configPath,
+    { ...current, apiKey, installSource: resolveInstallSourceFor(current) },
+    KEY_FILE_MODE
+  );
   restrictFile(configPath);
   const target = (options.resolveRc ?? resolveRcTarget)();
   const rc = target ? rewriteRcExport(target.path, apiKey, target.shell) : rcResult("no-rc");

package/dist/{chunk-DLBW37U6.js → chunk-EBP4YG75.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-7QLSKOSU.js";
 import {
   isValidApiKey
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 import {
   getBaseUrl
 } from "./chunk-2UMNXADU.js";

package/dist/{chunk-NQTRA7H5.js → chunk-GQLB2GBJ.js}

@@ -1,9 +1,9 @@
-import {
-  getPackageVersion
-} from "./chunk-7OYGFJYZ.js";
 import {
   getMachineId
 } from "./chunk-RN3NOEJF.js";
+import {
+  getPackageVersion
+} from "./chunk-ZUKH2NPJ.js";
 import {
   getBaseUrl
 } from "./chunk-2UMNXADU.js";

package/dist/{chunk-IA5GBKNL.js → chunk-MHA2WB7S.js}

@@ -1,6 +1,6 @@
 import {
   isSafeReadOnlyCommand
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 
 // src/ledger.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from "fs";

package/dist/chunk-PPD3HHNJ.js

@@ -0,0 +1,44 @@
+import {
+  normalizeInstallSource
+} from "./chunk-T6BNEQ2A.js";
+import {
+  configFilePath
+} from "./chunk-2UMNXADU.js";
+
+// src/install-source.ts
+import { readFileSync } from "fs";
+var ENV_OVERRIDE = "PUSHARY_INSTALL_SOURCE";
+var PLUGIN_ROOT = "CLAUDE_PLUGIN_ROOT";
+var EDITOR_PLUGIN_MARKERS = ["cursor-plugin", "vscode-plugin"];
+var detectInstallSource = (env = process.env, argv = process.argv) => {
+  const declared = env[ENV_OVERRIDE]?.trim();
+  if (declared) return normalizeInstallSource(declared);
+  const pluginRoot = env[PLUGIN_ROOT]?.trim();
+  if (pluginRoot) {
+    return EDITOR_PLUGIN_MARKERS.some((marker) => pluginRoot.includes(marker)) ? "editor_plugin" : "claude_plugin";
+  }
+  const entry = argv[1] ?? "";
+  if (entry.includes("_npx")) return "npx";
+  if (entry) return "npm";
+  return "unknown";
+};
+var storedInstallSource = () => {
+  try {
+    const parsed = JSON.parse(readFileSync(configFilePath(), "utf-8"));
+    const stored = parsed.installSource;
+    return typeof stored === "string" && stored ? normalizeInstallSource(stored) : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var resolveInstallSourceFor = (config) => {
+  const stored = config.installSource;
+  if (typeof stored === "string" && stored) return normalizeInstallSource(stored);
+  return detectInstallSource();
+};
+var reportedInstallSource = () => storedInstallSource() ?? detectInstallSource();
+
+export {
+  resolveInstallSourceFor,
+  reportedInstallSource
+};

package/dist/{chunk-QCYN5VXB.js → chunk-Q4QULGAV.js}

@@ -1,6 +1,6 @@
 import {
   HOOK_BUDGETS
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 
 // src/codex-config.ts
 import { createHash } from "crypto";

package/dist/{chunk-3CBPY2G5.js → chunk-R6AYBATA.js}

@@ -1,6 +1,6 @@
 import {
   HOOK_BUDGETS
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 
 // src/claude-config.ts
 import { join } from "path";

package/dist/{chunk-BBK3TTU2.js → chunk-RRZZ7TFJ.js}

@@ -1,7 +1,7 @@
 import {
   getPackageVersion,
   renderCommandHelp
-} from "./chunk-7OYGFJYZ.js";
+} from "./chunk-ZUKH2NPJ.js";
 import {
   EXIT
 } from "./chunk-KZERVKTD.js";

package/dist/{chunk-TJJBF73A.js → chunk-T6BNEQ2A.js}

@@ -1,6 +1,28 @@
 // ../contracts/src/index.ts
 var APPROVAL_MODES = ["push_only", "terminal_only", "push_first", "notify_only"];
 var isApprovalMode = (value) => typeof value === "string" && APPROVAL_MODES.includes(value);
+var INSTALL_SOURCES = [
+  /** `npx @pushary/agent-hooks@latest ...`, the documented one-liner. */
+  "npx",
+  /** A global or project npm install, invoked as `pushary`. */
+  "npm",
+  /** Claude Code plugin, from the marketplace. Detected via CLAUDE_PLUGIN_ROOT. */
+  "claude_plugin",
+  /** Cursor or VS Code plugin bundle. */
+  "editor_plugin",
+  /** Installed by the skills.sh wizard. */
+  "skills_sh",
+  /** An MCP client configured straight from the registry entry, no CLI involved. */
+  "mcp_registry",
+  /** One of the published framework adapters (ai-sdk, mastra, langgraph, ...). */
+  "framework_adapter",
+  /** The browser onboarding wizard. */
+  "dashboard",
+  /** Reported nothing, or reported something we do not recognise. */
+  "unknown"
+];
+var isInstallSource = (value) => typeof value === "string" && INSTALL_SOURCES.includes(value);
+var normalizeInstallSource = (value) => isInstallSource(value) ? value : "unknown";
 var HOOK_BUDGETS = {
   claude: { budgetSeconds: 120, guardSeconds: 10 },
   codex: { budgetSeconds: 180, guardSeconds: 10 },
@@ -760,6 +782,7 @@ var isScopeContract = (value) => {
 
 export {
   isApprovalMode,
+  normalizeInstallSource,
   HOOK_BUDGETS,
   hookWaitDeadline,
   hookWaitClamped,

package/dist/{chunk-7BBUTWBD.js → chunk-U2PZKYZM.js}

@@ -1,7 +1,7 @@
 import {
   describeKeyCheck,
   keyCheckFromResponse
-} from "./chunk-DLBW37U6.js";
+} from "./chunk-EBP4YG75.js";
 import {
   createIo
 } from "./chunk-TX7KBKT7.js";

package/dist/{chunk-46UEJXQO.js → chunk-UBUPETEQ.js}

@@ -1,9 +1,9 @@
 import {
   hasGeminiHooks
-} from "./chunk-CC2K2SST.js";
+} from "./chunk-7DYFAM32.js";
 import {
   hasCodexHooks
-} from "./chunk-QCYN5VXB.js";
+} from "./chunk-Q4QULGAV.js";
 
 // src/diagnostics/wiring.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;

package/dist/{chunk-NN4GTN6Q.js → chunk-ULITFWLG.js}

@@ -1,11 +1,15 @@
 import {
   PRETOOLUSE_HANDLED_TOOLS
-} from "./chunk-3CBPY2G5.js";
+} from "./chunk-R6AYBATA.js";
+import {
+  isGatingMoment,
+  recordKeylessMoment
+} from "./chunk-MHA2WB7S.js";
 import {
   denyReasonFrom,
   isDeferAnswer,
   resolveGate
-} from "./chunk-FWWBEB6L.js";
+} from "./chunk-A5DAEWBZ.js";
 import {
   DEFAULT_SESSION,
   askUser,
@@ -25,17 +29,13 @@ import {
   sendNotification,
   throttlePass,
   waitForAnswer
-} from "./chunk-HPDLDQC5.js";
-import {
-  isGatingMoment,
-  recordKeylessMoment
-} from "./chunk-IA5GBKNL.js";
+} from "./chunk-DUYM5SHH.js";
 import {
   buildDecisionEpisodeFeatures,
   effectiveWaitSeconds,
   hookWaitClamped,
   hookWaitDeadline
-} from "./chunk-TJJBF73A.js";
+} from "./chunk-T6BNEQ2A.js";
 import {
   getMachineId
 } from "./chunk-RN3NOEJF.js";