@pushary/agent-hooks 0.28.0 → 0.28.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pushary
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# @pushary/agent-hooks
+
+[![npm version](https://img.shields.io/npm/v/@pushary/agent-hooks.svg)](https://www.npmjs.com/package/@pushary/agent-hooks)
+[![npm downloads](https://img.shields.io/npm/dm/@pushary/agent-hooks.svg)](https://www.npmjs.com/package/@pushary/agent-hooks)
+[![license](https://img.shields.io/npm/l/@pushary/agent-hooks.svg)](./LICENSE)
+
+Push notifications, questions, and permission approvals for AI coding agents. Get a push when your agent finishes work, answer its questions from your phone, and approve risky commands before they run. Works with Claude Code, Codex, Cursor, Gemini CLI, and Hermes.
+
+Your agent froze waiting for a yes. This is how it reaches you.
+
+```bash
+npx @pushary/agent-hooks@latest setup
+```
+
+One command wires up the MCP server, the permission hooks, and the agent instruction files. Then you close your laptop and the agent still reaches you.
+
+## What it does
+
+There are three things.
+
+**Notify.** The agent sends a push when a long task finishes or when a build, test, or deploy fails. The notification can carry what changed, the error, and suggested next steps.
+
+**Ask.** The agent asks you questions through push: yes/no, multiple choice, or free text. It waits for your answer. When Pushary is connected, the agent sends its questions to your phone instead of stalling in the terminal.
+
+**Gate.** Risky shell commands (`rm -rf`, force pushes, history rewrites, database drops, deploys) are checked before they run. What happens is set by your dashboard policy: auto approve trusted read-only commands, push to your phone for approval, or hold for the phone and never auto-deny. If the check cannot run, the command is blocked instead of allowed. It fails closed.
+
+## Setup
+
+You need an API key. Sign up at [pushary.com](https://pushary.com/sign-up?from=npm), then run:
+
+```bash
+npx @pushary/agent-hooks@latest setup
+```
+
+The wizard detects which agents you have installed and configures each one. To skip the prompts:
+
+```bash
+npx @pushary/agent-hooks@latest setup --key pk_xxx.sk_xxx --skip-phone
+```
+
+Verify it worked:
+
+```bash
+npx @pushary/agent-hooks@latest doctor
+```
+
+## Supported agents
+
+| Agent | Notify | Ask | Gate |
+|-------|:------:|:---:|:----:|
+| Claude Code | yes | yes | yes |
+| Codex | yes | yes | yes |
+| Cursor | yes | yes | yes |
+| Gemini CLI | yes | yes | yes |
+| Hermes | yes | yes | yes |
+
+Any other MCP client can use notify and ask by pointing at the Pushary MCP endpoint directly.
+
+## Commands
+
+```
+setup    Configure Claude Code, Codex, Gemini CLI, Hermes, or Cursor with Pushary
+doctor   Verify your Pushary installation is working
+clean    Remove all Pushary configuration
+mode     Switch approval mode (push_only, push_first, terminal_only)
+wait     Show or set the "wait for your phone" ladder (pushary wait 45)
+hook     Run as a PreToolUse hook (reads stdin, writes stdout)
+```
+
+Examples:
+
+```bash
+npx @pushary/agent-hooks@latest mode push_only --for 30m
+npx @pushary/agent-hooks@latest wait 45
+npx @pushary/agent-hooks@latest clean
+```
+
+## Manual MCP setup
+
+If you only want notifications and questions (no permission gating), add Pushary to your MCP config directly:
+
+```json
+{
+  "mcpServers": {
+    "pushary": {
+      "type": "http",
+      "url": "https://pushary.com/api/mcp/mcp",
+      "headers": {
+        "Authorization": "Bearer YOUR_API_KEY"
+      }
+    }
+  }
+}
+```
+
+The MCP server exposes `send_notification`, `ask_user`, `wait_for_answer`, and `cancel_question`. Full tool reference is in the [docs](https://pushary.com/docs?from=npm).
+
+## Security
+
+The permission gate fails closed. If a policy cannot be fetched or a hook errors, the command is blocked, not allowed. Secrets in command arguments and environment are redacted before anything is sent to a phone or stored. Read-only commands can be allowlisted so trusted work never interrupts you, while writes and destructive commands still route through approval.
+
+## Links
+
+- Website: [pushary.com](https://pushary.com/?from=npm)
+- Docs: [pushary.com/docs](https://pushary.com/docs?from=npm)
+- Sign up: [pushary.com/sign-up](https://pushary.com/sign-up?from=npm)
+- Issues: [github.com/pushary/pushary/issues](https://github.com/pushary/pushary/issues)
+
+## License
+
+MIT

package/dist/bin/pushary-clean.js

@@ -2,14 +2,14 @@
 import {
   removeClaudeMcpServers,
   removePusharySettings
-} from "../chunk-76F75WQQ.js";
+} from "../chunk-QNEYHDKR.js";
 import {
   execNpm,
   removeCodexHooks,
   removeGeminiSettings,
   removeInstructionBlock
-} from "../chunk-QDPUTE2V.js";
-import "../chunk-YRL4ZB4R.js";
+} from "../chunk-X3YCHQQK.js";
+import "../chunk-Z5PL3K7C.js";
 
 // bin/pushary-clean.ts
 import { existsSync, readFileSync, writeFileSync, rmSync } from "fs";

package/dist/bin/pushary-codex-hook.js

@@ -32,14 +32,14 @@ import {
   toCodexWire,
   toPolicyLookup,
   waitForAnswer
-} from "../chunk-NFKYZY74.js";
+} from "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
 import {
   DECISION_LINE_MAX,
   effectiveWaitSeconds,
   hookWaitClamped,
   hookWaitDeadline
-} from "../chunk-YRL4ZB4R.js";
+} from "../chunk-Z5PL3K7C.js";
 import {
   getApiKey
 } from "../chunk-NKXSILEW.js";

package/dist/bin/pushary-codex.js

@@ -4,9 +4,9 @@ import {
   getMachineId,
   reportEvent,
   waitForAnswer
-} from "../chunk-NFKYZY74.js";
+} from "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
-import "../chunk-YRL4ZB4R.js";
+import "../chunk-Z5PL3K7C.js";
 import {
   getApiKey
 } from "../chunk-NKXSILEW.js";

package/dist/bin/pushary-doctor.js

@@ -12,12 +12,12 @@ import {
   missingGeminiHookEvents,
   readCodexMcpAuth,
   untrustedCodexHookEvents
-} from "../chunk-QDPUTE2V.js";
+} from "../chunk-X3YCHQQK.js";
 import {
   callMcpTool,
   sendMcpRequest
 } from "../chunk-DWED7BS3.js";
-import "../chunk-YRL4ZB4R.js";
+import "../chunk-Z5PL3K7C.js";
 import {
   getBaseUrl
 } from "../chunk-NKXSILEW.js";

package/dist/bin/pushary-gemini-hook.js

@@ -24,14 +24,14 @@ import {
   savePendingQuestion,
   sendNotification,
   waitForAnswer
-} from "../chunk-NFKYZY74.js";
+} from "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
 import {
   DECISION_LINE_MAX,
   effectiveWaitSeconds,
   hookWaitClamped,
   hookWaitDeadline
-} from "../chunk-YRL4ZB4R.js";
+} from "../chunk-Z5PL3K7C.js";
 import {
   getApiKey
 } from "../chunk-NKXSILEW.js";

package/dist/bin/pushary-hook.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import {
   handlePreToolUse
-} from "../chunk-2BHYQCF7.js";
+} from "../chunk-P6QBZS27.js";
 import "../chunk-KQYIHZ5E.js";
-import "../chunk-NFKYZY74.js";
+import "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
-import "../chunk-YRL4ZB4R.js";
+import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";
 
 // bin/pushary-hook.ts

package/dist/bin/pushary-post-hook.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   handlePostToolUse
-} from "../chunk-NFKYZY74.js";
+} from "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
-import "../chunk-YRL4ZB4R.js";
+import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";
 
 // bin/pushary-post-hook.ts

package/dist/bin/pushary-prompt-hook.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   handleUserPrompt
-} from "../chunk-NFKYZY74.js";
+} from "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
-import "../chunk-YRL4ZB4R.js";
+import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";
 
 // bin/pushary-prompt-hook.ts

