pushary 1.8.0

package/dist/chunk-CULUZTWQ.js

@@ -0,0 +1,2117 @@
+import {
+  DEFAULT_SESSION,
+  isDefaultSession,
+  listPendingQuestions,
+  listPendingQuestionsForToolUse,
+  markPendingCommandDelivered,
+  readPendingCommand,
+  removePendingCommand,
+  removePendingQuestion,
+  removePendingSession,
+  savePendingCommand
+} from "./chunk-N6IOSZOE.js";
+import {
+  IDLE_PROMPT_NOTIFICATION,
+  NOTIFICATION_PUSH_TYPES,
+  POSTTOOLUSE_MIRROR_ONLY_TOOLS
+} from "./chunk-EPCXUP3P.js";
+import {
+  cancelQuestion,
+  isPolicyConfig,
+  sendNotification,
+  waitForAnswer
+} from "./chunk-NGDD6TXY.js";
+import {
+  clientErrorKindOf,
+  reportClientError
+} from "./chunk-CVQYGMSR.js";
+import {
+  withRetry
+} from "./chunk-M5ICYGHT.js";
+import {
+  getMachineId
+} from "./chunk-LXQ5FBBD.js";
+import {
+  reportedInstallSource
+} from "./chunk-DB3ONZB4.js";
+import {
+  canonicalJson
+} from "./chunk-A2A2YTMG.js";
+import {
+  writeFileAtomic
+} from "./chunk-T7E75EKA.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-GPEGOGRJ.js";
+import {
+  ACTION_BODY_MAX,
+  AGENT_LABELS_BY_TYPE,
+  BLOCKED_ACTION_GRANT_TTL_SECONDS,
+  DECISION_LINE_MAX,
+  FILE_TARGET_TOOLS,
+  GATE_MAX_TOOL_INPUTS,
+  HOOK_COMPATIBLE_PROFILES,
+  HOOK_SOURCES,
+  PENDING_COMMAND_PREFIX,
+  REPO_AWARE_AGENTS,
+  blockedActionIdentity,
+  canonicalToolName,
+  gateOutputFor,
+  hookCompatibleProfileBySource,
+  isAutoApprove,
+  localRepoKey,
+  modeStateFromResponse,
+  normalizeRepoRemote,
+  pendingCommandEvents,
+  redactSecrets,
+  redactSecretsDeep,
+  resolveAutoResolveOrigin,
+  resolvePolicy,
+  toToolLookup,
+  truncateLine
+} from "./chunk-NQTHFF4W.js";
+
+// src/policy.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+var CACHE_TTL_MS = 60 * 1e3;
+var STALE_CACHE_MAX_MS = 12 * 60 * 60 * 1e3;
+var policyRequestFor = (agentType) => ({
+  agent: agentType,
+  repoAware: REPO_AWARE_AGENTS.includes(agentType)
+});
+var policyCacheFile = (apiKey, agent, repoAware = false) => {
+  const parts = [apiKey, agent, repoAware ? "repoAware" : void 0, "sessionToolAware"].filter(Boolean);
+  const hash = createHash("sha256").update(parts.join(":")).digest("hex").slice(0, 12);
+  return join(tmpdir(), `pushary-policy-${hash}.json`);
+};
+var fetchPolicy = async (apiKey, agent, repoAware = false, sessionId) => {
+  return withRetry(async () => {
+    const baseUrl = getBaseUrl();
+    const params = new URLSearchParams();
+    if (agent) params.set("agent", agent);
+    if (repoAware) params.set("repoAware", "1");
+    params.set("scopeAware", "1");
+    params.set("sessionToolAware", "1");
+    if (sessionId) params.set("sessionId", sessionId);
+    const query = params.toString();
+    const url = query ? `${baseUrl}/api/mcp/policy?${query}` : `${baseUrl}/api/mcp/policy`;
+    const response = await fetch(url, {
+      headers: { "Authorization": `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch policy: ${response.status}`);
+    }
+    const raw = await response.json();
+    if (!isPolicyConfig(raw)) throw new Error("Invalid policy response");
+    return raw;
+  }, { maxAttempts: 2 });
+};
+var getPolicy = async (apiKey, expectedVersion, agent, repoAware = false, sessionId) => {
+  const path = policyCacheFile(apiKey, agent, repoAware);
+  let staleCache = null;
+  if (existsSync(path)) {
+    try {
+      const stat = readFileSync(path, "utf-8");
+      const cached = JSON.parse(stat);
+      if (!isPolicyConfig(cached)) throw new Error("Corrupted cache");
+      const versionStale = expectedVersion != null && (cached._policyVersion ?? null) !== expectedVersion;
+      const sessionStale = (cached._sessionId ?? null) !== (sessionId ?? null);
+      const age = cached._cachedAt ? Date.now() - cached._cachedAt : 0;
+      const ttlFresh = !cached._cachedAt || age < CACHE_TTL_MS;
+      if (ttlFresh && !versionStale && !sessionStale) {
+        return cached;
+      }
+      if (!sessionStale && age < STALE_CACHE_MAX_MS) staleCache = cached;
+    } catch {
+    }
+  }
+  try {
+    const policy = await fetchPolicy(apiKey, agent, repoAware, sessionId);
+    try {
+      writeFileSync(path, JSON.stringify({ ...policy, _cachedAt: Date.now(), _policyVersion: expectedVersion ?? null, _sessionId: sessionId ?? null }), { encoding: "utf-8", mode: 384 });
+    } catch {
+    }
+    return policy;
+  } catch {
+    if (staleCache) return staleCache;
+    throw new Error("Failed to fetch policy and no cached policy available");
+  }
+};
+var MODE_GRACE_MS = 60 * 1e3;
+var modeStateCacheFile = (apiKey) => {
+  const hash = createHash("sha256").update(`mode:${apiKey}`).digest("hex").slice(0, 12);
+  return join(tmpdir(), `pushary-mode-${hash}.json`);
+};
+var readLastGoodMode = (apiKey) => {
+  try {
+    const path = modeStateCacheFile(apiKey);
+    if (!existsSync(path)) return null;
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    if (!parsed || typeof parsed.at !== "number" || !parsed.state) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+var writeLastGoodMode = (apiKey, state, sessionId) => {
+  try {
+    const cached = { state, at: Date.now(), ...sessionId ? { sessionId } : {} };
+    writeFileSync(modeStateCacheFile(apiKey), JSON.stringify(cached), { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+};
+var unknownMode = () => ({
+  mode: null,
+  kill: false,
+  policyVersion: null,
+  relayUrl: null,
+  trainingConsent: false,
+  scope: null,
+  degraded: true
+});
+var degradedFallback = (apiKey, authoritative = false) => {
+  if (authoritative) return unknownMode();
+  const last = readLastGoodMode(apiKey);
+  if (last && Date.now() - last.at < MODE_GRACE_MS) {
+    return { ...last.state, degraded: false };
+  }
+  return unknownMode();
+};
+var MODE_REUSE_MS = CACHE_TTL_MS;
+var readReusableMode = (apiKey, sessionId, maxAgeMs) => {
+  const last = readLastGoodMode(apiKey);
+  if (!last || (last.sessionId ?? null) !== (sessionId ?? null)) return null;
+  if (Date.now() - last.at >= maxAgeMs) return null;
+  return { ...last.state, degraded: false };
+};
+var fetchModeState = async (apiKey, sessionId, reuseWithinMs = 0, signal) => {
+  if (reuseWithinMs > 0) {
+    const reusable = readReusableMode(apiKey, sessionId, reuseWithinMs);
+    if (reusable) return reusable;
+  }
+  try {
+    const baseUrl = getBaseUrl();
+    const url = sessionId ? `${baseUrl}/api/mcp/mode?session=${encodeURIComponent(sessionId)}` : `${baseUrl}/api/mcp/mode`;
+    const response = await fetch(url, {
+      headers: { "Authorization": `Bearer ${apiKey}` },
+      signal: AbortSignal.any([AbortSignal.timeout(3e3), ...signal ? [signal] : []])
+    });
+    if (!response.ok) {
+      void reportClientError({ kind: "http_status", code: `mode_http_${response.status}` });
+      return degradedFallback(apiKey, response.status === 401 || response.status === 403);
+    }
+    const state = modeStateFromResponse(await response.json());
+    writeLastGoodMode(apiKey, state, sessionId);
+    return state;
+  } catch (error) {
+    void reportClientError({ kind: clientErrorKindOf(error), code: "mode_fetch_failed" });
+    return degradedFallback(apiKey);
+  }
+};
+var fetchModeOverride = async (apiKey) => (await fetchModeState(apiKey)).mode;
+
+// ../hook-mapping/src/describe.ts
+import { isAbsolute, relative, resolve } from "path";
+var hookPrefixes = {
+  Bash: (input) => `bash: ${input.command ?? "(no command)"}`,
+  PowerShell: (input) => `powershell: ${input.command ?? "(no command)"}`,
+  Monitor: (input) => `monitor: ${input.command ?? "(no command)"}`,
+  Write: (input) => `write file: ${input.file_path ?? "(unknown path)"}`,
+  Edit: (input) => `edit file: ${input.file_path ?? "(unknown path)"}`,
+  MultiEdit: (input) => `edit file: ${input.file_path ?? "(unknown path)"}`,
+  Read: (input) => `read file: ${input.file_path ?? "(unknown path)"}`,
+  // Without an entry here the fallback stringifies the whole tool input, and for
+  // ExitPlanMode that input IS the plan: the action line became a truncated dump of
+  // the plan markdown. The plan belongs in the body, not the one-line summary.
+  ExitPlanMode: () => "finished planning and wants to start coding",
+  // Mirrored on PostToolUse since the matcher was widened. Without entries the
+  // fallback prints `Task: done` and `WebSearch: done`, which name the tool and
+  // drop the only part a person reads: which subagent, and what it looked for.
+  Task: (input) => `subagent: ${describeTaskCall(input)}`,
+  WebSearch: (input) => `web search: ${firstString(input.query) ?? "(no query)"}`
+};
+var describeTaskCall = (input) => firstString(input.description) ?? firstString(input.subagent_type) ?? "(unnamed)";
+var describeTodoProgress = (todos) => {
+  if (!Array.isArray(todos)) return "updated the plan";
+  const items = todos.filter((t) => !!t && typeof t === "object");
+  const total = items.length;
+  if (total === 0) return "updated the plan";
+  const done = items.filter((t) => t.status === "completed").length;
+  const current = items.find((t) => t.status === "in_progress");
+  const label = current ? [current.activeForm, current.content].find((v) => typeof v === "string" && v.trim().length > 0) : void 0;
+  if (done >= total) return `finished all ${total} tasks`;
+  if (label) return `${label.trim()} (${done}/${total} done)`;
+  return `${done}/${total} tasks done`;
+};
+var eventPrefixes = {
+  Bash: (input) => `ran: ${String(input.command ?? "")}`,
+  PowerShell: (input) => `ran: ${String(input.command ?? "")}`,
+  Monitor: (input) => `ran: ${String(input.command ?? "")}`,
+  Write: (input) => `wrote: ${input.file_path ?? "unknown"}`,
+  Edit: (input) => `edited: ${input.file_path ?? "unknown"}`,
+  MultiEdit: (input) => `edited: ${input.file_path ?? "unknown"}`,
+  Read: (input) => `read: ${input.file_path ?? "unknown"}`,
+  TodoWrite: (input) => describeTodoProgress(input.todos),
+  Task: (input) => `ran subagent: ${describeTaskCall(input)}`,
+  WebSearch: (input) => `searched: ${firstString(input.query) ?? "the web"}`
+};
+var MCP_TOOL_PREFIX = "mcp__";
+var parseMcpToolName = (toolName) => {
+  if (!toolName.startsWith(MCP_TOOL_PREFIX)) return void 0;
+  const rest = toolName.slice(MCP_TOOL_PREFIX.length);
+  const split = rest.indexOf("__");
+  if (split <= 0 || split + 2 >= rest.length) return void 0;
+  return { server: rest.slice(0, split), tool: rest.slice(split + 2) };
+};
+var NETWORK_TARGET_KEYS = ["url", "urls", "href", "host", "hosts", "hostname", "domain", "domains"];
+var ABSOLUTE_HTTP_URL = /^https?:\/\//i;
+var HOSTNAME = /^(?=.{1,253}$)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)+(?::\d{1,5})?$/i;
+var hostOfUrl = (value) => {
+  try {
+    return new URL(value).host || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var hostOf = (value, bareHostnames) => {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (ABSOLUTE_HTTP_URL.test(trimmed)) return hostOfUrl(trimmed);
+  return bareHostnames && HOSTNAME.test(trimmed) ? trimmed : void 0;
+};
+var firstHost = (value, bareHostnames) => Array.isArray(value) ? value.map((entry) => hostOf(entry, bareHostnames)).find((host) => host !== void 0) : hostOf(value, bareHostnames);
+var deriveNetworkTarget = (toolInput) => {
+  for (const key of NETWORK_TARGET_KEYS) {
+    const host = firstHost(toolInput[key], true);
+    if (host) return host;
+  }
+  return Object.values(toolInput).map((value) => firstHost(value, false)).find((host) => host !== void 0);
+};
+var describeUnbuiltCall = (toolName, toolInput, format) => {
+  const mcp = parseMcpToolName(toolName);
+  const host = deriveNetworkTarget(toolInput);
+  if (mcp) {
+    if (format === "event") return `called ${mcp.tool} on ${mcp.server}`;
+    return host ? `call ${mcp.tool} on ${mcp.server} to reach ${host}` : `call ${mcp.tool} on ${mcp.server}`;
+  }
+  if (host) return format === "event" ? `accessed ${host}` : `network access to ${host}`;
+  return void 0;
+};
+var EVENT_ACTION_MAX = 120;
+var HOOK_FALLBACK_MAX = 200;
+var UNNAMED_ACTION = "this request";
+var describeToolCall = (toolName, toolInput, format = "hook") => {
+  if (!toolName) return "";
+  const prefixes = format === "hook" ? hookPrefixes : eventPrefixes;
+  const builder = prefixes[toolName];
+  const unbuilt = builder ? void 0 : describeUnbuiltCall(toolName, toolInput ?? {}, format);
+  const detail = JSON.stringify(toolInput ?? {});
+  const raw = builder ? builder(toolInput) : unbuilt ?? (format === "hook" ? detail === "{}" || detail === void 0 ? toolName : `${toolName}: ${detail}` : `${toolName}: done`);
+  const redacted = redactSecrets(raw);
+  if (format === "event") return redacted.slice(0, EVENT_ACTION_MAX);
+  return builder || unbuilt ? redacted : redacted.slice(0, HOOK_FALLBACK_MAX);
+};
+var TOOL_TARGET_MAX_LENGTH = 80;
+var deriveCommandHead = (command) => {
+  if (typeof command !== "string") return void 0;
+  const head = command.trim().split(/\s+/).slice(0, 2).join(" ");
+  return head ? redactSecrets(head).slice(0, TOOL_TARGET_MAX_LENGTH) : void 0;
+};
+var deriveToolTarget = (toolName, toolInput) => {
+  if (toolName === "Bash" || toolName === "PowerShell" || toolName === "Monitor") {
+    return deriveCommandHead(toolInput.command);
+  }
+  if (FILE_TARGET_TOOLS.has(toolName)) {
+    const filePath = toolInput.file_path;
+    if (typeof filePath !== "string") return void 0;
+    const separator = Math.max(filePath.lastIndexOf("/"), filePath.lastIndexOf("\\"));
+    const base = filePath.slice(separator + 1);
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0) return void 0;
+    return base.slice(dot).slice(0, TOOL_TARGET_MAX_LENGTH);
+  }
+  const mcp = parseMcpToolName(toolName);
+  if (mcp) return mcp.server.slice(0, TOOL_TARGET_MAX_LENGTH);
+  return deriveNetworkTarget(toolInput)?.slice(0, TOOL_TARGET_MAX_LENGTH);
+};
+var SCRIPT_RUNNERS = /* @__PURE__ */ new Set(["npm", "pnpm", "yarn", "bun", "npx", "deno", "rake", "make", "just", "task", "turbo"]);
+var RUN_SUBCOMMANDS = /* @__PURE__ */ new Set(["run", "run-script", "exec", "task"]);
+var deriveReceiptCommandHead = (command) => {
+  if (typeof command !== "string") return void 0;
+  const tokens = command.trim().split(/\s+/);
+  const [first, second] = tokens;
+  const keep = first && second && SCRIPT_RUNNERS.has(first.toLowerCase()) && RUN_SUBCOMMANDS.has(second.toLowerCase()) ? 3 : 2;
+  const head = tokens.slice(0, keep).join(" ");
+  return head ? redactSecrets(head).slice(0, TOOL_TARGET_MAX_LENGTH) : void 0;
+};
+var RECEIPT_TARGET_MAX_LENGTH = 256;
+var parseApplyPatchOps = (command) => {
+  if (typeof command !== "string") return [];
+  const ops = [];
+  for (const line of command.split("\n")) {
+    const file = line.match(/^\*\*\*\s+(Add|Update|Delete) File:\s+(.+?)\s*$/);
+    if (file) {
+      ops.push({ op: file[1].toLowerCase(), path: file[2] });
+      continue;
+    }
+    const move = line.match(/^\*\*\*\s+Move to:\s+(.+?)\s*$/);
+    if (move) ops.push({ op: "move", path: move[1] });
+  }
+  return ops;
+};
+var parseApplyPatchFiles = (command) => [...new Set(parseApplyPatchOps(command).map((entry) => entry.path))];
+var OPENCODE_TOOL_NAMES = {
+  bash: "Bash",
+  // A shell command reaching outside the worktree asks a second time under its
+  // own key. It is still the same command, and still Bash.
+  external_directory: "Bash",
+  edit: "Edit",
+  patch: "Edit",
+  apply_patch: "Edit",
+  write: "Write",
+  read: "Read",
+  glob: "Glob",
+  grep: "Grep",
+  webfetch: "WebFetch",
+  websearch: "WebSearch",
+  task: "Task"
+};
+var PATCH_ARG_KEYS = ["command", "patch", "input"];
+var patchedFilesIn = (input) => [...new Set(PATCH_ARG_KEYS.flatMap((key) => parseApplyPatchFiles(input[key])))];
+var lookupsForInput = (profile, toolName, input, absolute) => {
+  const lookup = toToolLookup(profile, toolName, input, absolute);
+  if (!lookup.unreadable) return [lookup];
+  const files = patchedFilesIn(input);
+  if (files.length === 0) return [lookup];
+  return files.slice(0, GATE_MAX_TOOL_INPUTS + 1).map((file) => toToolLookup(profile, toolName, { ...input, file_path: absolute(file) }, absolute));
+};
+var compatibleGateInputs = (profile, toolName, toolInputs, cwd) => {
+  const absolute = (path) => cwd && !isAbsolute(path) ? resolve(cwd, path) : path;
+  const lookups = toolInputs.flatMap((input) => lookupsForInput(profile, toolName, input, absolute));
+  if (lookups.length > GATE_MAX_TOOL_INPUTS) return null;
+  if (lookups.some((lookup) => lookup.unreadable)) return null;
+  return {
+    toolName: lookups[0]?.tool ?? canonicalToolName(profile, toolName),
+    toolInputs: lookups.map((lookup) => lookup.input)
+  };
+};
+var canonicalGateInputs = (source, toolName, toolInputs, cwd) => {
+  if (source === "codex" && toolName === "apply_patch" || source === "vscode" && ["apply_patch", "applyPatch", "copilot_applyPatch"].includes(toolName)) {
+    const paths = [...new Set(toolInputs.flatMap((input) => parseApplyPatchFiles(input.command ?? input.input ?? input.patch)))];
+    if (paths.length > GATE_MAX_TOOL_INPUTS) return null;
+    return {
+      toolName: "Edit",
+      toolInputs: paths.length === 0 ? toolInputs.map((input) => ({ file_path: input.command })) : paths.map((path) => ({ file_path: cwd && !isAbsolute(path) ? resolve(cwd, path) : path }))
+    };
+  }
+  if (source === "opencode") {
+    const canonical2 = OPENCODE_TOOL_NAMES[toolName] ?? toolName;
+    return {
+      toolName: canonical2,
+      toolInputs: toolInputs.map((input) => {
+        const path = input.file_path;
+        return typeof path === "string" && path.length > 0 && cwd && !isAbsolute(path) ? { ...input, file_path: resolve(cwd, path) } : input;
+      })
+    };
+  }
+  if (source === "vscode" || source === "cursor") {
+    if (source === "vscode" && toolName.startsWith("mcp_pushary_")) return { toolName: `mcp__pushary__${toolName.slice("mcp_pushary_".length)}`, toolInputs };
+    const alias = toolName.replace(/^copilot_/, "").toLowerCase().replace(/[^a-z0-9]/g, "");
+    const shells = [
+      "runterminalcommand",
+      "runinterminal",
+      "runcommand",
+      "terminalcommand",
+      "executecommand",
+      "runinterminalcommand",
+      "bash",
+      "shell",
+      "terminal",
+      "sendtoterminal",
+      "powershell",
+      "localshell"
+    ];
+    const canonical2 = shells.includes(alias) ? "Bash" : ["createfile", "write", "createdirectory", "createnewjupyternotebook"].includes(alias) ? "Write" : ["replacestringinfile", "multireplacestringinfile", "replacestring", "multireplacestring", "inserteditintofile", "insertedit", "edit", "editfile", "editfiles", "editnotebookfile", "editnotebook"].includes(alias) ? "Edit" : [
+      "readfile",
+      "viewimage",
+      "listdir",
+      "listdirectory",
+      "filesearch",
+      "findfiles",
+      "grepsearch",
+      "findtextinfiles",
+      "semanticsearch",
+      "searchcodebase",
+      "searchworkspacesymbols",
+      "geterrors",
+      "getchangedfiles",
+      "readprojectstructure",
+      "getnotebooksummary",
+      "readnotebookcelloutput",
+      "testsearch",
+      "findtestfiles",
+      "testfailure",
+      "getvscodeapi",
+      "getterminaloutput",
+      "gettaskoutput",
+      "terminalselection",
+      "terminallastcommand"
+    ].includes(alias) ? "Read" : toolName;
+    const inputs = toolInputs.flatMap((input) => ["multireplacestringinfile", "multireplacestring"].includes(alias) && Array.isArray(input.replacements) ? input.replacements.filter((item) => !!item && typeof item === "object" && !Array.isArray(item)) : alias === "editfiles" && Array.isArray(input.files) ? input.files.map((file) => typeof file === "string" ? { file_path: file } : file).filter((file) => !!file && typeof file === "object" && !Array.isArray(file)) : [input]);
+    if (inputs.length > GATE_MAX_TOOL_INPUTS) return null;
+    return { toolName: canonical2, toolInputs: inputs.map((input) => {
+      if (canonical2 === "Bash") return { ...input, command: [input.command, input.commandLine, input.command_line, input.cmd, input.script, input.input, input.text].find((value) => typeof value === "string") };
+      const path = input.file_path ?? input.filePath ?? input.path;
+      return typeof path === "string" ? { ...input, file_path: cwd && !isAbsolute(path) ? resolve(cwd, path) : path } : input;
+    }) };
+  }
+  const profile = hookCompatibleProfileBySource(source);
+  if (profile) return compatibleGateInputs(profile, toolName, toolInputs, cwd);
+  if (source !== "gemini") return { toolName, toolInputs };
+  if (toolName === "run_shell_command") {
+    return { toolName: "Bash", toolInputs: toolInputs.map((input) => ({ command: input.command })) };
+  }
+  const canonical = { write_file: "Write", replace: "Edit", read_file: "Read" }[toolName];
+  if (!canonical) return { toolName, toolInputs };
+  return {
+    toolName: canonical,
+    toolInputs: toolInputs.map((input) => {
+      const path = [input.file_path, input.absolute_path, input.path].find((value) => typeof value === "string" && value.length > 0);
+      return path ? { file_path: cwd && !isAbsolute(path) ? resolve(cwd, path) : path } : {};
+    })
+  };
+};
+var EXIT_CODE_FAILURE = /^Error: Exit code \d+/;
+var isToolResultError = (toolResult) => {
+  try {
+    if (typeof toolResult === "string") return EXIT_CODE_FAILURE.test(toolResult);
+    if (!toolResult || typeof toolResult !== "object") return false;
+    return "error" in toolResult || "is_error" in toolResult;
+  } catch {
+    return false;
+  }
+};
+var toolResultErrorText = (toolResult) => {
+  try {
+    const raw = typeof toolResult === "string" ? toolResult : toolResult && typeof toolResult === "object" ? String(
+      toolResult.error ?? toolResult.stderr ?? ""
+    ) : "";
+    return redactSecrets(raw);
+  } catch {
+    return "";
+  }
+};
+var relativizeReceiptPath = (filePath, cwd) => {
+  if (!cwd || !isAbsolute(filePath)) return filePath;
+  return relative(cwd, filePath);
+};
+var deriveReceiptMeta = (toolName, toolInput, toolResult, cwd) => {
+  try {
+    const ok = !isToolResultError(toolResult);
+    if (toolName === "apply_patch") {
+      const files = parseApplyPatchFiles(toolInput.command);
+      const target = files.length === 1 ? files[0] : toolInput.command;
+      if (typeof target !== "string" || !target) return void 0;
+      return { kind: "edit", target: redactSecrets(target).slice(0, RECEIPT_TARGET_MAX_LENGTH), ok };
+    }
+    const canonicalTool = {
+      run_shell_command: "Bash",
+      write_file: "Write",
+      replace: "Edit"
+    }[toolName] ?? toolName;
+    const canonicalInput = canonicalTool === toolName ? toolInput : {
+      ...toolInput,
+      file_path: toolInput.file_path ?? toolInput.absolute_path ?? toolInput.path
+    };
+    if (FILE_TARGET_TOOLS.has(canonicalTool)) {
+      const filePath = canonicalInput.file_path;
+      if (typeof filePath !== "string" || !filePath) return void 0;
+      return {
+        kind: canonicalTool === "Write" ? "write" : "edit",
+        // A path is an unlikely place for a credential but not an impossible one
+        // (a token in a temp directory name), and this field is persisted.
+        target: redactSecrets(relativizeReceiptPath(filePath, cwd)).slice(0, RECEIPT_TARGET_MAX_LENGTH),
+        ok
+      };
+    }
+    if (canonicalTool === "Bash" || canonicalTool === "PowerShell" || canonicalTool === "Monitor") {
+      const head = deriveReceiptCommandHead(canonicalInput.command);
+      if (!head) return void 0;
+      return {
+        kind: head === "git commit" ? "commit" : "bash",
+        target: head,
+        ok
+      };
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var scopePathFor = (toolName, toolInput, cwd) => {
+  const meta = deriveReceiptMeta(toolName, toolInput, void 0, cwd);
+  if (!meta) return void 0;
+  return meta.kind === "edit" || meta.kind === "write" ? meta.target : void 0;
+};
+var firstString = (...values) => values.find((v) => typeof v === "string" && v.length > 0);
+var ACTION_BODY_TRUNCATION_MARKER = "\n\u2026 [truncated]";
+var capActionBody = (text) => truncateLine(text, ACTION_BODY_MAX, ACTION_BODY_TRUNCATION_MARKER);
+var rawActionBody = (toolName, toolInput) => {
+  if (toolName === "Edit" || toolName === "replace") {
+    const before = firstString(toolInput.old_string);
+    const after = firstString(toolInput.new_string);
+    if (before === void 0 && after === void 0) return firstString(toolInput.diff);
+    return `- ${before ?? ""}
++ ${after ?? ""}`;
+  }
+  if (toolName === "Write" || toolName === "write_file") {
+    return firstString(toolInput.content) ?? firstString(toolInput.diff);
+  }
+  if (toolName === "ExitPlanMode") return firstString(toolInput.plan);
+  if (toolName === "Bash" || toolName === "PowerShell" || toolName === "Monitor" || toolName === "run_shell_command" || toolName === "shell" || toolName === "apply_patch") {
+    return firstString(toolInput.command);
+  }
+  return firstString(toolInput.url, toolInput.href);
+};
+var deriveActionBody = (toolName, toolInput) => {
+  try {
+    const raw = rawActionBody(toolName, toolInput);
+    if (!raw) return void 0;
+    return capActionBody(redactSecretsDeep(raw));
+  } catch {
+    return void 0;
+  }
+};
+var deriveAction = (toolName, toolInput) => truncateLine(describeToolCall(toolName, toolInput, "hook"), DECISION_LINE_MAX);
+var BLOCKER_BY_MODE = {
+  push_only: "Approval required before this runs",
+  push_first: "Paused for your approval before continuing",
+  escalate: "Escalated to you after the approval timeout"
+};
+var deriveBlocker = (mode, reason) => {
+  const text = reason?.replace(/\s+/g, " ").trim() || BLOCKER_BY_MODE[mode] || "Waiting for your approval";
+  return truncateLine(text, DECISION_LINE_MAX);
+};
+
+// ../hook-mapping/src/map.ts
+import { basename } from "path";
+var AGENT_IDENTITIES = {
+  claude: { type: "claude_code", label: AGENT_LABELS_BY_TYPE.claude_code },
+  codex: { type: "codex", label: AGENT_LABELS_BY_TYPE.codex },
+  gemini: { type: "gemini_cli", label: AGENT_LABELS_BY_TYPE.gemini_cli },
+  cursor: { type: "cursor", label: AGENT_LABELS_BY_TYPE.cursor },
+  vscode: { type: "vscode", label: AGENT_LABELS_BY_TYPE.vscode },
+  opencode: { type: "opencode", label: AGENT_LABELS_BY_TYPE.opencode },
+  qwen: { type: "qwen_code", label: AGENT_LABELS_BY_TYPE.qwen_code },
+  codebuddy: { type: "codebuddy", label: AGENT_LABELS_BY_TYPE.codebuddy },
+  qoder: { type: "qoder", label: AGENT_LABELS_BY_TYPE.qoder },
+  droid: { type: "droid", label: AGENT_LABELS_BY_TYPE.droid },
+  devin: { type: "devin", label: AGENT_LABELS_BY_TYPE.devin }
+};
+var TEAMMATE_IDLE_ACTION = "A teammate went idle";
+var CLAUDE_MEANINGS = {
+  PostToolUse: { kind: "tool", event: "tool_complete" },
+  UserPromptSubmit: { kind: "prompt", event: "user_prompt" },
+  Stop: { kind: "stop", event: "session_end" },
+  SubagentStop: { kind: "subagent_stop", event: "session_end" },
+  PreCompact: { kind: "compaction", event: "compaction" },
+  PostCompact: { kind: "compaction", event: "compaction" },
+  SessionStart: { kind: "session_start", event: "session_start" },
+  SessionEnd: { kind: "session_closed", event: "session_closed" },
+  SubagentStart: { kind: "session_start", event: "session_start", action: "Subagent started" },
+  Notification: { kind: "notification", event: "notification" },
+  TeammateIdle: { kind: "teammate_idle", event: "teammate_idle", action: TEAMMATE_IDLE_ACTION },
+  StopFailure: { kind: "stop_failure", event: "turn_error" },
+  PermissionDenied: { kind: "permission_denied", event: "permission_denied" }
+};
+var compatibleMeanings = (agentType) => {
+  const events = HOOK_COMPATIBLE_PROFILES.find((profile) => profile.agentType === agentType)?.events ?? [];
+  return Object.fromEntries(events.flatMap((event) => {
+    const meaning = CLAUDE_MEANINGS[event];
+    return meaning ? [[event, meaning]] : [];
+  }));
+};
+var MEANING_BY_HOOK = {
+  claude: CLAUDE_MEANINGS,
+  qwen: compatibleMeanings("qwen_code"),
+  codebuddy: compatibleMeanings("codebuddy"),
+  qoder: compatibleMeanings("qoder"),
+  droid: compatibleMeanings("droid"),
+  devin: compatibleMeanings("devin"),
+  codex: {
+    PostToolUse: { kind: "tool", event: "tool_complete" },
+    UserPromptSubmit: { kind: "prompt", event: "user_prompt" },
+    Stop: { kind: "stop", event: "session_end" },
+    SessionStart: { kind: "session_start", event: "session_begin", action: "Session started" },
+    SessionEnd: { kind: "session_closed", event: "session_closed" },
+    // Codex names all four in its own HookEventName enum, and the CLI registers
+    // them. A row missing here is the same defect as the dropped Codex
+    // SessionEnd: the CLI reports the event, the Mac app forwards the identical
+    // envelope, and only the app's copy vanishes.
+    SubagentStart: { kind: "session_start", event: "session_begin", action: "Subagent started" },
+    SubagentStop: { kind: "subagent_stop", event: "session_end" },
+    PreCompact: { kind: "compaction", event: "compaction" },
+    PostCompact: { kind: "compaction", event: "compaction" }
+  },
+  gemini: {
+    AfterTool: { kind: "tool", event: "tool_complete" },
+    BeforeAgent: { kind: "prompt", event: "user_prompt" },
+    AfterAgent: { kind: "stop", event: "session_end" },
+    SessionStart: { kind: "session_start", event: "session_begin", action: "Session started" },
+    SessionEnd: { kind: "session_closed", event: "session_closed" }
+  },
+  cursor: {
+    afterShellExecution: { kind: "tool", event: "tool_complete" },
+    afterFileEdit: { kind: "tool", event: "tool_complete" },
+    postToolUse: { kind: "tool", event: "tool_complete" },
+    stop: { kind: "stop", event: "session_end" },
+    sessionStart: { kind: "session_start", event: "session_begin" },
+    sessionEnd: { kind: "session_closed", event: "session_closed" },
+    beforeSubmitPrompt: { kind: "prompt", event: "user_prompt" },
+    preCompact: { kind: "compaction", event: "compaction" },
+    subagentStart: { kind: "session_start", event: "session_begin", action: "Subagent started" },
+    subagentStop: { kind: "subagent_stop", event: "notification" }
+  },
+  vscode: {
+    PostToolUse: { kind: "tool", event: "tool_complete" },
+    Stop: { kind: "stop", event: "session_end" },
+    SessionStart: { kind: "session_start", event: "session_begin" },
+    UserPromptSubmit: { kind: "prompt", event: "user_prompt" },
+    PreCompact: { kind: "compaction", event: "compaction" },
+    SubagentStart: { kind: "session_start", event: "session_begin", action: "Subagent started" },
+    SubagentStop: { kind: "subagent_stop", event: "session_end" }
+  },
+  // OpenCode's own names, because the plugin sends the hook it was called from
+  // rather than translating. `session.idle` is the turn boundary — its Stop, not
+  // its SessionEnd — and there is no session-start entry on purpose: OpenCode
+  // publishes `session.created` for every subagent fork too.
+  opencode: {
+    "tool.execute.after": { kind: "tool", event: "tool_complete" },
+    "chat.message": { kind: "prompt", event: "user_prompt" },
+    "session.idle": { kind: "stop", event: "session_end" }
+  }
+};
+var TASK_TITLE_MAX_LENGTH = 120;
+var STOP_SUMMARY_MAX_LENGTH = 200;
+var SESSION_END_ACTIONS = {
+  clear: "Session cleared",
+  logout: "Logged out",
+  resume: "Session suspended",
+  prompt_input_exit: "Session ended",
+  bypass_permissions_disabled: "Session ended",
+  other: "Session ended"
+};
+var countArray = (value) => Array.isArray(value) ? value.length : 0;
+var summarizeFinalMessage = (message) => {
+  if (typeof message !== "string") return "Session ended";
+  const collapsed = message.replace(/\s+/g, " ").trim();
+  if (!collapsed) return "Session ended";
+  return collapsed.slice(0, STOP_SUMMARY_MAX_LENGTH);
+};
+var summarizeStop = (input) => {
+  const running = countArray(input.background_tasks);
+  if (running > 0) return `Paused with ${running} background task${running === 1 ? "" : "s"} still running`;
+  const crons = countArray(input.session_crons);
+  if (crons > 0) return `Idle until a scheduled task wakes it (${crons} pending)`;
+  return summarizeFinalMessage(input.last_assistant_message ?? input.prompt_response);
+};
+var subagentStopAction = (agentType) => {
+  const name = typeof agentType === "string" ? agentType.replace(/\s+/g, " ").trim() : "";
+  return name ? `${name} subagent finished` : "Subagent finished";
+};
+var subagentStopSummary = (input) => {
+  const message = input.last_assistant_message ?? input.prompt_response;
+  if (typeof message === "string" && message.trim()) return summarizeStop(input);
+  return subagentStopAction(input.agent_type);
+};
+var COMPACTION_TRIGGERS = {
+  manual: "on request",
+  auto: "automatically"
+};
+var compactionAction = (hookEvent, trigger) => {
+  const how = typeof trigger === "string" ? COMPACTION_TRIGGERS[trigger] : void 0;
+  const base = hookEvent === "PostCompact" ? "Compacted context" : "Compacting context";
+  return how ? `${base} ${how}` : base;
+};
+var sessionStartAction = (source) => source === "resume" ? "Session resumed" : "Session started";
+var sessionEndAction = (reason) => typeof reason === "string" && SESSION_END_ACTIONS[reason] || "Session ended";
+var taskTitleFrom = (prompt) => typeof prompt === "string" ? prompt.replace(/\s+/g, " ").trim().slice(0, TASK_TITLE_MAX_LENGTH) || void 0 : void 0;
+var asString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var NOTIFICATION_ACTION_MAX_LENGTH = 200;
+var STOP_FAILURE_REASON_MAX_LENGTH = 300;
+var notificationTypeOf = (payload) => asString(payload.notification_type) ?? asString(payload.type);
+var notificationAction = (payload) => {
+  const text = asString(payload.message) ?? asString(payload.title);
+  const collapsed = redactSecrets(text ?? "").replace(/\s+/g, " ").trim();
+  return collapsed ? collapsed.slice(0, NOTIFICATION_ACTION_MAX_LENGTH) : "Notification";
+};
+var STOP_FAILURE_REASONS = {
+  rate_limit: "Rate limited by the API",
+  overloaded: "The API is overloaded right now",
+  authentication_failed: "Authentication failed",
+  billing_error: "A billing error stopped the turn"
+};
+var STOP_FAILURE_FALLBACK = "The turn ended on an API error (rate limit, billing, or auth).";
+var describeStopFailure = (error) => {
+  const fromString = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) return void 0;
+    return STOP_FAILURE_REASONS[trimmed] ?? redactSecrets(trimmed).slice(0, STOP_FAILURE_REASON_MAX_LENGTH);
+  };
+  if (typeof error === "string") {
+    const described = fromString(error);
+    if (described) return described;
+  } else if (error && typeof error === "object") {
+    for (const key of ["type", "message", "error", "code"]) {
+      const value = error[key];
+      if (typeof value === "string") {
+        const described = fromString(value);
+        if (described) return described;
+      }
+    }
+  }
+  return STOP_FAILURE_FALLBACK;
+};
+var permissionDeniedAction = (toolName) => {
+  const tool = asString(toolName);
+  return tool ? `Auto-mode blocked ${tool}` : "Auto-mode blocked a tool call";
+};
+var sessionIdentityOf = (payload) => {
+  const sessionId = asString(payload.session_id ?? payload.sessionId ?? payload.conversation_id);
+  const agentId = asString(payload.agent_id);
+  if (!agentId) return { sessionId };
+  return { sessionId: agentId, parentSessionId: sessionId };
+};
+
+// ../hook-mapping/src/codex-rollout.ts
+var CODEX_TURN_CONTEXT_TYPE = "turn_context";
+var CODEX_AUTO_REVIEWER = "auto_review";
+var CODEX_GUARDIAN_THREAD_SOURCE = "guardian_review";
+var CODEX_PLANNED_ACTION_MARKER = "Planned action JSON:\n";
+var CODEX_APPROVAL_REQUEST_END = ">>> APPROVAL REQUEST END";
+var CODEX_SHELL_TOOL = "exec_command";
+var CODEX_SHELL_COMMAND_FLAGS = ["-lc", "-c"];
+var asRecord = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+var parseRecord = (text) => {
+  try {
+    return asRecord(JSON.parse(text));
+  } catch {
+    return null;
+  }
+};
+var nonEmptyString = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var isTimestamp = (value) => typeof value === "string" && Number.isFinite(Date.parse(value));
+var readCodexTurnContext = (line) => {
+  const entry = parseRecord(line);
+  if (entry?.type !== CODEX_TURN_CONTEXT_TYPE) return null;
+  const payload = asRecord(entry.payload);
+  const turnId = nonEmptyString(payload?.turn_id);
+  if (!payload || !turnId) return null;
+  return {
+    turnId,
+    approvalsReviewer: payload.approvals_reviewer === CODEX_AUTO_REVIEWER ? "auto_review" : "user",
+    ...isTimestamp(entry.timestamp) ? { startedAt: entry.timestamp } : {}
+  };
+};
+var isCodexGuardianRolloutHead = (line, sessionId) => {
+  if (!sessionId) return false;
+  const entry = parseRecord(line);
+  const payload = asRecord(entry?.payload);
+  return entry?.type === "session_meta" && payload?.parent_thread_id === sessionId && payload.thread_source === CODEX_GUARDIAN_THREAD_SOURCE;
+};
+var readCodexPlannedAction = (message) => {
+  const marker = message.lastIndexOf(CODEX_PLANNED_ACTION_MARKER);
+  if (marker < 0) return null;
+  const body = message.slice(marker + CODEX_PLANNED_ACTION_MARKER.length);
+  const end = body.lastIndexOf(CODEX_APPROVAL_REQUEST_END);
+  if (end < 0 || body.slice(end + CODEX_APPROVAL_REQUEST_END.length).trim().length > 0) return null;
+  return parseRecord(body.slice(0, end).trim());
+};
+var readCodexReviewVerdict = (message) => {
+  const verdict = parseRecord(message.trim());
+  if (verdict?.outcome !== "allow" && verdict?.outcome !== "deny") return null;
+  const rationale = typeof verdict.rationale === "string" ? verdict.rationale.trim() : "";
+  return { outcome: verdict.outcome, ...rationale ? { rationale } : {} };
+};
+var scanCodexGuardianReviews = (lines) => {
+  const reviews = [];
+  let pending = null;
+  for (const line of lines) {
+    const entry = parseRecord(line.text);
+    const payload = asRecord(entry?.payload);
+    if (entry?.type !== "event_msg" || typeof payload?.message !== "string") continue;
+    if (payload.type === "user_message") {
+      const plannedAction = readCodexPlannedAction(payload.message);
+      pending = plannedAction ? { offset: line.offset, plannedAction, ...isTimestamp(entry.timestamp) ? { requestedAt: entry.timestamp } : {} } : null;
+      continue;
+    }
+    if (payload.type !== "agent_message" || !pending) continue;
+    const verdict = readCodexReviewVerdict(payload.message);
+    if (!verdict) continue;
+    reviews.push({ ...pending, verdict });
+    pending = null;
+  }
+  return { reviews, ...pending ? { pendingOffset: pending.offset } : {} };
+};
+var codexPlannedShellCommand = (plannedAction) => {
+  if (plannedAction?.tool !== CODEX_SHELL_TOOL) return null;
+  const argv = plannedAction.command;
+  if (!Array.isArray(argv) || argv.length !== 3) return null;
+  const [shell, flag, command] = argv;
+  if (typeof shell !== "string" || shell.trim().length === 0) return null;
+  if (typeof flag !== "string" || !CODEX_SHELL_COMMAND_FLAGS.includes(flag)) return null;
+  if (typeof command !== "string" || command.trim().length === 0) return null;
+  const cwd = nonEmptyString(plannedAction.cwd);
+  return { command, ...cwd ? { cwd } : {} };
+};
+var codexReviewerDenialsSince = (reviews, since) => {
+  const sinceMs = Date.parse(since);
+  if (!Number.isFinite(sinceMs)) return [];
+  return reviews.flatMap((review) => {
+    if (review.verdict.outcome !== "deny" || !review.requestedAt) return [];
+    if (Date.parse(review.requestedAt) < sinceMs) return [];
+    const shell = codexPlannedShellCommand(review.plannedAction);
+    if (!shell) return [];
+    return [{
+      ...shell,
+      offset: review.offset,
+      requestedAt: review.requestedAt,
+      plannedAction: review.plannedAction,
+      ...review.verdict.rationale ? { rationale: review.verdict.rationale } : {}
+    }];
+  });
+};
+
+// src/repo.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "fs";
+import { basename as basename2, dirname, isAbsolute as isAbsolute2, join as join2, resolve as resolve2 } from "path";
+var MAX_PARENT_WALK = 64;
+var GIT_FILE_PREFIX = "gitdir:";
+var findGitDir = (startDir) => {
+  let current = resolve2(startDir);
+  for (let depth = 0; depth < MAX_PARENT_WALK; depth += 1) {
+    const candidate = join2(current, ".git");
+    try {
+      if (existsSync2(candidate)) {
+        if (statSync(candidate).isDirectory()) return candidate;
+        const pointer = readFileSync2(candidate, "utf-8").trim();
+        if (pointer.startsWith(GIT_FILE_PREFIX)) {
+          const target = pointer.slice(GIT_FILE_PREFIX.length).trim();
+          return isAbsolute2(target) ? target : resolve2(current, target);
+        }
+      }
+    } catch {
+    }
+    const parent = dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
+  return void 0;
+};
+var configPathFor = (gitDir) => {
+  const index = gitDir.replace(/\\/g, "/").indexOf("/worktrees/");
+  return index === -1 ? join2(gitDir, "config") : join2(gitDir.slice(0, index), "config");
+};
+var ORIGIN_SECTION = /^\[remote "origin"\]/;
+var SECTION_HEADER = /^\[/;
+var URL_LINE = /^url\s*=\s*(.+)$/;
+var readOriginRemote = (gitDir) => {
+  try {
+    const configPath = configPathFor(gitDir);
+    if (!existsSync2(configPath)) return void 0;
+    let inOrigin = false;
+    for (const rawLine of readFileSync2(configPath, "utf-8").split("\n")) {
+      const line = rawLine.trim();
+      if (SECTION_HEADER.test(line)) {
+        inOrigin = ORIGIN_SECTION.test(line);
+        continue;
+      }
+      if (!inOrigin) continue;
+      const url = URL_LINE.exec(line);
+      if (url) return url[1]?.trim();
+    }
+  } catch {
+  }
+  return void 0;
+};
+var deriveRepoKey = (cwd) => {
+  const dir = cwd && cwd.length > 0 ? cwd : process.cwd();
+  try {
+    const gitDir = findGitDir(dir);
+    if (gitDir) {
+      const remote = readOriginRemote(gitDir);
+      const normalized = remote ? normalizeRepoRemote(remote) : void 0;
+      if (normalized) return normalized;
+      const root = gitDir.endsWith(".git") ? dirname(gitDir) : dir;
+      return localRepoKey(basename2(root));
+    }
+    return localRepoKey(basename2(resolve2(dir)));
+  } catch {
+    return void 0;
+  }
+};
+var repoKeyCache = /* @__PURE__ */ new Map();
+var REPO_KEY_ENV = "PUSHARY_REPO_KEY";
+var repoKeyFor = (cwd) => {
+  const override = process.env[REPO_KEY_ENV];
+  if (typeof override === "string") {
+    const trimmed = override.trim();
+    if (trimmed.toLowerCase() === "off") return void 0;
+    if (trimmed.length > 0) return trimmed.toLowerCase();
+  }
+  const dir = cwd && cwd.length > 0 ? cwd : process.cwd();
+  if (repoKeyCache.has(dir)) return repoKeyCache.get(dir);
+  const derived = deriveRepoKey(dir);
+  repoKeyCache.set(dir, derived);
+  return derived;
+};
+
+// src/usage.ts
+import { closeSync, mkdirSync, openSync, readFileSync as readFileSync3, readSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "fs";
+import { createHash as createHash2 } from "crypto";
+import { join as join3 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+var DEFAULT_PRICES = [
+  { match: "opus-4-1", in: 15, out: 75 },
+  { match: "opus-4-0", in: 15, out: 75 },
+  { match: "3-opus", in: 15, out: 75 },
+  { match: "opus", in: 5, out: 25 },
+  { match: "haiku", in: 1, out: 5 },
+  { match: "sonnet", in: 3, out: 15 }
+];
+var FALLBACK_PRICE = { match: "", in: 3, out: 15 };
+var CACHE_WRITE_MULTIPLIER = 1.25;
+var CACHE_READ_MULTIPLIER = 0.1;
+var RECENT_ID_LIMIT = 200;
+var READ_CHUNK_BYTES = 1024 * 1024;
+var isModelPrice = (value) => {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.match === "string" && typeof candidate.in === "number" && typeof candidate.out === "number";
+};
+var priceTable = () => {
+  const raw = process.env.PUSHARY_MODEL_PRICING?.trim();
+  if (!raw) return DEFAULT_PRICES;
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed) && parsed.length > 0 && parsed.every(isModelPrice)) return parsed;
+  } catch {
+  }
+  return DEFAULT_PRICES;
+};
+var estimateCostUsd = (usage, model) => {
+  const price = priceTable().find((p) => model.includes(p.match)) ?? FALLBACK_PRICE;
+  const perTokenIn = price.in / 1e6;
+  const perTokenOut = price.out / 1e6;
+  return usage.inputTokens * perTokenIn + usage.outputTokens * perTokenOut + usage.cacheCreationTokens * perTokenIn * CACHE_WRITE_MULTIPLIER + usage.cacheReadTokens * perTokenIn * CACHE_READ_MULTIPLIER;
+};
+var stateDir = () => process.env.PUSHARY_USAGE_DIR?.trim() || join3(tmpdir2(), "pushary-usage");
+var stateFile = (sessionId) => join3(stateDir(), sessionId.replace(/[^a-zA-Z0-9_-]/g, "_"));
+var emptyState = () => ({ offset: 0, tokensIn: 0, tokensOut: 0, costUsd: 0, recentIds: [] });
+var readState = (path) => {
+  try {
+    const parsed = JSON.parse(readFileSync3(path, "utf-8"));
+    if (typeof parsed.offset === "number" && parsed.offset >= 0 && typeof parsed.tokensIn === "number" && typeof parsed.tokensOut === "number" && typeof parsed.costUsd === "number" && Array.isArray(parsed.recentIds)) {
+      return {
+        offset: parsed.offset,
+        tokensIn: parsed.tokensIn,
+        tokensOut: parsed.tokensOut,
+        costUsd: parsed.costUsd,
+        recentIds: parsed.recentIds.filter((id) => typeof id === "string")
+      };
+    }
+  } catch {
+  }
+  return emptyState();
+};
+var readRange = (path, start, end) => {
+  const fd = openSync(path, "r");
+  try {
+    const chunks = [];
+    let position = start;
+    while (position < end) {
+      const length = Math.min(READ_CHUNK_BYTES, end - position);
+      const buffer = Buffer.alloc(length);
+      const bytesRead = readSync(fd, buffer, 0, length, position);
+      if (bytesRead <= 0) break;
+      chunks.push(buffer.subarray(0, bytesRead));
+      position += bytesRead;
+    }
+    return Buffer.concat(chunks);
+  } finally {
+    closeSync(fd);
+  }
+};
+var toCount = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+var applyLine = (state, line) => {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return 0;
+  }
+  if (parsed.type !== "assistant") return 0;
+  const usage = parsed.message?.usage;
+  if (!usage || typeof usage !== "object") return 0;
+  const model = typeof parsed.message?.model === "string" ? parsed.message.model : "";
+  if (model.includes("<synthetic>")) return 0;
+  const id = typeof parsed.message?.id === "string" ? parsed.message.id : null;
+  if (id) {
+    if (state.recentIds.includes(id)) return 0;
+    state.recentIds.push(id);
+    if (state.recentIds.length > RECENT_ID_LIMIT) state.recentIds.splice(0, state.recentIds.length - RECENT_ID_LIMIT);
+  }
+  const messageUsage = {
+    inputTokens: toCount(usage.input_tokens),
+    outputTokens: toCount(usage.output_tokens),
+    cacheCreationTokens: toCount(usage.cache_creation_input_tokens),
+    cacheReadTokens: toCount(usage.cache_read_input_tokens)
+  };
+  const cost = estimateCostUsd(messageUsage, model);
+  state.tokensIn += messageUsage.inputTokens + messageUsage.cacheCreationTokens + messageUsage.cacheReadTokens;
+  state.tokensOut += messageUsage.outputTokens;
+  state.costUsd += cost;
+  return cost;
+};
+var USER_PROMPT_TAIL_BYTES = 256 * 1024;
+var USER_PROMPT_MAX = 2048;
+var extractUserText = (content) => {
+  if (typeof content === "string") return content.replace(/\s+/g, " ").trim() || void 0;
+  if (Array.isArray(content)) {
+    const text = content.filter((block) => Boolean(block) && typeof block === "object").filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join(" ").replace(/\s+/g, " ").trim();
+    return text || void 0;
+  }
+  return void 0;
+};
+var readLastUserPrompt = (transcriptPath) => {
+  try {
+    const size = statSync2(transcriptPath).size;
+    const start = Math.max(0, size - USER_PROMPT_TAIL_BYTES);
+    const lines = readRange(transcriptPath, start, size).toString("utf-8").split("\n");
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const line = lines[i].trim();
+      if (!line) continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (parsed.type !== "user") continue;
+      const text = extractUserText(parsed.message?.content);
+      if (text) return text.slice(0, USER_PROMPT_MAX);
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+var readNewUsage = (transcriptPath, sessionId) => {
+  try {
+    const file = statSync2(transcriptPath);
+    const size = file.size;
+    const path = stateFile(sessionId);
+    let state = readState(path);
+    if (size < state.offset) state = { ...emptyState(), recentIds: state.recentIds };
+    const startOffset = state.offset;
+    let deltaUsd = 0;
+    if (size > state.offset) {
+      const buffer = readRange(transcriptPath, state.offset, size);
+      const lastNewline = buffer.lastIndexOf(10);
+      if (lastNewline >= 0) {
+        const complete = buffer.subarray(0, lastNewline + 1);
+        for (const line of complete.toString("utf-8").split("\n")) {
+          if (line.trim()) deltaUsd += applyLine(state, line);
+        }
+        state.offset += lastNewline + 1;
+      }
+    }
+    mkdirSync(stateDir(), { recursive: true });
+    writeFileSync2(path, JSON.stringify(state), "utf-8");
+    if (state.tokensIn === 0 && state.tokensOut === 0) return null;
+    return {
+      // Identical cursor-range reports share an identity across transport retries.
+      // Native message identity distinguishes an in-place rotation of the range.
+      // This does not serialize readers of different, potentially overlapping ranges.
+      eventId: createHash2("sha256").update(JSON.stringify([
+        sessionId,
+        file.dev,
+        file.ino,
+        startOffset,
+        state.offset,
+        state.recentIds.at(-1)
+      ])).digest("hex").slice(0, 32),
+      reportedAt: Date.now(),
+      tokensIn: state.tokensIn,
+      tokensOut: state.tokensOut,
+      costUsd: state.costUsd,
+      deltaUsd
+    };
+  } catch {
+    return null;
+  }
+};
+
+// src/codex-adapter.ts
+import { resolve as resolve3 } from "path";
+var CODEX_AGENT = { type: "codex", label: "Codex" };
+var codexAllow = () => ({ kind: "allow" });
+var codexDeny = (reason) => ({ kind: "deny", reason });
+var codexPass = () => ({ kind: "pass" });
+var toCodexWire = (event, decision) => {
+  if (decision.kind === "pass") return null;
+  return gateOutputFor(
+    "codex",
+    event,
+    decision.kind,
+    decision.kind === "deny" ? decision.reason : void 0
+  ) ?? null;
+};
+var describeApplyPatch = (command) => {
+  const ops = parseApplyPatchOps(command);
+  if (ops.length === 0) return null;
+  const files = [...new Set(ops.map((entry) => entry.path))];
+  if (files.length === 1) {
+    const verb = ops[0].op === "add" ? "create" : ops[0].op === "delete" ? "delete" : ops[0].op === "move" ? "move" : "edit";
+    return `${verb} file: ${files[0]}`;
+  }
+  return `apply patch to ${files.length} files`;
+};
+var toPolicyLookup = (toolName, toolInput, cwd) => {
+  if (toolName !== "apply_patch") return { tool: toolName, input: toolInput };
+  const command = toolInput.command;
+  const files = parseApplyPatchFiles(command);
+  if (files.length === 1) {
+    return { tool: "Edit", input: { file_path: cwd ? resolve3(cwd, files[0]) : files[0] } };
+  }
+  return { tool: "Edit", input: typeof command === "string" ? { file_path: command } : {} };
+};
+var toPolicyLookups = (toolName, toolInput, cwd) => {
+  if (toolName !== "apply_patch") {
+    const single = toPolicyLookup(toolName, toolInput, cwd);
+    return { tool: single.tool, inputs: [single.input] };
+  }
+  const files = parseApplyPatchFiles(toolInput.command);
+  if (files.length === 0) {
+    const single = toPolicyLookup(toolName, toolInput, cwd);
+    return { tool: single.tool, inputs: [single.input] };
+  }
+  return {
+    tool: "Edit",
+    inputs: files.map((file) => ({ file_path: cwd ? resolve3(cwd, file) : file }))
+  };
+};
+var permissionTimeoutDecision = (timeoutAction) => {
+  if (timeoutAction === "approve") return codexAllow();
+  if (timeoutAction === "deny") return codexDeny("No response within timeout");
+  return codexPass();
+};
+var preToolUseTimeoutDecision = (timeoutAction, denyReason = "No response within timeout") => timeoutAction === "deny" ? codexDeny(denyReason) : codexPass();
+
+// src/codex-call-decision.ts
+import { createHash as createHash3 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync4, readdirSync, rmSync, statSync as statSync3, writeFileSync as writeFileSync3 } from "fs";
+import { tmpdir as tmpdir3, userInfo } from "os";
+import { join as join4 } from "path";
+var CODEX_DECISION_TTL_MS = 60 * 1e3;
+var userScope = () => {
+  try {
+    const info = userInfo();
+    const id = typeof info.uid === "number" && info.uid >= 0 ? String(info.uid) : info.username;
+    return id.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || "default";
+  } catch {
+    return "default";
+  }
+};
+var decisionDir = () => join4(tmpdir3(), `pushary-codex-decisions-${userScope()}`);
+var decisionFile = (key) => join4(decisionDir(), key);
+var PRESENTATION_ONLY_INPUT_KEYS = ["description"];
+var identifyingToolInput = (toolInput) => {
+  if (!toolInput) return {};
+  const identifying = {};
+  for (const [key, value] of Object.entries(toolInput)) {
+    if (PRESENTATION_ONLY_INPUT_KEYS.includes(key)) continue;
+    identifying[key] = value;
+  }
+  return identifying;
+};
+var codexCallKey = (identity) => {
+  if (!identity.sessionId || !identity.turnId || !identity.toolName) return null;
+  const material = canonicalJson([
+    identity.sessionId,
+    identity.turnId,
+    identity.toolName,
+    identifyingToolInput(identity.toolInput)
+  ]);
+  return createHash3("sha256").update(material, "utf-8").digest("hex").slice(0, 32);
+};
+var parseDecision = (raw) => {
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed.kind === "approved") {
+      return typeof parsed.toolUseId === "string" && parsed.toolUseId ? { kind: "approved", toolUseId: parsed.toolUseId } : null;
+    }
+    if (parsed.kind === "handled") return { kind: "handled" };
+    if (parsed.kind === "denied") {
+      return { kind: "denied", reason: typeof parsed.reason === "string" ? parsed.reason : "" };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var sweepExpired = (dir, nowMs) => {
+  try {
+    for (const name of readdirSync(dir)) {
+      const path = join4(dir, name);
+      try {
+        if (nowMs - statSync3(path).mtimeMs >= CODEX_DECISION_TTL_MS) rmSync(path, { force: true });
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return;
+  }
+};
+var recordCodexCallDecision = (key, decision) => {
+  if (!key) return;
+  try {
+    const dir = decisionDir();
+    if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true, mode: 448 });
+    else sweepExpired(dir, Date.now());
+    writeFileSync3(decisionFile(key), JSON.stringify(decision), { encoding: "utf-8", mode: 384 });
+  } catch {
+    return;
+  }
+};
+var consumeCodexCallDecision = (key) => {
+  if (!key) return null;
+  const path = decisionFile(key);
+  try {
+    const fresh = Date.now() - statSync3(path).mtimeMs < CODEX_DECISION_TTL_MS;
+    const raw = readFileSync4(path, "utf-8");
+    rmSync(path, { force: true });
+    return fresh ? parseDecision(raw) : null;
+  } catch {
+    return null;
+  }
+};
+
+// src/driver.ts
+var DRIVER_ENV = "PUSHARY_DRIVER";
+var PHONE_DRIVER = "phone";
+var driverFromEnv = (env) => env[DRIVER_ENV] === PHONE_DRIVER ? PHONE_DRIVER : void 0;
+var phoneDrivenEnv = (base) => ({
+  ...base,
+  [DRIVER_ENV]: PHONE_DRIVER
+});
+
+// src/throttle.ts
+import { join as join5 } from "path";
+import { tmpdir as tmpdir4 } from "os";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, statSync as statSync4, writeFileSync as writeFileSync4, rmSync as rmSync2 } from "fs";
+var THROTTLE_DIR = join5(tmpdir4(), "pushary-throttle");
+var markerPath = (key) => join5(THROTTLE_DIR, createHash4("sha256").update(key).digest("hex").slice(0, 16));
+var claimThrottle = (key, windowMs) => {
+  try {
+    const path = markerPath(key);
+    if (existsSync4(path) && Date.now() - statSync4(path).mtimeMs < windowMs) return "throttled";
+    mkdirSync3(THROTTLE_DIR, { recursive: true });
+    writeFileSync4(path, "", "utf-8");
+    return "passed";
+  } catch {
+    return "unavailable";
+  }
+};
+var releaseThrottle = (key) => {
+  rmSync2(markerPath(key), { force: true });
+};
+
+// src/blocked-action-hint.ts
+import { createHash as createHash5 } from "crypto";
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync5, readdirSync as readdirSync2, rmSync as rmSync3, statSync as statSync5, utimesSync } from "fs";
+import { tmpdir as tmpdir5 } from "os";
+import { join as join6 } from "path";
+var BLOCKED_ACTION_HINT_TTL_MS = BLOCKED_ACTION_GRANT_TTL_SECONDS * 1e3;
+var FINGERPRINT = /^[0-9a-f]{64}$/;
+var isFingerprint = (value) => typeof value === "string" && FINGERPRINT.test(value);
+var blockedActionSubject = (source, sessionId, toolName, toolInput, cwd) => {
+  if (source !== "claude") return { source, sessionId, toolName, toolInput };
+  return cwd ? { source, sessionId, cwd, toolName, toolInput } : null;
+};
+var blockedActionFingerprint = ({ source = "claude", sessionId, toolName, toolInput, cwd }) => {
+  if (!sessionId || !toolInput) return null;
+  const canonical = canonicalGateInputs(source, toolName, [toolInput], cwd);
+  if (!canonical || canonical.toolInputs.length !== 1) return null;
+  const [canonicalInput] = canonical.toolInputs;
+  if (!canonicalInput) return null;
+  const subject = blockedActionSubject(source, sessionId, canonical.toolName, canonicalInput, cwd);
+  return subject ? createHash5("sha256").update(blockedActionIdentity(subject), "utf8").digest("hex") : null;
+};
+var hintDir = () => join6(tmpdir5(), `pushary-blocked-action-hints-${userScope()}`);
+var hintFile = (fingerprint) => join6(hintDir(), fingerprint);
+var isExpired = (mtimeMs, nowMs) => nowMs - mtimeMs >= BLOCKED_ACTION_HINT_TTL_MS;
+var sweepExpired2 = (dir, nowMs) => {
+  try {
+    for (const name of readdirSync2(dir)) {
+      const path = join6(dir, name);
+      try {
+        if (isExpired(statSync5(path).mtimeMs, nowMs)) rmSync3(path, { force: true });
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return;
+  }
+};
+var recordBlockedActionHint = (fingerprint, approved) => {
+  if (!isFingerprint(fingerprint)) return false;
+  try {
+    const dir = hintDir();
+    if (!existsSync5(dir)) mkdirSync4(dir, { recursive: true, mode: 448 });
+    else sweepExpired2(dir, Date.now());
+    writeFileAtomic(hintFile(fingerprint), JSON.stringify({ fingerprint, ...approved }), 384);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var readLiveHint = (fingerprint) => {
+  const path = hintFile(fingerprint);
+  try {
+    const stat = statSync5(path);
+    if (!stat.isFile()) return null;
+    if (isExpired(stat.mtimeMs, Date.now())) {
+      rmSync3(path, { force: true });
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync5(path, "utf-8"));
+    return parsed?.fingerprint === fingerprint ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+var hasBlockedActionHint = (fingerprint) => isFingerprint(fingerprint) && readLiveHint(fingerprint) !== null;
+var approvalIn = (fingerprint, sessionId) => {
+  const hint = readLiveHint(fingerprint);
+  if (hint?.sessionId !== sessionId || typeof hint.toolName !== "string") return null;
+  return { fingerprint, sessionId, toolName: hint.toolName, reminded: hint.reminded === true };
+};
+var approvalAwaitingRetry = (sessionId) => {
+  if (!sessionId) return null;
+  try {
+    for (const name of readdirSync2(hintDir())) {
+      const approval = isFingerprint(name) ? approvalIn(name, sessionId) : null;
+      if (approval) return approval;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+};
+var markApprovalReminded = (approval) => {
+  const path = hintFile(approval.fingerprint);
+  try {
+    const { atime, mtime } = statSync5(path);
+    const { fingerprint, sessionId, toolName } = approval;
+    writeFileAtomic(path, JSON.stringify({ fingerprint, sessionId, toolName, reminded: true }), 384);
+    utimesSync(path, atime, mtime);
+  } catch {
+    return;
+  }
+};
+var forgetBlockedActionHint = (fingerprint) => {
+  if (!isFingerprint(fingerprint)) return;
+  try {
+    rmSync3(hintFile(fingerprint), { force: true });
+  } catch {
+    return;
+  }
+};
+
+// src/background-work.ts
+import { createHash as createHash6 } from "crypto";
+import { mkdirSync as mkdirSync5, rmSync as rmSync4, statSync as statSync6, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir as tmpdir6 } from "os";
+import { join as join7 } from "path";
+var BACKGROUND_WORK_TTL_MS = 60 * 60 * 1e3;
+var backgroundWorkDir = () => join7(tmpdir6(), "pushary-background-work");
+var markerFor = (sessionKey) => join7(backgroundWorkDir(), createHash6("sha256").update(sessionKey).digest("hex"));
+var hasRunningBackgroundTasks = (backgroundTasks) => Array.isArray(backgroundTasks) && backgroundTasks.length > 0;
+var noteBackgroundWork = (sessionKey, running) => {
+  try {
+    if (!running) {
+      rmSync4(markerFor(sessionKey), { force: true });
+      return;
+    }
+    mkdirSync5(backgroundWorkDir(), { recursive: true, mode: 448 });
+    writeFileSync5(markerFor(sessionKey), "", { mode: 384 });
+  } catch {
+    return;
+  }
+};
+var isWaitingOnBackgroundWork = (sessionKey, nowMs = Date.now()) => {
+  try {
+    return nowMs - statSync6(markerFor(sessionKey)).mtimeMs < BACKGROUND_WORK_TTL_MS;
+  } catch {
+    return false;
+  }
+};
+
+// src/events.ts
+import { basename as basename3, join as join8 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync6, statSync as statSync7, writeFileSync as writeFileSync6 } from "fs";
+import { tmpdir as tmpdir7 } from "os";
+var INTENT_DIR = join8(tmpdir7(), "pushary-intent");
+var INTENT_MAX_BYTES = 2048;
+var INTENT_GRACE_MS = 10 * 60 * 1e3;
+var sanitizeSession = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
+var intentFile = (sessionId) => join8(INTENT_DIR, sanitizeSession(sessionId));
+var saveLastPrompt = (sessionId, prompt) => {
+  try {
+    const trimmed = prompt.replace(/\s+/g, " ").trim().slice(0, INTENT_MAX_BYTES);
+    if (!trimmed) return;
+    mkdirSync6(INTENT_DIR, { recursive: true });
+    writeFileSync6(intentFile(sessionId), trimmed, "utf-8");
+  } catch {
+  }
+};
+var readLastPrompt = (sessionId) => {
+  try {
+    const path = intentFile(sessionId);
+    if (isDefaultSession(sessionId) && statSync7(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
+    const value = readFileSync6(path, "utf-8").trim();
+    return value.length > 0 ? value : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var pendingQuestionsToSettle = (sessionId, toolUseId, insideSubagent = false) => {
+  const settledElsewhere = toolUseId ? listPendingQuestionsForToolUse(sessionId, toolUseId) : [];
+  if (insideSubagent) return settledElsewhere;
+  return [.../* @__PURE__ */ new Set([...settledElsewhere, ...listPendingQuestions(sessionId)])];
+};
+var reconcileQuestions = async (sessionId, files, signal) => {
+  const late = [];
+  try {
+    if (files.length === 0) return late;
+    const apiKey = getApiKey();
+    if (signal) signal = AbortSignal.any([signal, AbortSignal.timeout(2e3)]);
+    for (const correlationId of files) {
+      if (signal?.aborted) break;
+      try {
+        const answer = await waitForAnswer(apiKey, correlationId, 1e3, signal);
+        if (answer.answered) {
+          late.push({ correlationId, value: answer.value });
+          continue;
+        }
+        await cancelQuestion(apiKey, correlationId, signal);
+      } catch {
+        continue;
+      }
+      removePendingQuestion(sessionId, correlationId);
+    }
+  } catch {
+  }
+  return late;
+};
+var reconcilePendingQuestions = (sessionId, toolUseId, signal) => reconcileQuestions(sessionId, pendingQuestionsToSettle(sessionId, toolUseId), signal);
+var describeLateAnswer = (value) => {
+  const v = (value ?? "").trim();
+  if (v === "yes") return "approved it";
+  if (v === "no") return "rejected it";
+  if (v === "defer") return "chose to handle it on this machine";
+  return v ? `answered "${v.slice(0, 200)}"` : "responded";
+};
+var buildLateAnswerContext = (late) => {
+  if (late.length === 0) return void 0;
+  const parts = late.map((l) => `you ${describeLateAnswer(l.value)} on your phone`);
+  return `Pushary: a permission prompt you were sent was answered late \u2014 ${parts.join("; ")} \u2014 after the terminal already took over. Treat this as the user's latest intent; do not assume the earlier terminal decision matched it.`;
+};
+var notifyLateAnswers = async (apiKey, late, agentName, sessionId, signal) => {
+  if (late.length === 0) return;
+  const summary = late.map((l) => describeLateAnswer(l.value)).join(", ");
+  await sendNotification(apiKey, {
+    title: "Answer arrived late",
+    body: `You ${summary} after the agent had already moved on.`,
+    agentName,
+    sessionId
+  }, 2500, signal).catch(() => {
+  });
+};
+var CLAUDE_CODE_AGENT = { type: "claude_code", label: "Claude Code" };
+var POLICY_CACHE_TTL_MS = 5 * 60 * 1e3;
+var readFreshCachedPolicy = (apiKey, agentType, sessionId) => {
+  const request = policyRequestFor(agentType);
+  const path = policyCacheFile(apiKey, request.agent, request.repoAware);
+  if (!existsSync6(path)) return null;
+  const cached = JSON.parse(readFileSync6(path, "utf-8"));
+  if (!isPolicyConfig(cached)) return null;
+  if ((cached._sessionId ?? null) !== (sessionId ?? null)) return null;
+  if (!cached._cachedAt || Date.now() - cached._cachedAt >= POLICY_CACHE_TTL_MS) return null;
+  return cached;
+};
+var autoDecisionEnabled = () => {
+  const flag = process.env.PUSHARY_AUTO_DECISION_BEACON;
+  return flag === "1" || flag === "true";
+};
+var deriveDecisionSource = (toolName, toolInput, liveMode, agentType, cwd, sessionId) => {
+  try {
+    if (liveMode.kill) return "terminal";
+    if (!autoDecisionEnabled()) return void 0;
+    const policy = readFreshCachedPolicy(getApiKey(), agentType, sessionId);
+    if (!policy) return void 0;
+    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput, cwd, repoKeyFor(cwd), sessionId);
+    if (isAutoApprove(resolved)) return "policy_auto";
+    if (resolved.mode === "push_only" || resolved.mode === "push_first") return "human";
+    return "terminal";
+  } catch {
+    return void 0;
+  }
+};
+var deriveAutoDecisionBeacon = (toolName, toolInput, liveMode, agentType, cwd, sessionId) => {
+  try {
+    if (liveMode.kill) return void 0;
+    if (!autoDecisionEnabled()) return void 0;
+    const policy = readFreshCachedPolicy(getApiKey(), agentType, sessionId);
+    if (!policy) return void 0;
+    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput, cwd, repoKeyFor(cwd), sessionId);
+    if (resolved.timeoutSeconds !== 0 || resolved.timeoutAction !== "approve") return void 0;
+    return {
+      decisionOrigin: resolveAutoResolveOrigin(policy, toolName, toolInput, cwd, repoKeyFor(cwd), sessionId),
+      toolName,
+      toolTarget: deriveToolTarget(toolName, toolInput)
+    };
+  } catch {
+    return void 0;
+  }
+};
+var AUTO_DECISION_WINDOW_MS = 15 * 60 * 1e3;
+var HOOK_ACTIVE_WINDOW_MS = 30 * 60 * 1e3;
+var deriveUsage = (transcriptPath, sessionId) => {
+  if (!transcriptPath || process.env.PUSHARY_COST_TRACKING === "off") return void 0;
+  try {
+    return readNewUsage(transcriptPath, sessionId || DEFAULT_SESSION) ?? void 0;
+  } catch {
+    return void 0;
+  }
+};
+var mergeAdditionalContext = (existing, reported) => {
+  const pendingCommand = reported.status === "fulfilled" ? reported.value?.pendingCommand : void 0;
+  if (typeof pendingCommand !== "string" || pendingCommand.trim().length === 0) return existing;
+  const injected = `${PENDING_COMMAND_PREFIX} ${pendingCommand.trim()}`;
+  return existing ? `${existing}
+
+${injected}` : injected;
+};
+var consumesActivityContext = (agentType) => {
+  const source = HOOK_SOURCES.find((candidate) => AGENT_IDENTITIES[candidate].type === agentType);
+  if (!source) return false;
+  return pendingCommandEvents(source).some((event) => event !== "Stop");
+};
+var detectInstallMode = () => (process.argv[1] ?? "").includes("_npx") ? "npx" : "cli";
+var acknowledgePendingCommand = async (apiKey, baseUrl, commandId, sessionId, machineId, timeoutMs, state = "delivered", signal) => {
+  try {
+    signal?.throwIfAborted();
+    if (timeoutMs <= 0) return false;
+    const response = await fetch(`${baseUrl}/api/agent/command/ack`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        commandId,
+        sessionId: sessionId ?? null,
+        machineId,
+        state,
+        ...state === "failed" ? { failureCode: "consumer_rejected" } : {}
+      }),
+      signal: AbortSignal.any([AbortSignal.timeout(timeoutMs), ...signal ? [signal] : []])
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+};
+var ACK_RESERVE_MS = 1500;
+var reportEvent = async (event, options = {}) => {
+  const apiKey = options.apiKey ?? getApiKey();
+  const baseUrl = getBaseUrl();
+  const machineId = event.machineId ?? getMachineId();
+  const sessionKey = event.sessionId || DEFAULT_SESSION;
+  const receiptNamespace = `${apiKey}:${machineId}:${event.agentType}`;
+  const clientCanDrain = consumesActivityContext(event.agentType) && options.timeoutMs === void 0 && options.skipDrain !== true;
+  const deadlineMs = options.budgetMs === void 0 ? void 0 : Date.now() + options.budgetMs;
+  const ackReserveMs = deadlineMs === void 0 ? 0 : Math.min(ACK_RESERVE_MS, Math.floor((options.budgetMs ?? 0) * 0.4));
+  const postTimeoutMs = (fallback) => deadlineMs === void 0 ? fallback : Math.max(0, Math.min(fallback, deadlineMs - ackReserveMs - Date.now()));
+  const ackTimeoutMs = (fallback) => deadlineMs === void 0 ? fallback : Math.max(0, Math.min(fallback, deadlineMs - Date.now()));
+  return withRetry(async () => {
+    options.signal?.throwIfAborted();
+    const timeoutMs = postTimeoutMs(options.timeoutMs ?? 1e4);
+    if (timeoutMs <= 0) return null;
+    const storedCommand = clientCanDrain ? readPendingCommand(sessionKey, receiptNamespace) : null;
+    const res = await fetch(`${baseUrl}/api/agent/event`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        ...event,
+        machineId,
+        // Lets the phone's Stop end this process instead of only denying its next
+        // tool call. Ours alone: never another process, never a parent.
+        pid: event.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 } : {},
+        ...driverFromEnv(process.env) ? { driver: driverFromEnv(process.env) } : {},
+        canDrainCommand: clientCanDrain && !storedCommand,
+        ackMode: clientCanDrain && !storedCommand,
+        skipCommandDrain: options.skipDrain === true || storedCommand != null
+      }),
+      signal: AbortSignal.any([AbortSignal.timeout(timeoutMs), ...options.signal ? [options.signal] : []])
+    });
+    if ((options.requireOk || event.usage !== void 0) && !res.ok) throw new Error(`/api/agent/event rejected (${res.status})`);
+    try {
+      const result = await res.json();
+      const withoutPending = () => ({ ...result, pendingCommand: void 0, pendingCommandId: void 0 });
+      if (storedCommand) {
+        const failed = storedCommand.failed === true;
+        const acknowledged = await acknowledgePendingCommand(
+          apiKey,
+          baseUrl,
+          storedCommand.id,
+          event.sessionId,
+          machineId,
+          ackTimeoutMs(options.timeoutMs ?? 1e4),
+          failed ? "failed" : "delivered",
+          options.signal
+        );
+        if (!acknowledged) return withoutPending();
+        if (storedCommand.delivered || failed) {
+          removePendingCommand(sessionKey, storedCommand.id, receiptNamespace);
+          return withoutPending();
+        }
+        if (!markPendingCommandDelivered(sessionKey, storedCommand.id, receiptNamespace)) return withoutPending();
+        return { ...withoutPending(), pendingCommand: storedCommand.text, pendingCommandId: storedCommand.id };
+      }
+      if (typeof result.pendingCommandId === "string" && typeof result.pendingCommand === "string") {
+        const saved = savePendingCommand(sessionKey, {
+          id: result.pendingCommandId,
+          text: result.pendingCommand,
+          expiresAtMs: typeof result.pendingCommandExpiresAtMs === "number" ? result.pendingCommandExpiresAtMs : Date.now() + 36e5,
+          delivered: false
+        }, receiptNamespace);
+        if (!saved) return withoutPending();
+        const acknowledged = await acknowledgePendingCommand(
+          apiKey,
+          baseUrl,
+          result.pendingCommandId,
+          event.sessionId,
+          machineId,
+          ackTimeoutMs(options.timeoutMs ?? 1e4),
+          "delivered",
+          options.signal
+        );
+        if (!acknowledged || !markPendingCommandDelivered(sessionKey, result.pendingCommandId, receiptNamespace)) {
+          return withoutPending();
+        }
+      }
+      return result;
+    } catch {
+      return null;
+    }
+  }, { maxAttempts: options.maxAttempts ?? 2, baseDelayMs: 300 });
+};
+var NON_GATED_MIRROR_TOOLS = new Set(POSTTOOLUSE_MIRROR_ONLY_TOOLS);
+var HOOK_BUDGET_MS = 9e3;
+var DRAINING_REPORT_BUDGET_MS = 8e3;
+var settleQuestionsForToolUse = async (sessionId, toolUseId) => {
+  if (!toolUseId) return;
+  const late = await reconcileQuestions(sessionId, listPendingQuestionsForToolUse(sessionId, toolUseId));
+  for (const answer of late) removePendingQuestion(sessionId, answer.correlationId);
+};
+var ranInsideSubagent = (input) => sessionIdentityOf(input).parentSessionId !== void 0;
+var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const occurredAt = (/* @__PURE__ */ new Date()).toISOString();
+  const deadline = Date.now() + HOOK_BUDGET_MS;
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    const action = describeToolCall(input.tool_name, input.tool_input, "event");
+    const lookup = toPolicyLookup(input.tool_name, input.tool_input);
+    const toolResult = input.tool_response ?? input.tool_result;
+    const isError = isToolResultError(toolResult);
+    const receiptsEnabled = process.env.PUSHARY_RECEIPTS !== "off";
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    const insideSubagent = ranInsideSubagent(input);
+    const questionsToSettle = pendingQuestionsToSettle(sessionKey, input.tool_use_id, insideSubagent);
+    const [liveMode, late] = await Promise.all([
+      fetchModeState(getApiKey(), input.session_id, MODE_REUSE_MS, signal),
+      reconcileQuestions(sessionKey, questionsToSettle, signal)
+    ]);
+    let additionalContext;
+    if (late.length > 0 && agent.type === CLAUDE_CODE_AGENT.type) {
+      additionalContext = buildLateAnswerContext(late);
+      for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
+    }
+    const isMirrorOnly = NON_GATED_MIRROR_TOOLS.has(input.tool_name);
+    const decisionSource = isMirrorOnly ? void 0 : deriveDecisionSource(lookup.tool, lookup.input, liveMode, agent.type, input.cwd, input.session_id);
+    const beacon = !isMirrorOnly && decisionSource === "policy_auto" && claimThrottle(`autodecision:${sessionKey}:${lookup.tool}`, AUTO_DECISION_WINDOW_MS) === "passed" ? deriveAutoDecisionBeacon(lookup.tool, lookup.input, liveMode, agent.type, input.cwd, input.session_id) : void 0;
+    const toolReport = reportEvent({
+      event: isError ? "tool_error" : "tool_complete",
+      occurredAt,
+      toolUseId: input.tool_use_id,
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action,
+      sessionId: input.session_id,
+      error: isError ? toolResultErrorText(toolResult).slice(0, 500) : void 0,
+      decisionSource,
+      ...beacon ? { decisionOrigin: beacon.decisionOrigin, toolName: beacon.toolName, toolTarget: beacon.toolTarget } : {},
+      meta: receiptsEnabled ? deriveReceiptMeta(lookup.tool, lookup.input, toolResult, input.cwd ?? process.cwd()) : void 0,
+      usage: deriveUsage(input.transcript_path, input.session_id)
+    }, {
+      maxAttempts: 1,
+      budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())),
+      signal,
+      skipDrain: insideSubagent
+    });
+    const extraReports = [];
+    if (claimThrottle(`hookactive:${sessionKey}`, HOOK_ACTIVE_WINDOW_MS) === "passed") {
+      extraReports.push(
+        reportEvent(
+          {
+            event: "agent_hook_active",
+            agentType: agent.type,
+            agentName: `${agent.label} - ${projectName}`,
+            sessionId: input.session_id
+          },
+          { maxAttempts: 1, timeoutMs: 800, signal }
+        )
+      );
+    }
+    const [reported] = await Promise.allSettled([toolReport, ...extraReports]);
+    if (consumesActivityContext(agent.type)) {
+      additionalContext = mergeAdditionalContext(additionalContext, reported);
+    }
+    return additionalContext;
+  } catch {
+    return void 0;
+  }
+};
+var handleUserPrompt = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const deadline = Date.now() + HOOK_BUDGET_MS;
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    const titlesEnabled = process.env.PUSHARY_TASK_TITLES !== "off";
+    const taskTitle = titlesEnabled ? taskTitleFrom(input.prompt) : void 0;
+    if (input.prompt) saveLastPrompt(sessionKey, input.prompt);
+    const late = await reconcilePendingQuestions(sessionKey, void 0, signal);
+    let additionalContext;
+    if (late.length > 0 && agent.type === CLAUDE_CODE_AGENT.type) {
+      additionalContext = buildLateAnswerContext(late);
+      for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
+    }
+    const [reported] = await Promise.allSettled([
+      reportEvent({
+        event: "user_prompt",
+        agentType: agent.type,
+        agentName: `${agent.label} - ${projectName}`,
+        sessionId: input.session_id,
+        taskTitle
+      }, { maxAttempts: 1, budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())), signal })
+    ]);
+    if (consumesActivityContext(agent.type)) {
+      additionalContext = mergeAdditionalContext(additionalContext, reported);
+    }
+    return additionalContext;
+  } catch {
+    return void 0;
+  }
+};
+var UNUSED_APPROVAL_INSTRUCTION = "The person allowed, from Pushary, the call auto mode blocked. Send that call again now, exactly as it was with nothing changed, to use their approval. It covers only that exact call.";
+var phoneInstructionOf = (pendingCommand) => typeof pendingCommand === "string" && pendingCommand.trim().length > 0 ? `The user sent a new instruction from their phone via Pushary: ${pendingCommand.trim()}` : null;
+var handleStop = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const deadline = Date.now() + HOOK_BUDGET_MS;
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    noteBackgroundWork(sessionKey, hasRunningBackgroundTasks(input.background_tasks));
+    const late = await reconcilePendingQuestions(sessionKey, void 0, signal);
+    const tasks = [
+      reportEvent({
+        event: "session_end",
+        agentType: agent.type,
+        agentName: `${agent.label} - ${projectName}`,
+        action: summarizeStop(input),
+        ...sessionIdentityOf(input),
+        usage: deriveUsage(input.transcript_path, input.session_id)
+      }, { maxAttempts: 1, budgetMs: Math.min(DRAINING_REPORT_BUDGET_MS, Math.max(0, deadline - Date.now())), signal })
+    ];
+    if (late.length > 0) {
+      tasks.push(notifyLateAnswers(getApiKey(), late, `${agent.label} - ${projectName}`, input.session_id, signal));
+      for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
+    }
+    if (!isDefaultSession(sessionKey) && listPendingQuestions(sessionKey).length === 0) removePendingSession(sessionKey);
+    const [reported] = await Promise.allSettled(tasks);
+    const pendingCommand = reported.status === "fulfilled" ? reported.value?.pendingCommand : void 0;
+    const unusedApproval = !input.stop_hook_active && approvalAwaitingRetry(input.session_id) !== null;
+    const instructions = [unusedApproval ? UNUSED_APPROVAL_INSTRUCTION : null, phoneInstructionOf(pendingCommand)].filter((instruction) => instruction !== null);
+    return instructions.length > 0 ? { decision: "block", reason: instructions.join("\n\n") } : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isSubagentStop = (input) => input.hook_event_name === "SubagentStop" || typeof input.agent_id === "string" && input.agent_id.length > 0;
+var SUBAGENT_STOP_REPORT_TIMEOUT_MS = 4e3;
+var handleSubagentStop = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    await reportEvent({
+      event: "session_end",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action: subagentStopSummary(input),
+      ...sessionIdentityOf(input)
+      // A subagent's end is a `session_end` like any other as far as the route is
+      // concerned, and this caller discards the response, so without this the
+      // parent's queued instruction is popped and thrown away.
+    }, { maxAttempts: 1, timeoutMs: SUBAGENT_STOP_REPORT_TIMEOUT_MS, skipDrain: true });
+  } catch {
+  }
+};
+var isCompactionEvent = (hookEventName) => hookEventName === "PreCompact" || hookEventName === "PostCompact";
+var COMPACTION_REPORT_TIMEOUT_MS = 4e3;
+var handleCompaction = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    await reportEvent({
+      event: "compaction",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action: compactionAction(input.hook_event_name, input.trigger),
+      ...sessionIdentityOf(input)
+    }, { maxAttempts: 1, timeoutMs: COMPACTION_REPORT_TIMEOUT_MS });
+  } catch {
+  }
+};
+var handleSessionStart = async (input, agent = CLAUDE_CODE_AGENT) => {
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    const action = input.agent_id ? "Subagent started" : sessionStartAction(input.source);
+    await reportEvent({
+      event: "session_start",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action,
+      ...sessionIdentityOf(input)
+    }, { maxAttempts: 2, timeoutMs: 4e3 });
+  } catch {
+  }
+};
+var handleSessionEnd = async (input, agent = CLAUDE_CODE_AGENT, options = {}) => {
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    const action = sessionEndAction(input.reason);
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    if (options.reconcile ?? true) {
+      const late = await reconcilePendingQuestions(sessionKey);
+      if (late.length > 0) {
+        await notifyLateAnswers(getApiKey(), late, `${agent.label} - ${projectName}`, input.session_id).catch(() => {
+        });
+        for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
+      }
+    }
+    if (!isDefaultSession(sessionKey)) removePendingSession(sessionKey);
+    if (options.reportClosed === false) return;
+    await reportEvent({
+      event: "session_closed",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action,
+      sessionId: input.session_id
+    }, { maxAttempts: options.reportAttempts ?? 2, timeoutMs: options.reportTimeoutMs ?? 3e3 });
+  } catch {
+  }
+};
+var NOTIFICATION_THROTTLE_MS = 60 * 1e3;
+var pushesNotification = (notifType, sessionKey) => NOTIFICATION_PUSH_TYPES.has(notifType) && !(notifType === IDLE_PROMPT_NOTIFICATION && isWaitingOnBackgroundWork(sessionKey));
+var handleNotification = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
+  try {
+    const projectName = basename3(input.cwd ?? process.cwd());
+    const notifType = notificationTypeOf(input) ?? "";
+    const sessionKey = input.session_id || DEFAULT_SESSION;
+    const teammateIdle = input.hook_event_name === "TeammateIdle";
+    const action = teammateIdle ? TEAMMATE_IDLE_ACTION : notificationAction(input);
+    const failed = !teammateIdle && notifType === "error";
+    await reportEvent({
+      event: teammateIdle ? "teammate_idle" : failed ? "error" : "notification",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action,
+      sessionId: input.session_id,
+      error: failed ? action : void 0
+      // `timeoutMs` is not decoration. It is this file's way of saying "side
+      // report", and it sets `clientCanDrain` false. Without it this call
+      // advertises itself as able to consume a phone-queued instruction, and the
+      // stored-command replay inside `reportEvent` hands one back, acknowledges it
+      // as delivered and marks the local receipt delivered, to a caller that
+      // discards the return value. The notification hook prints nothing, so the
+      // instruction is destroyed rather than delayed. Hoisting this report out of
+      // the else-branch put every notification type on that path, not just the
+      // quiet ones.
+      //
+      // 2.5s rather than the 4s a side report usually gets: on the push branch
+      // this is followed by a ~3s `fetchModeState` and a 4s `sendNotification`,
+      // and all three have to fit inside Claude Code's 10s Notification budget.
+    }, { maxAttempts: 1, timeoutMs: 2500, signal }).catch(() => {
+    });
+    if (!teammateIdle && pushesNotification(notifType, sessionKey)) {
+      if (claimThrottle(`notify:${sessionKey}:${notifType}`, NOTIFICATION_THROTTLE_MS) !== "passed") return;
+      let apiKey;
+      try {
+        apiKey = getApiKey();
+      } catch {
+        return;
+      }
+      const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS, signal).catch(() => null);
+      if (mode?.kill || mode?.mode === "terminal_only") return;
+      await sendNotification(apiKey, {
+        title: `${agent.label} is waiting`,
+        body: input.message ? action.slice(0, 200) : "Your agent is waiting for you.",
+        agentName: `${agent.label} - ${projectName}`,
+        sessionId: input.session_id,
+        // Makes this an `update` server-side, so resolveSiteMode gates it on
+        // the wildcard policy too. `info` because nothing finished.
+        context: { type: "info" }
+      }, 4e3, signal).catch(() => {
+      });
+    }
+  } catch {
+  }
+};
+var handleStopFailure = async (input, agent = CLAUDE_CODE_AGENT) => {
+  const signal = AbortSignal.timeout(HOOK_BUDGET_MS);
+  try {
+    let apiKey;
+    try {
+      apiKey = getApiKey();
+    } catch {
+      return;
+    }
+    const projectName = basename3(input.cwd ?? process.cwd());
+    const reason = describeStopFailure(input.error);
+    await reportEvent({
+      event: "turn_error",
+      agentType: agent.type,
+      agentName: `${agent.label} - ${projectName}`,
+      action: reason,
+      error: reason,
+      sessionId: input.session_id
+      // Same reason as the Notification report above, and the same budget shape:
+      // this is followed by a ~3s fetchModeState and a 4s sendNotification inside
+      // Claude Code's 10s StopFailure budget. The stopfailure hook prints nothing,
+      // so without this the phone's queued instruction is taken and destroyed.
+    }, { maxAttempts: 1, timeoutMs: 2500, signal }).catch(() => {
+    });
+    const mode = await fetchModeState(apiKey, input.session_id, MODE_REUSE_MS, signal).catch(() => null);
+    if (mode?.kill || mode?.mode === "terminal_only") return;
+    await sendNotification(apiKey, {
+      title: `${agent.label} stopped on an error`,
+      body: reason,
+      agentName: `${agent.label} - ${projectName}`,
+      sessionId: input.session_id,
+      context: { type: "error", errorMessage: reason }
+    }, 4e3, signal).catch(() => {
+    });
+  } catch {
+  }
+};
+
+export {
+  policyRequestFor,
+  getPolicy,
+  fetchModeState,
+  fetchModeOverride,
+  phoneDrivenEnv,
+  HOOK_FALLBACK_MAX,
+  UNNAMED_ACTION,
+  describeToolCall,
+  deriveToolTarget,
+  parseApplyPatchFiles,
+  OPENCODE_TOOL_NAMES,
+  canonicalGateInputs,
+  scopePathFor,
+  deriveActionBody,
+  deriveAction,
+  deriveBlocker,
+  permissionDeniedAction,
+  sessionIdentityOf,
+  readCodexTurnContext,
+  isCodexGuardianRolloutHead,
+  scanCodexGuardianReviews,
+  codexReviewerDenialsSince,
+  repoKeyFor,
+  claimThrottle,
+  releaseThrottle,
+  readLastUserPrompt,
+  CODEX_AGENT,
+  codexAllow,
+  codexDeny,
+  codexPass,
+  toCodexWire,
+  describeApplyPatch,
+  toPolicyLookup,
+  toPolicyLookups,
+  permissionTimeoutDecision,
+  preToolUseTimeoutDecision,
+  userScope,
+  codexCallKey,
+  recordCodexCallDecision,
+  consumeCodexCallDecision,
+  blockedActionFingerprint,
+  recordBlockedActionHint,
+  hasBlockedActionHint,
+  approvalAwaitingRetry,
+  markApprovalReminded,
+  forgetBlockedActionHint,
+  readLastPrompt,
+  CLAUDE_CODE_AGENT,
+  AUTO_DECISION_WINDOW_MS,
+  reportEvent,
+  settleQuestionsForToolUse,
+  handlePostToolUse,
+  handleUserPrompt,
+  handleStop,
+  isSubagentStop,
+  handleSubagentStop,
+  isCompactionEvent,
+  handleCompaction,
+  handleSessionStart,
+  handleSessionEnd,
+  handleNotification,
+  handleStopFailure
+};