@pushary/agent-hooks 0.94.0 → 0.95.1

package/dist/{chunk-YANV5TGK.js → chunk-YPYPI6BG.js}

@@ -1,12 +1,9 @@
 import {
   openCodeConfigDirFrom
-} from "./chunk-BSEAOCCQ.js";
+} from "./chunk-IZRI4M3C.js";
 import {
   codexHomeFrom
-} from "./chunk-Y6XXFXVB.js";
-import {
-  HOOK_LOCATOR_BINARY
-} from "./chunk-Z6CP5ZZD.js";
+} from "./chunk-3F4VV5TS.js";
 
 // src/vscode-config.ts
 import { homedir } from "os";
@@ -265,12 +262,13 @@ var instructionBody = (label) => `## Pushary notifications and approvals
 
 You have Pushary MCP tools that reach the user on their phone. Use them proactively. Do not wait for the user to ask.
 
-- When you need the user to make a decision or answer a clarifying question, call \`ask_user\` instead of guessing or stalling. Use type "confirm" for yes/no, "select" for a fixed set of options, and "input" for free text. \`ask_user\` blocks until the user replies or it times out, so you do not need a separate wait step.
+- When you need the user to make a decision or answer a clarifying question, call \`ask_user\` instead of guessing or stalling. Use type "confirm" for yes/no, "select" for a fixed set of options, and "input" for free text. Read \`answered\`, \`status\` and the returned handoff instead of assuming the tool blocked. Silence is not consent; choice/text answers do not authorize a separate action.
 - Ask once, on one channel. If you also have a built-in way to prompt the user, use that or \`ask_user\` for a given question, never both. \`ask_user\` is the one that reaches the user when they are away from this machine, so prefer it. Raising both strands the user in whichever prompt you are not waiting on.
-- Before any risky or irreversible step (deleting files, force pushing, spending money, sending external messages), call \`ask_user\` with type "confirm" and wait for approval.
-- Before starting a multi-step run that will change several files, call \`propose_scope\` once with the paths you expect to change, anything you promise not to touch, and what done means. The user agrees to the boundary in one tap. A ratified boundary NARROWS what may proceed without asking, it does not pre-approve work inside it, so an action that would normally need approval still needs it. Skip it for a single quick edit, and do not propose a new scope mid-run just to widen one: if you need to go outside the agreed scope, do the work and let the approval that follows widen it.
+- Honor authorization already granted in this session. Ask before a risky or irreversible action outside that authorization, or when an enforced host policy requires it. Do not ask again for an already authorized step, and never bypass an enforced gate.
+- Call \`propose_scope\` only for an unresolved or requested file boundary. A ratified scope narrows what may proceed; it does not bypass other approval rules. Do not add a plan approval merely because work spans several files, and do not propose a new scope mid-run just to widen it. Let the installed gate request any scope expansion before the edit executes.
 - When you are blocked, stuck, or hit an error you cannot resolve on your own, call \`send_notification\` so the user knows, and call \`ask_user\` if you need a decision to continue.
-- When a task that took several steps finishes, call \`send_notification\` so the user knows it is done. Always pass \`context\` with a \`type\` of "task_complete", "error" or "info": it is what tells Pushary this is a task update, so the user's own setting for where updates land can route it.
+- When meaningful work finishes while the user is away, or they requested an alert, call \`send_notification\` so the user knows it is done. Skip trivial completions and duplicate reports to someone already reading. Always pass \`context\` with a \`type\` of "task_complete", "error" or "info": it is what tells Pushary this is a task update, so the user's own setting for where updates land can route it.
+- Confirm notifications can offer lock-screen actions; arbitrary choices and text open the app. The Mac notch handles personal account questions, not Partner customer enrollment.
 - Use \`cancel_question\` to retract a pending question once it is no longer needed.
 - Respect the user's Pushary delivery mode: it decides where an approval is surfaced (phone, terminal, or awareness only), not whether it is required. In Terminal mode do not expect a phone answer; the approval waits in the terminal. If the Pushary hook already gated an action, a single approval is enough, do not ask again.
 
@@ -332,82 +330,6 @@ var hasInstructionBlock = (filePath) => {
 // src/hooks-spec.ts
 var CURSOR_GATE_SCRIPT = "pushary-gate.mjs";
 
-// src/diagnostics/bridge.ts
-import { execFileSync } from "child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join3 } from "path";
-var BRIDGE_BUNDLE_IDENTIFIER = "com.pushary.app";
-var BRIDGE_HELPER_SUFFIX = "/Contents/Helpers/pushary-bridge";
-var BRIDGE_BUNDLE_ROOTS = ["/Applications/Pushary.app", "$HOME/Applications/Pushary.app"];
-var expandHome = (path, home) => path.replaceAll("$HOME", home);
-var parseBridgeStub = (contents, stubPath) => {
-  const helperSuffix = contents.match(/^H=(\S+)$/m)?.[1] ?? BRIDGE_HELPER_SUFFIX;
-  const cachePath = contents.match(/^C="([^"\n]+)"$/m)?.[1] ?? join3(dirname3(stubPath), ".bridge-cache");
-  const rootsLine = contents.match(/^for P in ((?:"[^"\n]*"\s*)+); do$/m)?.[1];
-  const bundleRoots = rootsLine ? [...rootsLine.matchAll(/"([^"]*)"/g)].map((match) => match[1]) : BRIDGE_BUNDLE_ROOTS;
-  const bundleIdentifier = contents.match(/kMDItemCFBundleIdentifier == "([^"]+)"/)?.[1] ?? BRIDGE_BUNDLE_IDENTIFIER;
-  return { helperSuffix, cachePath, bundleRoots, bundleIdentifier };
-};
-var resolveBridgeStub = (stubPath, probe) => {
-  const contents = probe.readFile(stubPath);
-  if (contents === null) return { kind: "no-stub", stub: stubPath };
-  const shape = parseBridgeStub(contents, stubPath);
-  const helperIn = (bundle) => `${bundle}${shape.helperSuffix}`;
-  const looked = [];
-  for (const root of shape.bundleRoots.map((root2) => expandHome(root2, probe.home))) {
-    looked.push(root);
-    if (probe.exists(helperIn(root))) return { kind: "bundle", helper: helperIn(root), via: "root" };
-  }
-  const cached = shape.cachePath ? probe.readFile(shape.cachePath)?.split("\n")[0]?.trim() : void 0;
-  if (cached) {
-    looked.push(cached);
-    if (probe.exists(helperIn(cached))) return { kind: "bundle", helper: helperIn(cached), via: "cache" };
-  }
-  for (const found of probe.mdfind(shape.bundleIdentifier)) {
-    looked.push(found);
-    if (probe.exists(helperIn(found))) return { kind: "bundle", helper: helperIn(found), via: "spotlight" };
-  }
-  return { kind: "missing", stub: stubPath, looked };
-};
-var BRIDGE_GONE_MESSAGE = "the Mac app is gone but its hooks remain; run pushary setup or reinstall the app";
-var describeBridgeResolution = (resolution) => {
-  switch (resolution.kind) {
-    case "bundle":
-      return `${resolution.helper} (${resolution.via === "root" ? "installed" : resolution.via === "cache" ? "cached path" : "found by Spotlight"})`;
-    case "missing":
-      return BRIDGE_GONE_MESSAGE;
-    case "no-stub":
-      return `${resolution.stub} is not there; ${BRIDGE_GONE_MESSAGE}`;
-  }
-};
-var isBridgeLocator = (executable) => executable !== null && executable.split(/[/\\]/).pop() === HOOK_LOCATOR_BINARY;
-var spotlight = (bundleIdentifier) => {
-  if (process.platform !== "darwin") return [];
-  try {
-    return execFileSync("/usr/bin/mdfind", [`kMDItemCFBundleIdentifier == "${bundleIdentifier}"`], {
-      encoding: "utf-8",
-      timeout: 5e3,
-      stdio: ["ignore", "pipe", "ignore"]
-    }).split("\n").map((line) => line.trim()).filter((line) => line !== "");
-  } catch {
-    return [];
-  }
-};
-var readOrNull = (path) => {
-  try {
-    return readFileSync2(path, "utf-8");
-  } catch {
-    return null;
-  }
-};
-var liveBridgeProbe = () => ({
-  exists: existsSync3,
-  readFile: readOrNull,
-  mdfind: spotlight,
-  home: homedir3()
-});
-
 export {
   registerPluginLocation,
   unregisterPluginLocation,
@@ -425,9 +347,5 @@ export {
   writeInstructionBlock,
   removeInstructionBlock,
   hasInstructionBlock,
-  CURSOR_GATE_SCRIPT,
-  resolveBridgeStub,
-  describeBridgeResolution,
-  isBridgeLocator,
-  liveBridgeProbe
+  CURSOR_GATE_SCRIPT
 };

package/dist/{chunk-6WYL3XIP.js → chunk-ZOR5OJZJ.js}

@@ -1,20 +1,21 @@
 import {
   readTranscriptPreference
-} from "./chunk-6BIMJIRG.js";
+} from "./chunk-JSASMV3H.js";
 
 // src/transcript-setting.ts
-var fromEnv = () => {
+var transcriptEnvironmentPreference = () => {
   const value = process.env.PUSHARY_TRANSCRIPTS?.trim().toLowerCase();
   if (!value) return null;
   if (["0", "false", "off"].includes(value)) return false;
   if (["1", "true", "on"].includes(value)) return true;
   return null;
 };
-var configuredPreference = () => fromEnv() ?? readTranscriptPreference();
+var configuredPreference = () => transcriptEnvironmentPreference() ?? readTranscriptPreference();
 var transcriptsEnabled = () => configuredPreference() ?? false;
 var transcriptPreferenceForSetup = (explicit = null) => explicit ?? configuredPreference() ?? true;
 
 export {
+  transcriptEnvironmentPreference,
   transcriptsEnabled,
   transcriptPreferenceForSetup
 };

package/dist/chunk-ZW3KAWTM.js

@@ -0,0 +1,266 @@
+import {
+  isBridgeLocator
+} from "./chunk-77U3ZVV6.js";
+import {
+  pusharyHookExecutable
+} from "./chunk-IFCS6LXB.js";
+import {
+  BELL_HOOK_BINARY
+} from "./chunk-DSTLA2TC.js";
+import {
+  parseFlags
+} from "./chunk-GMXKITVA.js";
+import {
+  UsageError
+} from "./chunk-7QLSKOSU.js";
+import {
+  isValidApiKey
+} from "./chunk-VOWZ5VOO.js";
+
+// src/setup/options.ts
+var AGENT_CHOICES = ["claude_code", "codex", "gemini_cli", "hermes", "cursor", "vscode", "opencode", "custom"];
+var CONNECT_MODES = ["app", "browser", "web", "none"];
+var CONNECT_ALIASES = { auto: "app", pwa: "web" };
+var parseConnectMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (Object.hasOwn(CONNECT_ALIASES, value)) return CONNECT_ALIASES[value];
+  if (CONNECT_MODES.includes(value)) return value;
+  throw new UsageError(`--connect must be one of: ${CONNECT_MODES.join(", ")} (got ${raw})`);
+};
+var VERIFY_MODES = ["roundtrip", "push", "none"];
+var parseVerifyMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (VERIFY_MODES.includes(value)) return value;
+  throw new UsageError(`--verify must be one of: ${VERIFY_MODES.join(", ")} (got ${raw})`);
+};
+var CONTROL_MODES = ["auto", "on", "off"];
+var parseControlMode = (raw) => {
+  const value = raw.trim().toLowerCase();
+  if (CONTROL_MODES.includes(value)) return value;
+  throw new UsageError(`--control must be one of: ${CONTROL_MODES.join(", ")} (got ${raw})`);
+};
+var effectiveVerify = (options, context) => {
+  if (options.verifyExplicit) return options.verify;
+  if (options.verify === "roundtrip") return "roundtrip";
+  return context.paired ? "roundtrip" : options.verify;
+};
+var SETUP_FLAGS = {
+  bools: ["key-stdin", "skip-phone", "yes", "y", "json", "dry-run", "take-over-hooks", "help", "h"],
+  values: ["key", "connect", "agents", "verify", "control", "transcripts"]
+};
+var effectiveControlMode = (options, stored, configPresent) => options.controlExplicit ? options.control : stored ?? (configPresent ? null : options.control);
+var isAgentChoice = (value) => AGENT_CHOICES.includes(value);
+var parseAgentSelection = (raw, yes) => {
+  if (raw === void 0) {
+    return yes ? { kind: "auto" } : { kind: "ask" };
+  }
+  const value = raw.trim().toLowerCase();
+  if (value === "auto") return { kind: "auto" };
+  if (value === "none") return { kind: "none" };
+  const parts = value.split(",").map((part) => part.trim()).filter((part) => part !== "");
+  if (parts.length === 0) throw new UsageError("--agents needs a value");
+  const unknown = parts.filter((part) => !isAgentChoice(part));
+  if (unknown.length > 0) {
+    throw new UsageError(
+      `--agents does not know: ${unknown.join(", ")}. Use auto, none, or any of: ${AGENT_CHOICES.join(", ")}`
+    );
+  }
+  return { kind: "explicit", agents: [...new Set(parts)] };
+};
+var parseSetupOptions = (input) => {
+  const flags = parseFlags(input.argv, SETUP_FLAGS);
+  const stray = [
+    ...flags.command !== void 0 && flags.command !== "setup" ? [flags.command] : [],
+    ...flags.rest
+  ];
+  if (stray.length > 0) {
+    throw new UsageError(
+      `setup takes no positional arguments (got ${stray.join(", ")}). Did you mean --agents ${stray[0]}?`
+    );
+  }
+  const yes = flags.bools.has("yes") || flags.bools.has("y");
+  const help = flags.bools.has("help") || flags.bools.has("h");
+  const agentsFlag = flags.values.get("agents");
+  const agents = parseAgentSelection(agentsFlag, yes);
+  const connectRaw = flags.values.get("connect");
+  const connectMode = connectRaw === void 0 ? "app" : parseConnectMode(connectRaw);
+  const verifyRaw = flags.values.get("verify");
+  const controlRaw = flags.values.get("control");
+  const transcriptsRaw = flags.values.get("transcripts")?.trim().toLowerCase();
+  if (transcriptsRaw !== void 0 && transcriptsRaw !== "on" && transcriptsRaw !== "off") {
+    throw new UsageError(`--transcripts must be one of: on, off (got ${transcriptsRaw})`);
+  }
+  const nonInteractive = yes || agentsFlag !== void 0 || flags.bools.has("json") || !input.stdinIsTty;
+  const verify = verifyRaw !== void 0 ? parseVerifyMode(verifyRaw) : nonInteractive ? "push" : "roundtrip";
+  const key = flags.values.get("key")?.trim() || null;
+  const keyStdin = flags.bools.has("key-stdin");
+  if (key && keyStdin) {
+    throw new UsageError("Pass either --key or --key-stdin, not both");
+  }
+  if (key && !isValidApiKey(key)) {
+    throw new UsageError("--key is not a valid API key. Expected the pk_xxx.xxx shape from pushary.com/dashboard/agent/settings");
+  }
+  return {
+    connectMode,
+    connectExplicit: connectRaw !== void 0,
+    // `--connect none` and `--skip-phone` are the same instruction, so they
+    // resolve to the same field rather than being checked separately at the two
+    // call sites that would inevitably drift apart.
+    skipPhone: flags.bools.has("skip-phone") || connectMode === "none",
+    // Anything that means "there is nobody to answer a prompt". A non-TTY stdin
+    // is included because that is the case that used to hang: it is better to
+    // take the defaults and say so than to wait forever for a keypress.
+    //
+    // --json counts. Under it stdout carries exactly one object and every human
+    // line is redirected to stderr, so a prompt has nowhere to render: the
+    // question goes to stderr while the run blocks on a keypress the caller
+    // cannot see it is waiting for, and whatever is reading stdout waits forever
+    // for an object that never arrives. Asking for machine-readable output is
+    // itself a statement that no human is watching.
+    nonInteractive,
+    json: flags.bools.has("json"),
+    dryRun: flags.bools.has("dry-run"),
+    help,
+    agents,
+    key,
+    keyStdin,
+    verify,
+    verifyExplicit: verifyRaw !== void 0,
+    control: controlRaw === void 0 ? "auto" : parseControlMode(controlRaw),
+    controlExplicit: controlRaw !== void 0,
+    transcripts: transcriptsRaw === void 0 ? null : transcriptsRaw === "on",
+    takeOverHooks: flags.bools.has("take-over-hooks")
+  };
+};
+
+// src/setup/hook-ownership.ts
+var commandsIn = (value) => {
+  if (Array.isArray(value)) return value.flatMap(commandsIn);
+  if (!value || typeof value !== "object") return [];
+  return Object.entries(value).flatMap(([key, item]) => key === "command" && typeof item === "string" ? [item] : commandsIn(item));
+};
+var isRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var hasPaidPusharyCommand = (value) => commandsIn(value).some((command) => {
+  const executable = pusharyHookExecutable(command);
+  const name = executable?.split(/[/\\]/).pop()?.replace(/\.(cmd|exe|mjs)$/i, "");
+  return executable !== null && !isBridgeLocator(executable) && name !== BELL_HOOK_BINARY;
+});
+var hasAppCommand = (value) => commandsIn(value).some((command) => {
+  const executable = pusharyHookExecutable(command);
+  return executable !== null && isBridgeLocator(executable);
+});
+var mcpBearerKey = (document, containerKey, headersKey) => {
+  const servers = isRecord(document?.[containerKey]) ? document[containerKey] : null;
+  const pushary = isRecord(servers?.pushary) ? servers.pushary : null;
+  const headers = isRecord(pushary?.[headersKey]) ? pushary[headersKey] : null;
+  const authorization = headers?.Authorization;
+  const match = typeof authorization === "string" ? authorization.trim().match(/^Bearer\s+(\S+)$/) : null;
+  return match?.[1] ?? null;
+};
+var captureMcpServer = (document, containerKey) => {
+  const container = document[containerKey];
+  const servers = isRecord(container) ? container : null;
+  if (!servers && Object.hasOwn(document, containerKey)) {
+    return { present: false, containerValue: structuredClone(container) };
+  }
+  return servers && Object.hasOwn(servers, "pushary") ? { present: true, value: structuredClone(servers.pushary) } : { present: false };
+};
+var restoreMcpServer = (document, containerKey, snapshot) => {
+  const before = JSON.stringify(document);
+  const existing = isRecord(document[containerKey]) ? document[containerKey] : null;
+  if (snapshot.present) {
+    const servers = existing ?? {};
+    servers.pushary = structuredClone(snapshot.value);
+    document[containerKey] = servers;
+  } else if (Object.hasOwn(snapshot, "containerValue")) {
+    document[containerKey] = structuredClone(snapshot.containerValue);
+  } else if (existing && Object.hasOwn(existing, "pushary")) {
+    delete existing.pushary;
+    if (Object.keys(existing).length === 0) delete document[containerKey];
+  }
+  return JSON.stringify(document) !== before;
+};
+var captureHookTakeover = (agent, document) => {
+  const hooks = isRecord(document?.hooks) ? document.hooks : null;
+  if (!hooks) return null;
+  const captured = {};
+  for (const [event, entries] of Object.entries(hooks)) {
+    if (!Array.isArray(entries)) continue;
+    const appEntries = entries.flatMap((value, index) => isRecord(value) && hasAppCommand(value) ? [{ index, value: structuredClone(value) }] : []);
+    if (appEntries.length > 0) captured[event] = appEntries;
+  }
+  return Object.keys(captured).length > 0 ? { version: 1, agent, hooks: captured } : null;
+};
+var isHookTakeoverReceipt = (value) => {
+  if (!isRecord(value) || value.version !== 1 || typeof value.agent !== "string" || !AGENT_CHOICES.includes(value.agent) || !isRecord(value.hooks)) return false;
+  const expectsMcp = ["claude_code", "codex", "gemini_cli", "vscode"].includes(value.agent);
+  if (value.mcpServer !== void 0 !== expectsMcp) return false;
+  if (value.codexTrust !== void 0 !== (value.agent === "codex")) return false;
+  if (value.codexTrust !== void 0 && !isRecord(value.codexTrust)) return false;
+  if (value.mcpServer !== void 0 && (!isRecord(value.mcpServer) || typeof value.mcpServer.present !== "boolean" || value.mcpServer.present && !Object.hasOwn(value.mcpServer, "value"))) return false;
+  return Object.values(value.hooks).every((entries) => Array.isArray(entries) && entries.length > 0 && entries.every((item) => isRecord(item) && Number.isInteger(item.index) && item.index >= 0 && isRecord(item.value)));
+};
+var restoreHookTakeover = (document, receipt) => {
+  const before = JSON.stringify(document);
+  const appOwnsNow = hookOwnerOf(document) === "app";
+  const hooks = isRecord(document.hooks) ? document.hooks : {};
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) continue;
+    const kept = value.filter((entry) => !hasPaidPusharyCommand(entry));
+    if (kept.length === 0) delete hooks[event];
+    else hooks[event] = kept;
+  }
+  if (!appOwnsNow) {
+    for (const [event, snapshots] of Object.entries(receipt.hooks)) {
+      const entries = Array.isArray(hooks[event]) ? [...hooks[event]] : [];
+      for (const snapshot of snapshots) {
+        entries.splice(Math.min(snapshot.index, entries.length), 0, structuredClone(snapshot.value));
+      }
+      hooks[event] = entries;
+    }
+  }
+  document.hooks = hooks;
+  return JSON.stringify(document) !== before;
+};
+var hookOwnerOf = (document, appAvailable = true) => {
+  const hooks = document && typeof document === "object" ? document.hooks : void 0;
+  const executables = commandsIn(hooks).map(pusharyHookExecutable).filter((executable) => executable !== null);
+  if (appAvailable && executables.some(isBridgeLocator)) return "app";
+  if (executables.some((executable) => !isBridgeLocator(executable))) return "cli";
+  return "none";
+};
+var planHooks = (context) => {
+  if (context.owner !== "app") return "install";
+  if (context.takeOverHooks) return "install";
+  return "keep";
+};
+var describeAppOwnership = (agentName) => `The Pushary Mac app owns ${agentName}'s hooks.`;
+var KEEP_HINT = "Kept with the app's account. Pass --take-over-hooks to have the CLI own them instead.";
+var OWNER_LABELS = {
+  app: "the Pushary Mac app",
+  cli: "the CLI"
+};
+var describeHookOwnership = (entries, names) => {
+  const owned = entries.filter((entry) => entry.owner !== "none");
+  if (owned.length === 0) return null;
+  const parts = owned.map((entry) => `${names[entry.agent]} by ${OWNER_LABELS[entry.owner]}${entry.kept ? " (kept)" : ""}`);
+  return `Hooks: ${parts.join(", ")}.`;
+};
+
+export {
+  AGENT_CHOICES,
+  effectiveVerify,
+  effectiveControlMode,
+  parseSetupOptions,
+  mcpBearerKey,
+  captureMcpServer,
+  restoreMcpServer,
+  captureHookTakeover,
+  isHookTakeoverReceipt,
+  restoreHookTakeover,
+  hookOwnerOf,
+  planHooks,
+  describeAppOwnership,
+  KEEP_HINT,
+  describeHookOwnership
+};