package/dist/bin/pushary-setup.js

@@ -3,7 +3,7 @@ import {
   addClaudeMcpServer,
   addPusharyHooks,
   addPusharyToolPermissions
-} from "../chunk-76F75WQQ.js";
+} from "../chunk-QNEYHDKR.js";
 import {
   GEMINI_HOOK_BINARY,
   addCodexHookTrust,
@@ -16,14 +16,14 @@ import {
   renderAgentInstructions,
   renderProjectAgentInstructions,
   writeInstructionBlock
-} from "../chunk-QDPUTE2V.js";
+} from "../chunk-X3YCHQQK.js";
 import {
   reportEvent
-} from "../chunk-NFKYZY74.js";
+} from "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
 import {
   isValidApiKey
-} from "../chunk-YRL4ZB4R.js";
+} from "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";
 
 // bin/pushary-setup.ts

package/dist/bin/pushary-stop-hook.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 import {
   handleStop
-} from "../chunk-NFKYZY74.js";
+} from "../chunk-IAOXM7X5.js";
 import "../chunk-DWED7BS3.js";
-import "../chunk-YRL4ZB4R.js";
+import "../chunk-Z5PL3K7C.js";
 import "../chunk-NKXSILEW.js";
 
 // bin/pushary-stop-hook.ts

