@pushary/agent-hooks 1.9.63 → 1.9.65

package/dist/chunk-ATPJGHUP.js

@@ -0,0 +1,1201 @@
+import {
+  atLeast,
+  formatVersion,
+  quoteIfNeeded,
+  shellDoubleQuoted,
+  writeFileAtomic
+} from "./chunk-SCMEVDAR.js";
+import {
+  CLAUDE_PRETOOLUSE_MATCHER,
+  CODEX_QUESTION_TOOLS,
+  HOOK_BUDGETS,
+  HOOK_LOCATOR_BINARY,
+  PRETOOLUSE_GATED_TOOLS,
+  withHookHoldBudget
+} from "./chunk-MNKIR2ZB.js";
+
+// src/setup/paths.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/claude-config-paths.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+var claudeConfigDir = (home = homedir(), environment = process.env) => resolve(environment.CLAUDE_CONFIG_DIR || join(home, ".claude"));
+var claudeUserConfigFile = (home = homedir(), environment = process.env) => join(environment.CLAUDE_CONFIG_DIR ? claudeConfigDir(home, environment) : home, ".claude.json");
+
+// src/setup/paths.ts
+import { homedir as homedir3 } from "os";
+import { join as join5 } from "path";
+
+// src/codex-config.ts
+import { createHash } from "crypto";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+
+// src/registration-holder.ts
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var registeredCommands = (document) => {
+  const hooks = asRecord(document?.hooks);
+  if (!hooks) return [];
+  const found = [];
+  for (const [event, value] of Object.entries(hooks)) {
+    if (!Array.isArray(value)) continue;
+    for (const item of value) {
+      const inner = asRecord(item)?.hooks;
+      if (!Array.isArray(inner)) continue;
+      for (const hook of inner) {
+        const command = asRecord(hook)?.command;
+        if (typeof command === "string") found.push({ event, command });
+      }
+    }
+  }
+  return found;
+};
+var wholeSegments = (command) => command.split(/[\s/\\"']+/).map((segment) => segment.replace(/\.(cmd|exe)$/i, ""));
+var namesLocator = (command) => wholeSegments(command).includes(HOOK_LOCATOR_BINARY);
+var namesCliBinary = (command, cliBinaries) => wholeSegments(command).some((segment) => cliBinaries.has(segment));
+var namesOurBinary = (command, cliBinaries) => namesLocator(command) || namesCliBinary(command, cliBinaries);
+var registrationHolderOf = (document, cliBinaries) => {
+  const commands = registeredCommands(document);
+  if (commands.some(({ command }) => namesLocator(command))) return "app";
+  return commands.some(({ command }) => namesCliBinary(command, cliBinaries)) ? "cli" : "none";
+};
+
+// src/hook-command.ts
+var HOOK_SHELL = "/bin/sh -c";
+var holdBudgetOf = (hook) => hook.holds ? hook.timeout : void 0;
+var LOCATE = 'B=$(command -v "$0") || exit 0; [ -f "$B" ] || exit 0; [ -x "$B" ] || exit 0';
+var NODE_PRESENT = "command -v node >/dev/null 2>&1 || exit 0";
+var CURSOR_NO_OPINION = { permission: "deny", user_message: "Command denied via Pushary.", agent_message: "Pushary hook is unavailable. Repair the integration before retrying." };
+var CURSOR_NATIVE_PROMPT = { permission: "ask" };
+var CURSOR_NATIVE_PROMPT_EVENTS = ["beforeShellExecution", "beforeMCPExecution"];
+var hookEventIsOneOf = (events) => events.flatMap((event) => [`*\\"hook_event_name\\":\\"${event}\\"*`, `*\\"hook_event_name\\":\\ \\"${event}\\"*`]).join("|");
+var CURSOR_MISS = `{ E=$(cat); case "$E" in ${hookEventIsOneOf(CURSOR_NATIVE_PROMPT_EVENTS)}) printf %s ${shellDoubleQuoted(JSON.stringify(CURSOR_NATIVE_PROMPT))} ;; *) printf %s ${shellDoubleQuoted(JSON.stringify(CURSOR_NO_OPINION))} ;; esac; exit 0; }`;
+var HOOK_GUARD_SCRIPTS = {
+  native_binary: `${LOCATE}; exec "$B" "$@"`,
+  node_binary: `${LOCATE}; ${NODE_PRESENT}; exec "$B" "$@"`,
+  node_script: `[ -f "$0" ] || exit 0; ${NODE_PRESENT}; exec node "$0" "$@"`,
+  cursor_gate_script: `[ -f "$0" ] || ${CURSOR_MISS}; command -v node >/dev/null 2>&1 || ${CURSOR_MISS}; exec node "$0" "$@"`
+};
+var BINARY_GUARDS = {
+  native: "native_binary",
+  node: "node_binary"
+};
+var guardKindOf = (target) => {
+  switch (target.kind) {
+    case "node":
+      return "node_script";
+    case "cursor_gate":
+      return "cursor_gate_script";
+    case "binary":
+      return BINARY_GUARDS[target.runtime];
+  }
+};
+var targetPath = (target) => target.kind === "binary" ? target.path : target.script;
+var runsThroughNode = (target) => target.kind !== "binary";
+var guardHookCommand = (target, platform = process.platform) => {
+  const path = quoteIfNeeded(targetPath(target), platform);
+  if (platform === "win32") return runsThroughNode(target) ? `node ${path}` : path;
+  return `${HOOK_SHELL} '${HOOK_GUARD_SCRIPTS[guardKindOf(target)]}' ${path}`;
+};
+var guardBinary = (path, platform) => guardHookCommand({ kind: "binary", path, runtime: "node" }, platform);
+var SILENT_MISS = "exit 0";
+var REFUSE = "R";
+var definesRefusal = (refusal) => `${REFUSE}() { printf %s ${shellDoubleQuoted(refusal)}; exit 0; }`;
+var guardBinaryRefusing = (path, refusal, platform = process.platform) => {
+  if (platform === "win32") return guardBinary(path, platform);
+  const script = `${definesRefusal(refusal)}; ${HOOK_GUARD_SCRIPTS.node_binary.replaceAll(SILENT_MISS, REFUSE)}`;
+  return `${HOOK_SHELL} '${script}' ${quoteIfNeeded(path)}`;
+};
+var guardNodeScript = (script, platform) => guardHookCommand({ kind: "node", script }, platform);
+var guardCursorGate = (script, platform) => guardHookCommand({ kind: "cursor_gate", script }, platform);
+var guardedArgv = (target, args = [], platform = process.platform) => {
+  const path = targetPath(target);
+  if (platform === "win32") {
+    return runsThroughNode(target) ? ["node", path, ...args] : [path, ...args];
+  }
+  const [shell, ...shellArgs] = HOOK_SHELL.split(/\s+/);
+  return [shell, ...shellArgs, HOOK_GUARD_SCRIPTS[guardKindOf(target)], path, ...args];
+};
+
+// src/hook-entries.ts
+var registerHookEntry = (existing, isOurs, entry2) => {
+  const rewritten = [];
+  let placed = false;
+  for (const item of existing) {
+    if (!isOurs(item)) {
+      rewritten.push(item);
+      continue;
+    }
+    if (placed) continue;
+    rewritten.push(entry2);
+    placed = true;
+  }
+  if (!placed) rewritten.push(entry2);
+  return rewritten;
+};
+
+// src/removal-scope.ts
+var namesAppLocator = (command) => command.includes(HOOK_LOCATOR_BINARY);
+var isProtectedByScope = (command, scope) => scope?.keepAppWiring === true && namesAppLocator(command);
+
+// src/canonical-json.ts
+var canonicalJson = (value) => {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
+  const record = value;
+  return "{" + Object.keys(record).sort().map((key) => JSON.stringify(key) + ":" + canonicalJson(record[key])).join(",") + "}";
+};
+
+// src/codex-config.ts
+var CODEX_HOOK_BINARY = "pushary-codex-hook";
+var codexHome = () => codexHomeFrom(homedir2());
+var codexHomeFrom = (home) => process.env.CODEX_HOME?.trim() || join2(home, ".codex");
+var codexConfigToml = () => join2(codexHome(), "config.toml");
+var codexHooksJsonIn = (home) => join2(home, "hooks.json");
+var codexHooksJson = () => codexHooksJsonIn(codexHome());
+var codexAgentsMd = () => join2(codexHome(), "AGENTS.md");
+var codexSkillDir = () => join2(codexHome(), "skills", "pushary");
+var CODEX_TOOL_CALL_MATCHER = "Bash|apply_patch|mcp__.*";
+var CODEX_PRE_TOOL_USE_MATCHER = [CODEX_TOOL_CALL_MATCHER, ...CODEX_QUESTION_TOOLS].join("|");
+var CODEX_HOOK_EVENTS = [
+  { event: "PermissionRequest", delivery: "approval", timeout: HOOK_BUDGETS.codex.budgetSeconds, statusMessage: "Waiting for your phone" },
+  { event: "PreToolUse", matcher: CODEX_PRE_TOOL_USE_MATCHER, delivery: "approval", timeout: HOOK_BUDGETS.codex.budgetSeconds, statusMessage: "Checking Pushary policy" },
+  { event: "PostToolUse", matcher: CODEX_TOOL_CALL_MATCHER, delivery: "telemetry", timeout: 10 },
+  { event: "UserPromptSubmit", delivery: "telemetry", timeout: 10 },
+  { event: "Stop", delivery: "rescue", timeout: HOOK_BUDGETS.codex.budgetSeconds, holds: true },
+  // `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 },
+  // 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_REQUIRED_APPROVAL_EVENTS = CODEX_HOOK_EVENTS.filter((event) => event.delivery === "approval").map((event) => event.event);
+var CODEX_EVENT_KEY = {
+  PermissionRequest: "permission_request",
+  PreToolUse: "pre_tool_use",
+  PostToolUse: "post_tool_use",
+  UserPromptSubmit: "user_prompt_submit",
+  Stop: "stop",
+  SessionStart: "session_start",
+  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 asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord2(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var CODEX_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var CODEX_HTTP_ONLY_FIELDS = ["url", "http_headers", "env_http_headers", "http_headers_helper", "bearer_token", "bearer_token_env_var", "auth", "oauth", "oauth_resource"];
+var NATIVE_MCP_TRANSPORT_FIELDS = [...CODEX_HTTP_ONLY_FIELDS, "args", "env", "env_vars", "cwd"];
+var OLD_CLI_HTTP_FIELDS = /* @__PURE__ */ new Set(["url", "http_headers"]);
+var nativeCodexMcpCommand = () => join2(homedir2(), ".pushary", "bin", "pushary-mcp");
+var isNativeCodexMcpEntry = (entry2, command) => {
+  const server = asRecord2(entry2);
+  return server?.command === command && NATIVE_MCP_TRANSPORT_FIELDS.every((field) => !(field in server));
+};
+var carriesOnlyAnAuthorizationHeader = (headers) => {
+  const record = asRecord2(headers);
+  return record !== void 0 && Object.keys(record).length === 1 && typeof record.Authorization === "string";
+};
+var isOldCliMixedCodexMcpEntry = (entry2, command) => {
+  const server = asRecord2(entry2);
+  return server?.command === command && server.url === CODEX_MCP_URL && carriesOnlyAnAuthorizationHeader(server.http_headers) && NATIVE_MCP_TRANSPORT_FIELDS.every((field) => OLD_CLI_HTTP_FIELDS.has(field) || !(field in server));
+};
+var codexMcpMixesCommandWithHttp = (entry2) => {
+  const server = asRecord2(entry2);
+  return server !== void 0 && "command" in server && CODEX_HTTP_ONLY_FIELDS.some((field) => field in server);
+};
+var CODEX_RESTART_AFTER_TRANSPORT_CHANGE = "Fully quit and reopen Codex to load the updated Pushary configuration.";
+var codexMcpStartsCommand = (config) => {
+  const pushary = asRecord2(asRecord2(config.mcp_servers)?.pushary);
+  return pushary !== void 0 && "command" in pushary && pushary.enabled !== false;
+};
+var addCodexMcpServer = (config, apiKey, nativeOwnership = "preserve") => {
+  const existing = asRecord2(asRecord2(config.mcp_servers)?.pushary);
+  if (existing !== void 0 && "command" in existing) {
+    const command = nativeCodexMcpCommand();
+    if (!isOldCliMixedCodexMcpEntry(existing, command) && !isNativeCodexMcpEntry(existing, command)) {
+      throw new Error("Pushary MCP has an unrecognized or mixed transport. Its configuration was left unchanged.");
+    }
+    if (nativeOwnership === "preserve") {
+      for (const field of OLD_CLI_HTTP_FIELDS) delete existing[field];
+      return "kept-native";
+    }
+  }
+  const servers = ensureRecord(config, "mcp_servers");
+  const pushary = ensureRecord(servers, "pushary");
+  delete pushary.command;
+  pushary.url = CODEX_MCP_URL;
+  ensureRecord(pushary, "http_headers").Authorization = `Bearer ${apiKey}`;
+  pushary.default_tools_approval_mode = "approve";
+  delete pushary.bearer_token_env_var;
+  delete pushary.tools;
+  return "wrote-key";
+};
+var readCodexMcpAuth = (config) => {
+  const pushary = asRecord2(asRecord2(config.mcp_servers)?.pushary);
+  if (!pushary) return void 0;
+  if ("command" in pushary) {
+    return isNativeCodexMcpEntry(pushary, nativeCodexMcpCommand()) ? { method: "native" } : void 0;
+  }
+  const authorization = asRecord2(pushary.http_headers)?.Authorization;
+  if (typeof authorization === "string" && authorization.startsWith("Bearer ")) {
+    return { method: "embedded", key: authorization.slice("Bearer ".length).trim() };
+  }
+  if (typeof pushary.bearer_token_env_var === "string") {
+    return { method: "env", envVar: pushary.bearer_token_env_var };
+  }
+  if (typeof pushary.bearer_token === "string") return { method: "legacy-bearer" };
+  return void 0;
+};
+var isPusharyCodexCommand = (command) => command.includes(CODEX_HOOK_BINARY) || command.includes(HOOK_LOCATOR_BINARY);
+var isPusharyCommand = (hook, scope) => {
+  const command = String(asRecord2(hook)?.command ?? "");
+  if (isProtectedByScope(command, scope)) return false;
+  return isPusharyCodexCommand(command);
+};
+var isPusharyCodexHook = (entry2, scope) => {
+  const hooks = asRecord2(entry2)?.hooks;
+  return Array.isArray(hooks) && hooks.some((hook) => isPusharyCommand(hook, scope));
+};
+var CODEX_CLI_BINARIES = /* @__PURE__ */ new Set([CODEX_HOOK_BINARY]);
+var codexRegistrationHolder = (hooksConfig) => registrationHolderOf(hooksConfig, CODEX_CLI_BINARIES);
+var addCodexHooks = (config, command) => {
+  const hooks = ensureRecord(config, "hooks");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const existing = Array.isArray(hooks[definition.event]) ? hooks[definition.event] : [];
+    hooks[definition.event] = registerHookEntry(existing, isPusharyCodexHook, {
+      ...definition.matcher ? { matcher: definition.matcher } : {},
+      hooks: [{
+        type: "command",
+        command: withHookHoldBudget(command, holdBudgetOf(definition)),
+        timeout: definition.timeout,
+        ...definition.statusMessage ? { statusMessage: definition.statusMessage } : {}
+      }]
+    });
+  }
+};
+var removeCodexHooks = (config, scope) => {
+  const hooks = asRecord2(config.hooks);
+  if (!hooks) return false;
+  let changed = false;
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const filtered = entries.filter((entry2) => !isPusharyCodexHook(entry2, scope));
+    if (filtered.length !== entries.length) {
+      if (filtered.length === 0) {
+        delete hooks[definition.event];
+      } else {
+        hooks[definition.event] = filtered;
+      }
+      changed = true;
+    }
+  }
+  if (Object.keys(hooks).length === 0) delete config.hooks;
+  return changed;
+};
+var hasCodexHooks = (config) => {
+  const hooks = asRecord2(config.hooks);
+  if (!hooks) return false;
+  return CODEX_HOOK_EVENTS.some((definition) => {
+    const entries = hooks[definition.event];
+    return Array.isArray(entries) && entries.some((entry2) => isPusharyCodexHook(entry2));
+  });
+};
+var missingCodexHookEvents = (config) => {
+  const hooks = asRecord2(config.hooks);
+  return CODEX_HOOK_EVENTS.filter((definition) => {
+    const entries = hooks?.[definition.event];
+    return !Array.isArray(entries) || !entries.some((entry2) => isPusharyCodexHook(entry2));
+  }).map((definition) => definition.event);
+};
+var codexHookTrustHash = (definition, command) => {
+  const hook = { command: withHookHoldBudget(command, holdBudgetOf(definition)), timeout: definition.timeout, type: "command" };
+  if (definition.statusMessage) hook.statusMessage = definition.statusMessage;
+  const entry2 = { hooks: [hook] };
+  if (definition.matcher) entry2.matcher = definition.matcher;
+  return codexEntryTrustHash(CODEX_EVENT_KEY[definition.event], entry2);
+};
+var codexEntryTrustHash = (eventKey, entry2) => {
+  const hooks = Array.isArray(entry2.hooks) ? entry2.hooks : [];
+  const identity = {
+    event_name: eventKey,
+    hooks: hooks.map((hook) => ({ async: false, ...asRecord2(hook) }))
+  };
+  if (typeof entry2.matcher === "string") identity.matcher = entry2.matcher;
+  return "sha256:" + createHash("sha256").update(canonicalJson(identity), "utf8").digest("hex");
+};
+var codexHookPositions = (hooksConfig) => {
+  const hooks = asRecord2(hooksConfig?.hooks);
+  const positions = {};
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks?.[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const entryIndex = entries.findIndex((entry2) => isPusharyCodexHook(entry2));
+    if (entryIndex < 0) continue;
+    const inner = asRecord2(entries[entryIndex])?.hooks;
+    const hookIndex = Array.isArray(inner) ? inner.findIndex((hook) => isPusharyCommand(hook)) : -1;
+    positions[definition.event] = [entryIndex, Math.max(hookIndex, 0)];
+  }
+  return positions;
+};
+var codexHookStateKey = (hooksJsonPath, event, position) => `${hooksJsonPath}:${CODEX_EVENT_KEY[event]}:${position[0]}:${position[1]}`;
+var codexVacatedIndexes = (hooksConfig) => {
+  const hooks = asRecord2(hooksConfig?.hooks);
+  const vacated = {};
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const entries = hooks?.[definition.event];
+    if (!Array.isArray(entries)) continue;
+    const ours = entries.flatMap((entry2, index) => isPusharyCodexHook(entry2) ? [index] : []);
+    if (ours.length > 1) vacated[definition.event] = ours[1];
+  }
+  return vacated;
+};
+var dropVacatedCodexHookTrust = (config, hooksJsonPath, vacated) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  if (!state) return false;
+  let changed = false;
+  for (const [event, from] of Object.entries(vacated)) {
+    const prefix = `${hooksJsonPath}:${CODEX_EVENT_KEY[event] ?? codexEventKeyOf(event)}:`;
+    for (const key of Object.keys(state)) {
+      if (!key.startsWith(prefix)) continue;
+      const entryIndex = Number(key.slice(prefix.length).split(":")[0]);
+      if (!Number.isInteger(entryIndex) || entryIndex < from) continue;
+      delete state[key];
+      changed = true;
+    }
+  }
+  return changed;
+};
+var captureCodexHookTrust = (config, hooksJsonPath, positions) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  if (!state) return {};
+  const snapshot = {};
+  for (const [event, position] of Object.entries(positions)) {
+    const value = state[codexHookStateKey(hooksJsonPath, event, position)];
+    if (value !== void 0) snapshot[event] = structuredClone(value);
+  }
+  return snapshot;
+};
+var restoreCodexHookTrust = (config, hooksJsonPath, positions, snapshot) => {
+  const restorable = Object.entries(snapshot).filter(([event]) => positions[event] !== void 0);
+  if (restorable.length === 0) return false;
+  const state = ensureRecord(ensureRecord(config, "hooks"), "state");
+  for (const [event, value] of restorable) {
+    state[codexHookStateKey(hooksJsonPath, event, positions[event])] = structuredClone(value);
+  }
+  return true;
+};
+var codexTrustGaps = (config, hooksConfig, hooksJsonPath, command, positions) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  const hooks = asRecord2(hooksConfig?.hooks);
+  const gaps = [];
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const position = positions[definition.event];
+    if (!position) continue;
+    const hookState = asRecord2(state?.[codexHookStateKey(hooksJsonPath, definition.event, position)]);
+    if (definition.delivery === "approval" && hookState?.enabled === false) {
+      gaps.push({ event: definition.event, kind: "disabled" });
+      continue;
+    }
+    const stored = hookState?.trusted_hash;
+    const eventKey = CODEX_EVENT_KEY[definition.event] ?? definition.event;
+    const onDisk = asRecord2(
+      asRecord2(hooks?.[definition.event]) ?? (Array.isArray(hooks?.[definition.event]) ? hooks[definition.event][position[0]] : void 0)
+    );
+    const handlers = onDisk?.hooks;
+    const handler = Array.isArray(handlers) ? asRecord2(handlers[position[1]]) : void 0;
+    if (definition.delivery === "approval" && handler?.async === true) {
+      gaps.push({ event: definition.event, kind: "asynchronous" });
+      continue;
+    }
+    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 = asRecord2(config.mcp_servers);
+  if (!servers?.pushary) return false;
+  delete servers.pushary;
+  if (Object.keys(servers).length === 0) delete config.mcp_servers;
+  return true;
+};
+var removeCodexHookTrust = (config, hooksJsonPath, positions) => {
+  const state = asRecord2(asRecord2(config.hooks)?.state);
+  if (!state) return false;
+  let changed = false;
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const position = positions[definition.event];
+    if (!position) continue;
+    const key = codexHookStateKey(hooksJsonPath, definition.event, position);
+    if (key in state) {
+      delete state[key];
+      changed = true;
+    }
+  }
+  if (changed && Object.keys(state).length === 0) {
+    const hooks = asRecord2(config.hooks);
+    if (hooks) {
+      delete hooks.state;
+      if (Object.keys(hooks).length === 0) delete config.hooks;
+    }
+  }
+  return changed;
+};
+var removeCodexSettings = (config, hooksJsonPath, positions) => {
+  const mcp = removeCodexMcpServer(config);
+  const trust = removeCodexHookTrust(config, hooksJsonPath, positions);
+  return mcp || trust;
+};
+var addCodexHookTrust = (config, hooksJsonPath, command, positions) => {
+  const hooks = ensureRecord(config, "hooks");
+  const state = ensureRecord(hooks, "state");
+  for (const definition of CODEX_HOOK_EVENTS) {
+    const position = positions[definition.event];
+    if (!position) continue;
+    const key = codexHookStateKey(hooksJsonPath, definition.event, position);
+    const ours = codexHookTrustHash(definition, command);
+    const existing = asRecord2(state[key]) ?? {};
+    state[key] = { ...existing, trusted_hash: ours };
+    for (const stale of staleTrustKeys(state, hooksJsonPath, definition.event, key, ours)) {
+      delete state[stale];
+    }
+  }
+};
+var staleTrustKeys = (state, hooksJsonPath, event, currentKey, ourHash) => {
+  const prefix = `${hooksJsonPath}:${CODEX_EVENT_KEY[event]}:`;
+  return Object.keys(state).filter(
+    (key) => key !== currentKey && key.startsWith(prefix) && asRecord2(state[key])?.trusted_hash === ourHash
+  );
+};
+
+// src/cline-config.ts
+import { join as join4 } from "path";
+
+// src/claude-config.ts
+import { join as join3 } from "path";
+
+// 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",
+  "idle_prompt",
+  "agent_needs_input",
+  "worker_permission_prompt",
+  // An MCP server asking the person for a value. The Elicitation hook answers it;
+  // this is the feed row saying one is open.
+  "elicitation_dialog",
+  "elicitation_url_dialog",
+  // Turn boundary.
+  "agent_completed",
+  // Quota. The island already reads plan usage, and these say when a limit hit,
+  // went stale, or was turned off, which no polling of the usage endpoint reveals.
+  "quota_auto_resume_fired",
+  "quota_auto_resume_stale",
+  "quota_auto_resume_disabled"
+];
+var NOTIFICATION_PUSH_TYPES = /* @__PURE__ */ new Set([
+  "idle_prompt",
+  "agent_needs_input",
+  "worker_permission_prompt"
+]);
+
+// src/claude-events.ts
+var MIRRORED_TOOLS = POSTTOOLUSE_MIRRORED_TOOLS.join("|");
+var ESTABLISHED = [1, 0, 0];
+var OBSERVED = [2, 0, 0];
+var CLAUDE_HOOK_BINARY = "pushary-hook";
+var CLAUDE_HOOK_EVENTS = [
+  { event: "PreToolUse", binary: CLAUDE_HOOK_BINARY, matcher: CLAUDE_PRETOOLUSE_MATCHER, timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: ESTABLISHED },
+  { event: "PostToolUse", binary: "pushary-post-hook", matcher: MIRRORED_TOOLS, timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Stop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "UserPromptSubmit", binary: "pushary-prompt-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "Notification", binary: "pushary-notification-hook", matcher: NOTIFICATION_MATCHED_TYPES.join("|"), timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionStart", binary: "pushary-session-start-hook", matcher: "startup|resume|clear", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "SessionEnd", binary: "pushary-session-end-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "StopFailure", binary: "pushary-stopfailure-hook", timeout: 10, delivery: "telemetry", since: ESTABLISHED },
+  { event: "PermissionRequest", binary: "pushary-permission-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: ESTABLISHED },
+  { event: "PermissionDenied", binary: "pushary-permission-denied-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", holds: true, since: ESTABLISHED },
+  // Observability only. Each carries session shape the island cannot get any other
+  // way, and none of them decides anything.
+  { event: "SubagentStart", binary: "pushary-session-start-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "SubagentStop", binary: "pushary-stop-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PreCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "PostCompact", binary: "pushary-post-hook", matcher: "manual|auto", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  { event: "TeammateIdle", binary: "pushary-notification-hook", timeout: 10, delivery: "telemetry", since: OBSERVED },
+  // An MCP server asking the person for a value, answered from the phone rather
+  // than the terminal. No matcher: Claude Code matches this event on the MCP
+  // server's name, and we have no business preferring one server over another.
+  { event: "Elicitation", binary: "pushary-elicitation-hook", timeout: HOOK_BUDGETS.claude.budgetSeconds, delivery: "approval", since: OBSERVED }
+];
+var supportedClaudeEvents = (version) => CLAUDE_HOOK_EVENTS.filter((hook) => version ? atLeast(version, hook.since) : hook.since === ESTABLISHED);
+var registrationSignatures = (events, version) => Object.fromEntries(
+  events.map((hook) => [hook.event, `registered|${version ? formatVersion(version) : "unknown"}`])
+);
+var needsReregistration = (stored, version) => {
+  const expected = registrationSignatures(supportedClaudeEvents(version), version);
+  const keys = Object.keys(expected);
+  if (!stored) return true;
+  if (keys.length !== Object.keys(stored).length) return true;
+  return keys.some((event) => stored[event] !== expected[event]);
+};
+
+// src/claude-config.ts
+import { isDeepStrictEqual } from "util";
+var PUSHARY_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var PUSHARY_PERMISSION_RULE = "mcp__pushary__*";
+var asRecord3 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord2 = (target, key) => {
+  const existing = asRecord3(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyPermission = (rule) => typeof rule === "string" && (rule.includes("pushary") || rule.includes("MCP(pushary"));
+var HOOK_BINARIES = /* @__PURE__ */ new Set([
+  ...CLAUDE_HOOK_EVENTS.map((hook) => hook.binary),
+  HOOK_LOCATOR_BINARY
+]);
+var namesPusharyBinary = (command) => command.split(/[\s/\\"']+/).some((segment) => HOOK_BINARIES.has(segment.replace(/\.(cmd|exe)$/i, "")));
+var isPusharyHook = (entry2, scope) => {
+  const hooks = asRecord3(entry2)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    const command = String(asRecord3(hook)?.command ?? "");
+    if (isProtectedByScope(command, scope)) return false;
+    return namesPusharyBinary(command);
+  });
+};
+var pusharyMcpServer = (apiKey) => ({
+  type: "http",
+  url: PUSHARY_MCP_URL,
+  headers: { Authorization: `Bearer ${apiKey}` }
+});
+var addClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = ensureRecord2(config, "mcpServers");
+  mcpServers.pushary = pusharyMcpServer(apiKey);
+};
+var isClaudeMcpSnapshot = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const snapshot = value;
+  return typeof snapshot.hadMcpServers === "boolean" && typeof snapshot.mcpServersWasRecord === "boolean" && (!snapshot.hadMcpServers || snapshot.mcpServersWasRecord || Object.hasOwn(snapshot, "mcpServers")) && typeof snapshot.hadPushary === "boolean" && (!snapshot.hadPushary || Object.hasOwn(snapshot, "pushary")) && (!Object.hasOwn(snapshot, "installedPushary") || asRecord3(snapshot.installedPushary)?.type === "http" && asRecord3(snapshot.installedPushary)?.url === PUSHARY_MCP_URL);
+};
+var captureClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = asRecord3(config.mcpServers);
+  const hadMcpServers = Object.hasOwn(config, "mcpServers");
+  return {
+    hadMcpServers,
+    mcpServersWasRecord: Boolean(mcpServers),
+    ...hadMcpServers && !mcpServers ? { mcpServers: structuredClone(config.mcpServers) } : {},
+    hadPushary: Boolean(mcpServers && Object.hasOwn(mcpServers, "pushary")),
+    ...mcpServers && Object.hasOwn(mcpServers, "pushary") ? { pushary: structuredClone(mcpServers.pushary) } : {},
+    ...apiKey ? { installedPushary: pusharyMcpServer(apiKey) } : {}
+  };
+};
+var updateClaudeMcpSnapshot = (snapshot, apiKey) => ({
+  ...snapshot,
+  installedPushary: pusharyMcpServer(apiKey)
+});
+var restoreClaudeMcpServer = (config, snapshot) => {
+  const mcpServers = asRecord3(config.mcpServers);
+  const current = asRecord3(mcpServers?.pushary);
+  if (Object.hasOwn(snapshot, "installedPushary")) {
+    if (!isDeepStrictEqual(mcpServers?.pushary, snapshot.installedPushary)) return false;
+  } else if (current?.type !== "http" || current.url !== PUSHARY_MCP_URL) {
+    return false;
+  }
+  if (!snapshot.mcpServersWasRecord) {
+    if (Object.keys(mcpServers).length === 1) {
+      if (snapshot.hadMcpServers) config.mcpServers = structuredClone(snapshot.mcpServers);
+      else delete config.mcpServers;
+    } else {
+      delete mcpServers.pushary;
+    }
+  } else if (snapshot.hadPushary) {
+    mcpServers.pushary = structuredClone(snapshot.pushary);
+  } else {
+    delete mcpServers.pushary;
+    if (!snapshot.hadMcpServers && Object.keys(mcpServers).length === 0) delete config.mcpServers;
+  }
+  return true;
+};
+var removeClaudeMcpServers = (config) => {
+  let changed = false;
+  const removeFrom = (target) => {
+    const mcpServers = asRecord3(target.mcpServers);
+    if (!mcpServers?.pushary) return;
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete target.mcpServers;
+    changed = true;
+  };
+  removeFrom(config);
+  const projects = asRecord3(config.projects);
+  if (projects) {
+    for (const project of Object.values(projects)) {
+      const projectConfig = asRecord3(project);
+      if (projectConfig) removeFrom(projectConfig);
+    }
+  }
+  return changed;
+};
+var removePusharyToolPermissions = (settings) => {
+  const permissions = asRecord3(settings.permissions);
+  if (!permissions || !Array.isArray(permissions.allow)) return false;
+  const filtered = permissions.allow.filter((rule) => !isPusharyPermission(rule));
+  if (filtered.length === permissions.allow.length) return false;
+  if (filtered.length === 0) delete permissions.allow;
+  else permissions.allow = filtered;
+  if (Object.keys(permissions).length === 0) delete settings.permissions;
+  return true;
+};
+var addPusharyToolPermissions = (settings) => {
+  const permissions = ensureRecord2(settings, "permissions");
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filtered = allow.filter((rule) => !isPusharyPermission(rule));
+  if (!filtered.includes(PUSHARY_PERMISSION_RULE)) {
+    filtered.push(PUSHARY_PERMISSION_RULE);
+  }
+  permissions.allow = filtered;
+};
+var addPusharyHooks = (settings, binDir, version = null) => {
+  const resolve2 = (name) => guardBinary(binDir ? join3(binDir, name) : name);
+  const hooks = ensureRecord2(settings, "hooks");
+  const supported = new Map(supportedClaudeEvents(version).map((hook) => [hook.event, hook]));
+  for (const known of CLAUDE_HOOK_EVENTS) {
+    const current = Array.isArray(hooks[known.event]) ? hooks[known.event] : [];
+    const definition = supported.get(known.event);
+    if (definition) {
+      hooks[known.event] = registerHookEntry(current, isPusharyHook, entry(definition, resolve2));
+      continue;
+    }
+    const others = current.filter((item) => !isPusharyHook(item));
+    if (others.length > 0) {
+      hooks[known.event] = others;
+    } else {
+      delete hooks[known.event];
+    }
+  }
+};
+var entry = (definition, resolve2) => ({
+  ...definition.matcher ? { matcher: definition.matcher } : {},
+  hooks: [{
+    type: "command",
+    command: withHookHoldBudget(resolve2(definition.binary), holdBudgetOf(definition)),
+    timeout: definition.timeout
+  }]
+});
+var removePusharySettings = (settings, scope) => {
+  let changed = scope?.keepMcpServer === true ? false : removeClaudeMcpServers(settings);
+  if (scope?.keepMcpServer !== true && removePusharyToolPermissions(settings)) changed = true;
+  const hooks = asRecord3(settings.hooks);
+  if (hooks) {
+    for (const { event: key } of CLAUDE_HOOK_EVENTS) {
+      const entries = hooks[key];
+      if (!Array.isArray(entries)) continue;
+      const filtered = entries.filter((entry2) => !isPusharyHook(entry2, scope));
+      if (filtered.length !== entries.length) {
+        if (filtered.length === 0) {
+          delete hooks[key];
+        } else {
+          hooks[key] = filtered;
+        }
+        changed = true;
+      }
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  return changed;
+};
+
+// src/instruction-file.ts
+import { accessSync, constants, existsSync, readFileSync, statSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { dirname } from "path";
+var PUSHARY_BEGIN = "<!-- BEGIN PUSHARY (managed by @pushary/agent-hooks; do not edit this block) -->";
+var PUSHARY_END = "<!-- END PUSHARY -->";
+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. 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.
+- 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. When a Pushary hook result says the user approved a specific command after a denial, rerunning that exact command is the approved path and not a bypass of that 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. Only file paths are checked, and only on tool calls that carry one, so put a boundary that is not a path (recipients, channels, spend, systems you will not open) in \`promises\` and never in \`allowedPaths\`. Read the \`enforces\` field that comes back: an empty array means nothing in that contract is checked automatically, and you must say so rather than report that a scope is in force. \`hookSeen: false\` means no hook has reported that sessionId, so the gate will never find the contract: fix the session id rather than proceeding as if a scope were in force.
+- Before a task of more than two steps, break it into steps and find the forks. Settle by yourself every fork that a file, a command or a tool call can answer, then ask the rest as one numbered round with your recommended answer against each. A question in the terminal is free; a push is not. When the user is at the terminal, ask the whole round there. When the user is away, send only the fork that stops the run, and decide the rest on your recommendation.
+- 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 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.
+- When the user asks to be reminded later, call \`schedule_reminder\` with \`body\` and either \`inMinutes\` or \`at\` with an explicit UTC offset. Confirm the returned time, never guess their timezone, and do not use \`ask_user\` as a reminder. Pushary saves it and delivers after this agent exits. Call with no arguments to list pending reminders or \`cancelReminderId\` to cancel one before dispatch starts.
+- 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.
+
+Pass \`agentName\` as "${label} - <project folder name>" so the user knows which session is asking. If a question times out, follow \`handoffAction\` when present, otherwise \`nextAction\`: keep waiting with the same correlationId while pending. A poll ending is not question expiry. Cancel only for an explicit handoff or when the answer is no longer needed. If cancellation returns \`handoffAction: "stop"\`, stop. Otherwise, if cancellation returns false, poll once for 1 second and honor the answer that won the race.`;
+var SHARED_AGENTS_MD_LABEL = "<your agent's name, such as Codex or Hermes>";
+var CODEX_INSTRUCTIONS_LABEL = "Codex";
+var GEMINI_INSTRUCTIONS_LABEL = "Gemini";
+var OPENCODE_INSTRUCTIONS_LABEL = "OpenCode";
+var renderAgentInstructions = (label) => instructionBody(label);
+var KEYLESS_FALLBACK_LINE = "This repo uses Pushary phone approvals. Your teammates get agent questions on their lock screens; you do not have a key yet, so questions will fall back to the terminal. Get your own key (3-day trial): https://pushary.com/sign-up?utm_source=agents-md&utm_medium=teammate";
+var renderProjectAgentInstructions = (label) => `${instructionBody(label)}
+
+If this environment has no Pushary API key (no PUSHARY_API_KEY and no key in ~/.pushary/config.json), the tools above are unavailable in this session. In that case, treat the following as a statement of fact about this session and continue in the terminal: ${KEYLESS_FALLBACK_LINE}`;
+var wrap = (body) => `${PUSHARY_BEGIN}
+${body}
+${PUSHARY_END}`;
+var withInstructionBlockAppended = (existing, body) => {
+  const prefix = existing.trim() ? existing.replace(/\s*$/, "") + "\n\n" : "";
+  return prefix + wrap(body) + "\n";
+};
+var managedBlockRange = (text) => {
+  const start = text.indexOf(PUSHARY_BEGIN);
+  const end = text.indexOf(PUSHARY_END);
+  return start !== -1 && end > start ? { start, end: end + PUSHARY_END.length } : null;
+};
+var withInstructionBlockReplaced = (existing, body) => {
+  const range = managedBlockRange(existing);
+  return range ? existing.slice(0, range.start) + wrap(body) + existing.slice(range.end) : null;
+};
+var writeInstructionBlock = (filePath, body) => {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+  }
+  writeFileSync(filePath, withInstructionBlockReplaced(existing, body) ?? withInstructionBlockAppended(existing, body), "utf-8");
+};
+var occurrencesOf = (marker, text) => text.split(marker).length - 1;
+var soleManagedBlock = (text) => {
+  const begins = occurrencesOf(PUSHARY_BEGIN, text);
+  const ends = occurrencesOf(PUSHARY_END, text);
+  if (begins === 0 && ends === 0) return { kind: "none" };
+  const range = managedBlockRange(text);
+  return begins === 1 && ends === 1 && range ? { kind: "one", range } : { kind: "ambiguous" };
+};
+var CRLF = "\r\n";
+var withLineEndingsOf = (sample, block) => sample.includes(CRLF) ? block.replaceAll("\n", CRLF) : block;
+var readUtf8 = (filePath) => {
+  try {
+    const bytes = readFileSync(filePath);
+    const text = bytes.toString("utf-8");
+    return Buffer.from(text, "utf-8").equals(bytes) ? { kind: "text", text } : { kind: "not_utf8" };
+  } catch {
+    return { kind: "unreadable" };
+  }
+};
+var isWritable = (filePath) => {
+  try {
+    accessSync(filePath, constants.W_OK);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var refreshInstructionBlock = (filePath, body) => {
+  if (!existsSync(filePath)) return "absent";
+  const read = readUtf8(filePath);
+  if (read.kind !== "text") return read.kind;
+  const block = soleManagedBlock(read.text);
+  if (block.kind === "none") return "absent";
+  if (block.kind === "ambiguous") return "ambiguous_markers";
+  const existing = read.text.slice(block.range.start, block.range.end);
+  const fresh = withLineEndingsOf(existing, wrap(body));
+  if (existing === fresh) return "current";
+  if (!isWritable(filePath)) return "read_only";
+  try {
+    const refreshed = read.text.slice(0, block.range.start) + fresh + read.text.slice(block.range.end);
+    writeFileAtomic(filePath, refreshed, statSync(filePath).mode & 511);
+    return "refreshed";
+  } catch {
+    return "write_failed";
+  }
+};
+var removeInstructionBlock = (filePath) => {
+  let existing = "";
+  try {
+    existing = readFileSync(filePath, "utf-8");
+  } catch {
+    return false;
+  }
+  const start = existing.indexOf(PUSHARY_BEGIN);
+  const end = existing.indexOf(PUSHARY_END);
+  if (start === -1 || end === -1 || end < start) return false;
+  const remaining = (existing.slice(0, start) + existing.slice(end + PUSHARY_END.length)).trim();
+  if (remaining === "") {
+    rmSync(filePath, { force: true });
+  } else {
+    writeFileSync(filePath, remaining + "\n", "utf-8");
+  }
+  return true;
+};
+var hasInstructionBlock = (filePath) => {
+  try {
+    return readFileSync(filePath, "utf-8").includes(PUSHARY_BEGIN);
+  } catch {
+    return false;
+  }
+};
+
+// src/cline-config.ts
+var CLINE_LABEL = "Cline";
+var CLINE_SERVER_NAME = "pushary";
+var CLINE_MCP_TIMEOUT_SECONDS = 90;
+var CLINE_SETTINGS_FILE_NAME = "cline_mcp_settings.json";
+var CLINE_RULES_FILE_NAME = "pushary.md";
+var CLINE_DIRECTORY_NAME = ".cline";
+var CLINE_DATA_DIRECTORY_NAME = "data";
+var CLINE_SETTINGS_DIRECTORY_NAME = "settings";
+var CLINE_RULES_DIRECTORY_NAME = "rules";
+var CLINE_DIR_ENV = "CLINE_DIR";
+var CLINE_DATA_DIR_ENV = "CLINE_DATA_DIR";
+var CLINE_MCP_SETTINGS_PATH_ENV = "CLINE_MCP_SETTINGS_PATH";
+var STREAMABLE_HTTP_TRANSPORT = "streamableHttp";
+var STDIO_TRANSPORT = "stdio";
+var AUTHORIZATION_HEADER = "Authorization";
+var PUSHARY_KEY_BEARER_PREFIX = "Bearer pk_";
+var TRANSPORT_FIELDS = /* @__PURE__ */ new Set(["transport", "type", "transportType", "url", "headers", "command", "args", "cwd", "env"]);
+var CONNECTION_SWITCH_FIELD = "disabled";
+var PUSHARY_MCP_HOSTS = /* @__PURE__ */ new Set(["pushary.com", "www.pushary.com"]);
+var PUSHARY_MCP_PATH_PREFIX = "/api/mcp";
+var CLINE_AUTO_APPROVE_STEP = 'In Cline, open Auto-approve under the chat box and tick "Use MCP servers", so Pushary calls run without waiting for a click in VS Code. That setting covers every MCP server in Cline, not only Pushary.';
+var CLINE_RELOAD_STEP = "Reload VS Code (Developer: Reload Window) or restart the Cline CLI so Cline loads the Pushary server.";
+var CLINE_TOOL_NOTE = `In Cline, these tools come from the MCP server named "${CLINE_SERVER_NAME}". Cline's own question tool waits in VS Code and never reaches the user's phone, so when the user may be away, ask through Pushary's \`ask_user\` instead. Cline cannot tell whether the user is watching VS Code; Pushary's delivery mode decides where a notification lands, so call \`send_notification\` with context type "task_complete" when a task of several steps finishes.`;
+var CLINE_SETTINGS_REFUSALS = {
+  unparseable: "is not valid JSON, which Cline cannot read either",
+  "root-not-object": "is not a JSON object",
+  "servers-not-object": 'has an "mcpServers" value that is not an object'
+};
+var CLINE_SERVER_NAME_TAKEN = `already has a server named "${CLINE_SERVER_NAME}" that is not Pushary`;
+var isAuthorizationHeader = ([name]) => name.toLowerCase() === AUTHORIZATION_HEADER.toLowerCase();
+var asRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var environmentValue = (environment, name) => {
+  const value = environment[name]?.trim();
+  return value ? value : void 0;
+};
+var clineDirectory = (location) => environmentValue(location.environment, CLINE_DIR_ENV) ?? join4(location.home, CLINE_DIRECTORY_NAME);
+var clineDataDirectory = (location) => environmentValue(location.environment, CLINE_DATA_DIR_ENV) ?? join4(clineDirectory(location), CLINE_DATA_DIRECTORY_NAME);
+var clineMcpSettingsPath = (location) => environmentValue(location.environment, CLINE_MCP_SETTINGS_PATH_ENV) ?? join4(clineDataDirectory(location), CLINE_SETTINGS_DIRECTORY_NAME, CLINE_SETTINGS_FILE_NAME);
+var clineRulesFile = (location) => join4(clineDirectory(location), CLINE_RULES_DIRECTORY_NAME, CLINE_RULES_FILE_NAME);
+var parsedJson = (text) => {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+};
+var settingsTextMentionsPushary = (text) => [...PUSHARY_MCP_HOSTS].some((host) => text.includes(host)) || text.includes(PUSHARY_KEY_BEARER_PREFIX);
+var refusedSettings = (reason, text) => ({ kind: "refused", reason, mentionsPushary: settingsTextMentionsPushary(text) });
+var readClineSettings = (text) => {
+  if (!text.trim()) return { kind: "settings", settings: {} };
+  const parsed = parsedJson(text);
+  if (!parsed.ok) return refusedSettings("unparseable", text);
+  const settings = asRecord4(parsed.value);
+  if (!settings) return refusedSettings("root-not-object", text);
+  if (settings.mcpServers !== void 0 && !asRecord4(settings.mcpServers)) return refusedSettings("servers-not-object", text);
+  return { kind: "settings", settings };
+};
+var serversOf = (settings) => asRecord4(settings.mcpServers) ?? {};
+var transportOf = (entry2) => {
+  const record = asRecord4(entry2);
+  return asRecord4(record?.transport) ?? record;
+};
+var isPusharyMcpUrl = (value) => {
+  if (typeof value !== "string") return false;
+  try {
+    const url = new URL(value);
+    return PUSHARY_MCP_HOSTS.has(url.hostname) && (url.pathname === PUSHARY_MCP_PATH_PREFIX || url.pathname.startsWith(`${PUSHARY_MCP_PATH_PREFIX}/`));
+  } catch {
+    return false;
+  }
+};
+var authorizationBearer = (apiKey) => `Bearer ${apiKey}`;
+var clinePusharyEntry = (apiKey) => ({
+  transport: {
+    type: STREAMABLE_HTTP_TRANSPORT,
+    url: PUSHARY_MCP_URL,
+    headers: { [AUTHORIZATION_HEADER]: authorizationBearer(apiKey) }
+  },
+  timeout: CLINE_MCP_TIMEOUT_SECONDS
+});
+var commandArgumentsOf = (transport) => {
+  const args = transport?.args;
+  return Array.isArray(args) ? args : [];
+};
+var declaredTransportType = (transport) => transport?.type ?? transport?.transportType;
+var clineEntryRunsCommand = (entry2) => {
+  const transport = transportOf(entry2);
+  const declared = declaredTransportType(transport);
+  return typeof transport?.command === "string" && (declared === void 0 || declared === STDIO_TRANSPORT);
+};
+var reachesPusharyThroughCommand = (entry2) => clineEntryRunsCommand(entry2) && commandArgumentsOf(transportOf(entry2)).some(isPusharyMcpUrl);
+var isClinePusharyEntry = (entry2) => isPusharyMcpUrl(transportOf(entry2)?.url) || reachesPusharyThroughCommand(entry2);
+var isKeptOnConnect = ([field]) => !TRANSPORT_FIELDS.has(field) && field !== CONNECTION_SWITCH_FIELD;
+var isNotAuthorizationHeader = (header) => !isAuthorizationHeader(header);
+var headersWithoutAuthorization = (headers) => Object.fromEntries(Object.entries(asRecord4(headers) ?? {}).filter(isNotAuthorizationHeader));
+var connectedClinePusharyEntry = (existing, apiKey) => {
+  const ours = isClinePusharyEntry(existing) ? asRecord4(existing) ?? {} : {};
+  const fresh = clinePusharyEntry(apiKey);
+  return {
+    timeout: fresh.timeout,
+    ...Object.fromEntries(Object.entries(ours).filter(isKeptOnConnect)),
+    transport: {
+      ...fresh.transport,
+      headers: { ...headersWithoutAuthorization(transportOf(ours)?.headers), ...fresh.transport.headers }
+    }
+  };
+};
+var clinePusharyEntryOf = (settings) => serversOf(settings)[CLINE_SERVER_NAME];
+var clineEntryAuthorization = (entry2) => {
+  const headers = asRecord4(transportOf(entry2)?.headers);
+  const value = headers ? Object.entries(headers).find(isAuthorizationHeader)?.[1] : void 0;
+  return typeof value === "string" ? value : void 0;
+};
+var clineEntryUsesKey = (entry2, apiKey) => isClinePusharyEntry(entry2) && clineEntryAuthorization(entry2) === authorizationBearer(apiKey);
+var clineEntryHoldsLiteralKey = (entry2) => clineEntryAuthorization(entry2)?.startsWith(PUSHARY_KEY_BEARER_PREFIX) === true;
+var clineEntrySignedIn = (entry2) => asRecord4(asRecord4(asRecord4(entry2)?.oauth)?.tokens) !== void 0;
+var clineEntrySwitchedOff = (entry2) => asRecord4(entry2)?.[CONNECTION_SWITCH_FIELD] === true;
+var clineServerNameTakenElsewhere = (settings) => {
+  const entry2 = serversOf(settings)[CLINE_SERVER_NAME];
+  return entry2 !== void 0 && !isClinePusharyEntry(entry2);
+};
+var withClinePusharyServer = (settings, apiKey) => {
+  const servers = serversOf(settings);
+  return { ...settings, mcpServers: { ...servers, [CLINE_SERVER_NAME]: connectedClinePusharyEntry(servers[CLINE_SERVER_NAME], apiKey) } };
+};
+var withKeyHeader = (target, apiKey) => ({
+  ...target,
+  headers: { ...headersWithoutAuthorization(target.headers), [AUTHORIZATION_HEADER]: authorizationBearer(apiKey) }
+});
+var withRefreshedClineKey = (settings, apiKey) => {
+  const servers = serversOf(settings);
+  const entry2 = asRecord4(servers[CLINE_SERVER_NAME]) ?? {};
+  const nested = asRecord4(entry2.transport);
+  const refreshed = nested ? { ...entry2, transport: withKeyHeader(nested, apiKey) } : withKeyHeader(entry2, apiKey);
+  return { ...settings, mcpServers: { ...servers, [CLINE_SERVER_NAME]: refreshed } };
+};
+var withoutClinePusharyServer = (settings) => {
+  const servers = serversOf(settings);
+  if (!isClinePusharyEntry(servers[CLINE_SERVER_NAME])) return { settings, removed: false };
+  const remaining = Object.fromEntries(Object.entries(servers).filter(([name]) => name !== CLINE_SERVER_NAME));
+  return { settings: { ...settings, mcpServers: remaining }, removed: true };
+};
+var isOtherPusharyServer = ([name, entry2]) => name !== CLINE_SERVER_NAME && isClinePusharyEntry(entry2);
+var otherPusharyServerNames = (settings) => Object.entries(serversOf(settings)).filter(isOtherPusharyServer).map(([name]) => name);
+var clineSettingsText = (settings) => `${JSON.stringify(settings, null, 2)}
+`;
+var clineInstructionsBody = () => `${renderAgentInstructions(CLINE_LABEL)}
+
+${CLINE_TOOL_NOTE}`;
+
+// src/setup/paths.ts
+var claudeSettings = (environment = process.env) => join5(claudeConfigDir(homedir3(), environment), "settings.json");
+var claudeJson = (environment = process.env) => claudeUserConfigFile(homedir3(), environment);
+var claudeSkillDir = (environment = process.env) => join5(claudeConfigDir(homedir3(), environment), "skills", "pushary");
+var cursorPluginDir = () => join5(homedir3(), ".cursor", "plugins", "local", "pushary");
+var cursorUserHooks = () => join5(homedir3(), ".cursor", "hooks.json");
+var cursorPluginMcp = () => join5(cursorPluginDir(), "mcp.json");
+var cursorPluginManifest = () => join5(cursorPluginDir(), ".cursor-plugin", "plugin.json");
+var cursorPluginRule = () => join5(cursorPluginDir(), "rules", "pushary.mdc");
+var cursorUserMcp = () => join5(homedir3(), ".cursor", "mcp.json");
+var vscodePluginDir = () => join5(homedir3(), ".pushary", "plugins", "vscode");
+var vscodePluginMcp = () => join5(vscodePluginDir(), ".mcp.json");
+var claudeSettingsLocal = () => join5(claudeConfigDir(), "settings.local.json");
+var pusharyDir = () => join5(homedir3(), ".pushary");
+var claudeSetupDir = () => process.env.CLAUDE_CONFIG_DIR ? join5(pusharyDir(), "setup", "claude-profiles", createHash2("sha256").update(claudeUserConfigFile()).digest("hex").slice(0, 32)) : join5(pusharyDir(), "setup");
+var claudeMcpReceipt = () => join5(claudeSetupDir(), "claude-mcp.json");
+var bridgeAgentKey = () => join5(pusharyDir(), "bridge-auth", "agent-key.json");
+var autoUpdateState = () => join5(pusharyDir(), "auto-update.json");
+var autoUpdateLock = () => join5(pusharyDir(), "auto-update.lock");
+var serviceOwedBackMark = () => join5(pusharyDir(), "service-owed-back");
+var autoUpdateLog = () => join5(pusharyDir(), "logs", "auto-update.log");
+var clientReportClaims = () => join5(pusharyDir(), "client-reports");
+var claudeRegistrationReceipt = () => join5(claudeSetupDir(), "claude-registration.json");
+var hermesConfig = () => join5(homedir3(), ".hermes", "config.yaml");
+var hermesConfigReceipt = () => join5(pusharyDir(), "setup", "hermes-config.json");
+var fxQuestionRuleReceipt = () => join5(pusharyDir(), "setup", "fx-question-rule.json");
+var hookTakeoverReceipt = (agent) => join5(agent === "claude_code" ? claudeSetupDir() : join5(pusharyDir(), "setup"), `hook-takeover-${agent}.json`);
+var codexSkillDir2 = () => join5(codexHome(), "skills", "pushary");
+var codexAgentsMd2 = () => join5(codexHome(), "AGENTS.md");
+var geminiSettings = () => join5(homedir3(), ".gemini", "settings.json");
+var geminiMd = () => join5(homedir3(), ".gemini", "GEMINI.md");
+var pusharyConfigFile = () => join5(homedir3(), ".pushary", "config.json");
+var fxConfigDir = () => join5(homedir3(), ".fx");
+var fxMcpProfile = () => join5(fxConfigDir(), "mcp.json");
+var fxSettings = () => join5(fxConfigDir(), "settings.json");
+var fxAgentsMd = () => join5(fxConfigDir(), "AGENTS.md");
+var clineLocation = () => ({ home: homedir3(), environment: process.env });
+var clineMcpSettings = () => clineMcpSettingsPath(clineLocation());
+var clineRules = () => clineRulesFile(clineLocation());
+
+export {
+  claudeConfigDir,
+  claudeUserConfigFile,
+  registeredCommands,
+  namesOurBinary,
+  registrationHolderOf,
+  HOOK_SHELL,
+  holdBudgetOf,
+  guardBinary,
+  guardBinaryRefusing,
+  guardNodeScript,
+  guardCursorGate,
+  guardedArgv,
+  registerHookEntry,
+  isProtectedByScope,
+  canonicalJson,
+  CODEX_HOOK_BINARY,
+  codexHome,
+  codexHomeFrom,
+  codexConfigToml,
+  codexHooksJsonIn,
+  codexHooksJson,
+  codexAgentsMd,
+  codexSkillDir,
+  CODEX_HOOK_EVENTS,
+  CODEX_REQUIRED_APPROVAL_EVENTS,
+  codexMcpMixesCommandWithHttp,
+  CODEX_RESTART_AFTER_TRANSPORT_CHANGE,
+  codexMcpStartsCommand,
+  addCodexMcpServer,
+  readCodexMcpAuth,
+  isPusharyCodexCommand,
+  codexRegistrationHolder,
+  addCodexHooks,
+  removeCodexHooks,
+  hasCodexHooks,
+  missingCodexHookEvents,
+  codexHookPositions,
+  codexVacatedIndexes,
+  dropVacatedCodexHookTrust,
+  captureCodexHookTrust,
+  restoreCodexHookTrust,
+  codexTrustGaps,
+  removeCodexHookTrust,
+  removeCodexSettings,
+  addCodexHookTrust,
+  POSTTOOLUSE_MIRROR_ONLY_TOOLS,
+  IDLE_PROMPT_NOTIFICATION,
+  NOTIFICATION_PUSH_TYPES,
+  CLAUDE_HOOK_BINARY,
+  CLAUDE_HOOK_EVENTS,
+  supportedClaudeEvents,
+  registrationSignatures,
+  needsReregistration,
+  PUSHARY_MCP_URL,
+  isPusharyHook,
+  addClaudeMcpServer,
+  isClaudeMcpSnapshot,
+  captureClaudeMcpServer,
+  updateClaudeMcpSnapshot,
+  restoreClaudeMcpServer,
+  removeClaudeMcpServers,
+  removePusharyToolPermissions,
+  addPusharyToolPermissions,
+  addPusharyHooks,
+  removePusharySettings,
+  SHARED_AGENTS_MD_LABEL,
+  CODEX_INSTRUCTIONS_LABEL,
+  GEMINI_INSTRUCTIONS_LABEL,
+  OPENCODE_INSTRUCTIONS_LABEL,
+  renderAgentInstructions,
+  renderProjectAgentInstructions,
+  writeInstructionBlock,
+  refreshInstructionBlock,
+  removeInstructionBlock,
+  hasInstructionBlock,
+  CLINE_LABEL,
+  CLINE_AUTO_APPROVE_STEP,
+  CLINE_RELOAD_STEP,
+  CLINE_SETTINGS_REFUSALS,
+  CLINE_SERVER_NAME_TAKEN,
+  clineDataDirectory,
+  readClineSettings,
+  clineEntryRunsCommand,
+  isClinePusharyEntry,
+  clinePusharyEntryOf,
+  clineEntryAuthorization,
+  clineEntryUsesKey,
+  clineEntryHoldsLiteralKey,
+  clineEntrySignedIn,
+  clineEntrySwitchedOff,
+  clineServerNameTakenElsewhere,
+  withClinePusharyServer,
+  withRefreshedClineKey,
+  withoutClinePusharyServer,
+  otherPusharyServerNames,
+  clineSettingsText,
+  clineInstructionsBody,
+  claudeSettings,
+  claudeJson,
+  claudeSkillDir,
+  cursorPluginDir,
+  cursorUserHooks,
+  cursorPluginMcp,
+  cursorPluginManifest,
+  cursorPluginRule,
+  cursorUserMcp,
+  vscodePluginDir,
+  vscodePluginMcp,
+  claudeSettingsLocal,
+  pusharyDir,
+  claudeMcpReceipt,
+  bridgeAgentKey,
+  autoUpdateState,
+  autoUpdateLock,
+  serviceOwedBackMark,
+  autoUpdateLog,
+  clientReportClaims,
+  claudeRegistrationReceipt,
+  hermesConfig,
+  hermesConfigReceipt,
+  fxQuestionRuleReceipt,
+  hookTakeoverReceipt,
+  codexSkillDir2,
+  codexAgentsMd2,
+  geminiSettings,
+  geminiMd,
+  pusharyConfigFile,
+  fxConfigDir,
+  fxMcpProfile,
+  fxSettings,
+  fxAgentsMd,
+  clineMcpSettings,
+  clineRules
+};