package/dist/src/index.js

@@ -1,12 +1,12 @@
 import {
   handlePreToolUse
-} from "../chunk-QKNLW7H6.js";
+} from "../chunk-Y24D5ZWS.js";
+import "../chunk-C2MV4G4A.js";
+import "../chunk-UQSKCQBO.js";
+import "../chunk-YHG74UFF.js";
 import {
   fetchAccountPublicKey
 } from "../chunk-EQRS3SGM.js";
-import "../chunk-OYNPLEXP.js";
-import "../chunk-2ORRI66J.js";
-import "../chunk-YHG74UFF.js";
 import {
   fetchModeOverride,
   fetchModeState,
@@ -15,21 +15,21 @@ import {
   handlePostToolUse,
   handleStop,
   reportEvent
-} from "../chunk-5HGLZGI4.js";
+} from "../chunk-J55K6YS4.js";
 import {
   askUser,
   cancelQuestion,
   waitForAnswer
 } from "../chunk-RER3FRTD.js";
-import "../chunk-4PE2SQVM.js";
-import "../chunk-Y3UGCQQC.js";
-import "../chunk-NVPYRDCT.js";
-import "../chunk-Y6XXFXVB.js";
+import "../chunk-VLKEAYJ4.js";
+import "../chunk-TTO76NZJ.js";
+import "../chunk-SSQ5X6SA.js";
+import "../chunk-3F4VV5TS.js";
 import "../chunk-EYRGBYZG.js";
 import "../chunk-SAF6HGAA.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
-import "../chunk-ODL52O5V.js";
+import "../chunk-T5B3LRYF.js";
 import "../chunk-4LL6LG5X.js";
 import {
   getApiKey,
@@ -37,7 +37,7 @@ import {
 } from "../chunk-2UMNXADU.js";
 import {
   resolvePolicy
-} from "../chunk-Z6CP5ZZD.js";
+} from "../chunk-VOWZ5VOO.js";
 export {
   askUser,
   cancelQuestion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.94.0",
+  "version": "0.95.1",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "keywords": [
     "pushary",
@@ -73,7 +73,8 @@
     "pushary-bell": "./dist/bin/pushary-bell.js",
     "pushary-bell-hook": "./dist/bin/pushary-bell-hook.js",
     "pushary-disconnect": "./dist/bin/pushary-disconnect.js",
-    "pushary-transcripts": "./dist/bin/pushary-transcripts.js"
+    "pushary-transcripts": "./dist/bin/pushary-transcripts.js",
+    "pushary-transcript-register": "./dist/bin/pushary-transcript-register.js"
   },
   "files": [
     "dist",