package/dist/chunk-22CV7V7A.js

@@ -0,0 +1,38 @@
+// ../contracts/src/index.ts
+var APPROVAL_MODES = ["push_only", "terminal_only", "push_first", "notify_only"];
+var isApprovalMode = (value) => typeof value === "string" && APPROVAL_MODES.includes(value);
+var MATCH_RANKS = ["none", "tool", "prefix", "exact"];
+var matchRankWeight = (rank) => MATCH_RANKS.indexOf(rank);
+var matchToolPattern = (pattern, toolName, arg) => {
+  const open = pattern.indexOf("(");
+  if (open === -1 || !pattern.endsWith(")")) {
+    return pattern === toolName ? "tool" : "none";
+  }
+  if (pattern.slice(0, open) !== toolName || arg === void 0) return "none";
+  const inner = pattern.slice(open + 1, -1);
+  if (inner.endsWith(":*")) {
+    return arg.startsWith(inner.slice(0, -2)) ? "prefix" : "none";
+  }
+  return arg === inner ? "exact" : "none";
+};
+var POLICY_ARG_KEYS = {
+  Bash: "command",
+  Edit: "file_path",
+  Write: "file_path"
+};
+var extractPolicyArg = (toolName, toolInput) => {
+  const key = POLICY_ARG_KEYS[toolName];
+  if (!key) return void 0;
+  const value = toolInput[key];
+  return typeof value === "string" ? value : void 0;
+};
+var API_KEY_PATTERN = /^pk_[a-f0-9]+\.[a-f0-9]+$/;
+var isValidApiKey = (value) => API_KEY_PATTERN.test(value);
+
+export {
+  isApprovalMode,
+  matchRankWeight,
+  matchToolPattern,
+  extractPolicyArg,
+  isValidApiKey
+};

package/dist/chunk-2BE2IPMO.js

@@ -0,0 +1,315 @@
+import {
+  extractPolicyArg,
+  isApprovalMode,
+  matchRankWeight,
+  matchToolPattern
+} from "./chunk-RZLVE57X.js";
+import {
+  callMcpTool,
+  withRetry
+} from "./chunk-DWED7BS3.js";
+import {
+  getBaseUrl
+} from "./chunk-NKXSILEW.js";
+
+// src/validate.ts
+var isPolicyConfig = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return Array.isArray(d.policies) && typeof d.defaultTimeoutSeconds === "number" && typeof d.defaultTimeoutAction === "string";
+};
+var isAskUserResponse = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return typeof d.correlationId === "string" && typeof d.status === "string";
+};
+var isWaitForAnswerResponse = (data) => {
+  if (!data || typeof data !== "object") return false;
+  const d = data;
+  return typeof d.answered === "boolean";
+};
+
+// src/api.ts
+var askUser = async (apiKey, params) => {
+  const result = await callMcpTool(apiKey, "ask_user", { ...params, wait: false }, { maxRetries: 3 });
+  if (!isAskUserResponse(result)) throw new Error("Invalid ask_user response");
+  return result;
+};
+var waitForAnswer = async (apiKey, correlationId, timeoutMs = 3e4) => {
+  const result = await callMcpTool(apiKey, "wait_for_answer", {
+    correlationId,
+    timeoutMs
+  });
+  if (!isWaitForAnswerResponse(result)) throw new Error("Invalid wait_for_answer response");
+  return result;
+};
+var cancelQuestion = async (apiKey, correlationId) => {
+  await callMcpTool(apiKey, "cancel_question", { correlationId });
+};
+var sendNotification = async (apiKey, params) => {
+  await callMcpTool(apiKey, "send_notification", { ...params }, { maxRetries: 3 });
+};
+
+// 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 cacheFile = (apiKey) => {
+  const hash = createHash("sha256").update(apiKey).digest("hex").slice(0, 12);
+  return join(tmpdir(), `pushary-policy-${hash}.json`);
+};
+var fetchPolicy = async (apiKey) => {
+  return withRetry(async () => {
+    const baseUrl = getBaseUrl();
+    const response = await fetch(`${baseUrl}/api/mcp/policy`, {
+      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) => {
+  const path = cacheFile(apiKey);
+  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 ttlFresh = !cached._cachedAt || Date.now() - cached._cachedAt < CACHE_TTL_MS;
+      if (ttlFresh && !versionStale) {
+        return cached;
+      }
+      staleCache = cached;
+    } catch {
+    }
+  }
+  try {
+    const policy = await fetchPolicy(apiKey);
+    try {
+      writeFileSync(path, JSON.stringify({ ...policy, _cachedAt: Date.now(), _policyVersion: expectedVersion ?? null }), "utf-8");
+    } catch {
+    }
+    return policy;
+  } catch {
+    if (staleCache) return staleCache;
+    throw new Error("Failed to fetch policy and no cached policy available");
+  }
+};
+var findBestMatch = (policies, toolName, arg) => {
+  let best;
+  let bestWeight = 0;
+  let bestLength = -1;
+  for (const candidate of policies) {
+    const rank = matchToolPattern(candidate.tool, toolName, arg);
+    if (rank === "none") continue;
+    const weight = matchRankWeight(rank);
+    const length = rank === "prefix" ? candidate.tool.length : -1;
+    if (weight > bestWeight || weight === bestWeight && length > bestLength) {
+      best = candidate;
+      bestWeight = weight;
+      bestLength = length;
+    }
+  }
+  return best;
+};
+var resolvePolicy = (config, toolName, modeOverride, toolInput) => {
+  const arg = toolInput ? extractPolicyArg(toolName, toolInput) : void 0;
+  const base = findBestMatch(config.policies, toolName, arg) ?? config.policies.find((p) => p.tool === "*") ?? {
+    tool: toolName,
+    timeoutSeconds: config.defaultTimeoutSeconds,
+    timeoutAction: config.defaultTimeoutAction,
+    mode: config.defaultMode ?? "push_first",
+    pushFirstSeconds: config.defaultPushFirstSeconds ?? 20
+  };
+  const effectiveOverride = modeOverride ?? config.modeOverride;
+  if (effectiveOverride) {
+    return { ...base, mode: effectiveOverride };
+  }
+  return base;
+};
+var toPolicyVersion = (value) => typeof value === "string" || typeof value === "number" ? String(value) : null;
+var fetchModeState = async (apiKey, sessionId) => {
+  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.timeout(3e3)
+    });
+    if (!response.ok) return { mode: null, kill: false, policyVersion: null };
+    const data = await response.json();
+    const mode = data.override?.mode;
+    return {
+      mode: isApprovalMode(mode) ? mode : null,
+      kill: data.kill === true,
+      policyVersion: toPolicyVersion(data.policyVersion)
+    };
+  } catch {
+    return { mode: null, kill: false, policyVersion: null };
+  }
+};
+var fetchModeOverride = async (apiKey) => (await fetchModeState(apiKey)).mode;
+
+// src/describe.ts
+import { isAbsolute, relative } from "path";
+var hookPrefixes = {
+  Bash: (input) => `bash: ${input.command ?? "(no command)"}`,
+  Write: (input) => `write file: ${input.file_path ?? "(unknown path)"}`,
+  Edit: (input) => `edit file: ${input.file_path ?? "(unknown path)"}`,
+  Read: (input) => `read file: ${input.file_path ?? "(unknown path)"}`
+};
+var eventPrefixes = {
+  Bash: (input) => `ran: ${String(input.command ?? "").slice(0, 120)}`,
+  Write: (input) => `wrote: ${input.file_path ?? "unknown"}`,
+  Edit: (input) => `edited: ${input.file_path ?? "unknown"}`,
+  Read: (input) => `read: ${input.file_path ?? "unknown"}`
+};
+var describeToolCall = (toolName, toolInput, format = "hook") => {
+  const prefixes = format === "hook" ? hookPrefixes : eventPrefixes;
+  const builder = prefixes[toolName];
+  if (builder) return builder(toolInput);
+  return format === "hook" ? `${toolName}: ${JSON.stringify(toolInput).slice(0, 200)}` : `${toolName}: done`;
+};
+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 ? head.slice(0, TOOL_TARGET_MAX_LENGTH) : void 0;
+};
+var deriveToolTarget = (toolName, toolInput) => {
+  if (toolName === "Bash") {
+    return deriveCommandHead(toolInput.command);
+  }
+  if (toolName === "Edit" || toolName === "Write") {
+    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);
+  }
+  return void 0;
+};
+var RECEIPT_TARGET_MAX_LENGTH = 256;
+var isToolResultError = (toolResult) => {
+  try {
+    return Boolean(toolResult && ("error" in toolResult || "is_error" in toolResult));
+  } catch {
+    return false;
+  }
+};
+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 === "Edit" || toolName === "Write") {
+      const filePath = toolInput.file_path;
+      if (typeof filePath !== "string" || !filePath) return void 0;
+      return {
+        kind: toolName === "Edit" ? "edit" : "write",
+        target: relativizeReceiptPath(filePath, cwd).slice(0, RECEIPT_TARGET_MAX_LENGTH),
+        ok
+      };
+    }
+    if (toolName === "Bash") {
+      const head = deriveCommandHead(toolInput.command);
+      if (!head) return void 0;
+      return {
+        kind: head === "git commit" ? "commit" : "bash",
+        target: head,
+        ok
+      };
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+};
+
+// src/identity.ts
+import { createHash as createHash2 } from "crypto";
+import { hostname } from "os";
+var deriveMachineId = (host) => createHash2("sha256").update(host).digest("hex").slice(0, 8);
+var getMachineId = () => deriveMachineId(hostname());
+
+// src/pending.ts
+import { join as join2 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+import { existsSync as existsSync2, mkdirSync, writeFileSync as writeFileSync2, readdirSync, unlinkSync, rmSync, statSync } from "fs";
+var PENDING_DIR = join2(tmpdir2(), "pushary-pending");
+var DEFAULT_SESSION = "_no_session";
+var GRACE_MS = 10 * 60 * 1e3;
+var sanitize = (sessionId) => sessionId.replace(/[^A-Za-z0-9_-]/g, "_").slice(0, 128) || DEFAULT_SESSION;
+var dirFor = (sessionId) => join2(PENDING_DIR, sanitize(sessionId));
+var isDefaultSession = (sessionId) => sanitize(sessionId) === DEFAULT_SESSION;
+var savePendingQuestion = (sessionId, correlationId) => {
+  const dir = dirFor(sessionId);
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync2(join2(dir, correlationId), "", "utf-8");
+};
+var listPendingQuestions = (sessionId) => {
+  const dir = dirFor(sessionId);
+  let files;
+  try {
+    files = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  if (!isDefaultSession(sessionId)) return files;
+  const cutoff = Date.now() - GRACE_MS;
+  return files.filter((name) => {
+    try {
+      return statSync(join2(dir, name)).mtimeMs < cutoff;
+    } catch {
+      return false;
+    }
+  });
+};
+var removePendingQuestion = (sessionId, correlationId) => {
+  try {
+    unlinkSync(join2(dirFor(sessionId), correlationId));
+  } catch {
+  }
+};
+var removePendingSession = (sessionId) => {
+  try {
+    rmSync(dirFor(sessionId), { recursive: true, force: true });
+  } catch {
+  }
+};
+
+export {
+  isPolicyConfig,
+  askUser,
+  waitForAnswer,
+  cancelQuestion,
+  sendNotification,
+  getPolicy,
+  resolvePolicy,
+  fetchModeState,
+  fetchModeOverride,
+  describeToolCall,
+  deriveToolTarget,
+  isToolResultError,
+  deriveReceiptMeta,
+  getMachineId,
+  DEFAULT_SESSION,
+  isDefaultSession,
+  savePendingQuestion,
+  listPendingQuestions,
+  removePendingQuestion,
+  removePendingSession
+};