@pushary/agent-hooks 0.4.5 → 0.5.0

package/dist/bin/pushary-setup.js

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+import {
+  addClaudeMcpServer,
+  addPusharyHooks,
+  addPusharyToolPermissions
+} from "../chunk-AC4UYAGX.js";
 
 // bin/pushary-setup.ts
 import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync } from "fs";
@@ -10,7 +15,9 @@ import { fileURLToPath } from "url";
 var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
 var CLAUDE_JSON = join(homedir(), ".claude.json");
 var CURSOR_MCP = join(".cursor", "mcp.json");
-var SKILL_DIR = join(homedir(), ".claude", "skills", "pushary");
+var CURSOR_RULES_DIR = join(".cursor", "rules");
+var CLAUDE_SKILL_DIR = join(homedir(), ".claude", "skills", "pushary");
+var CODEX_SKILL_DIR = join(homedir(), ".codex", "skills", "pushary");
 var SHELL_FILES = [".zshrc", ".bashrc"].map((f) => join(homedir(), f));
 var dim = (s) => `\x1B[2m${s}\x1B[0m`;
 var bold = (s) => `\x1B[1m${s}\x1B[0m`;
@@ -30,7 +37,8 @@ var writeJson = (path, data) => {
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf-8");
 };
-var spinner = async (label, fn) => {
+var formatError = (err) => err instanceof Error ? err.message : String(err);
+var spinner = async (label, fn, options = {}) => {
   const frames = ["   ", ".  ", ".. ", "..."];
   let i = 0;
   const interval = setInterval(() => {
@@ -41,10 +49,11 @@ var spinner = async (label, fn) => {
     clearInterval(interval);
     process.stdout.write(`\r  ${check} ${label}
 `);
-  } catch {
+  } catch (err) {
     clearInterval(interval);
-    process.stdout.write(`\r  ${yellow("!")} ${label} ${dim("(skipped)")}
+    process.stdout.write(`\r  ${yellow("!")} ${label} ${dim(`(${formatError(err)})`)}
 `);
+    if (!options.optional) throw err;
   }
 };
 var getPackageVersion = () => {
@@ -76,74 +85,37 @@ var installGlobally = async () => {
     execSync("npm install -g @pushary/agent-hooks@latest", { stdio: "ignore" });
   });
 };
-var addMcpServer = (apiKey) => {
-  const data = readJson(CLAUDE_JSON);
-  const mcpServers = data.mcpServers ?? {};
-  mcpServers.pushary = {
-    type: "http",
-    url: "https://pushary.com/api/mcp/mcp",
-    headers: { Authorization: `Bearer ${apiKey}` }
-  };
-  data.mcpServers = mcpServers;
-  writeJson(CLAUDE_JSON, data);
-};
-var addPermissionHooks = (settings) => {
-  const hooks = settings.hooks ?? {};
-  const preToolUse = hooks.PreToolUse ?? [];
-  if (!JSON.stringify(preToolUse).includes("pushary-hook")) {
-    preToolUse.push({
-      matcher: "Bash|Write|Edit",
-      hooks: [{
-        type: "command",
-        command: "pushary-hook",
-        timeout: 120
-      }]
-    });
-    hooks.PreToolUse = preToolUse;
-  }
-  const postToolUse = hooks.PostToolUse ?? [];
-  if (!JSON.stringify(postToolUse).includes("pushary-post-hook")) {
-    postToolUse.push({
-      matcher: "Bash|Write|Edit",
-      hooks: [{
-        type: "command",
-        command: "pushary-post-hook",
-        timeout: 10
-      }]
-    });
-    hooks.PostToolUse = postToolUse;
-  }
-  const stop = hooks.Stop ?? [];
-  if (!JSON.stringify(stop).includes("pushary-stop-hook")) {
-    stop.push({
-      hooks: [{
-        type: "command",
-        command: "pushary-stop-hook",
-        timeout: 10
-      }]
-    });
-    hooks.Stop = stop;
-  }
-  settings.hooks = hooks;
+var _cachedSkillContent = null;
+var fetchSkillContent = async () => {
+  if (_cachedSkillContent) return _cachedSkillContent;
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(__dirname, "..", "..", "data", "SKILL.md"),
+    join(__dirname, "..", "data", "SKILL.md")
+  ];
+  const source = candidates.find((path) => existsSync(path));
+  if (!source) throw new Error("packaged skill not found");
+  _cachedSkillContent = readFileSync(source, "utf-8");
+  return _cachedSkillContent;
 };
-var addToolPermissions = (settings) => {
-  const permissions = settings.permissions ?? {};
-  const allow = permissions.allow ?? [];
-  const filtered = allow.filter((r) => !r.includes("pushary"));
-  const rule = "mcp__pushary__*";
-  if (!filtered.includes(rule)) filtered.push(rule);
-  permissions.allow = filtered;
-  settings.permissions = permissions;
+var installSkillToDir = async (dir, label) => {
+  await spinner(label, async () => {
+    const content = await fetchSkillContent();
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "SKILL.md"), content, "utf-8");
+  });
 };
-var installSkill = async () => {
-  await spinner("Installing Pushary skill", async () => {
-    const res = await fetch("https://raw.githubusercontent.com/pushary/pushary-skill/main/skills/pushary/SKILL.md", {
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (!res.ok) throw new Error(`Failed to fetch skill (${res.status})`);
-    const content = await res.text();
-    if (!existsSync(SKILL_DIR)) mkdirSync(SKILL_DIR, { recursive: true });
-    writeFileSync(join(SKILL_DIR, "SKILL.md"), content, "utf-8");
+var installCursorRule = async () => {
+  await spinner("Installing Pushary rules", async () => {
+    const content = await fetchSkillContent();
+    const body = content.replace(/^---[\s\S]*?---\n*/m, "");
+    const mdc = `---
+alwaysApply: true
+---
+
+${body}`;
+    if (!existsSync(CURSOR_RULES_DIR)) mkdirSync(CURSOR_RULES_DIR, { recursive: true });
+    writeFileSync(join(CURSOR_RULES_DIR, "pushary.mdc"), mdc, "utf-8");
   });
 };
 var setupClaudeCode = async (apiKey) => {
@@ -152,19 +124,21 @@ var setupClaudeCode = async (apiKey) => {
 `);
   const settings = readJson(CLAUDE_SETTINGS);
   await spinner("Adding MCP server (type: http)", async () => {
-    addMcpServer(apiKey);
+    const data = readJson(CLAUDE_JSON);
+    addClaudeMcpServer(data, apiKey);
+    writeJson(CLAUDE_JSON, data);
   });
   await spinner("Auto-allowing Pushary tools", async () => {
-    addToolPermissions(settings);
+    addPusharyToolPermissions(settings);
   });
   await installGlobally();
   await spinner("Adding hooks (PreToolUse, PostToolUse, Stop)", async () => {
-    addPermissionHooks(settings);
+    addPusharyHooks(settings);
   });
   await spinner(`Writing ${CLAUDE_SETTINGS}`, async () => {
     writeJson(CLAUDE_SETTINGS, settings);
   });
-  await installSkill();
+  await installSkillToDir(CLAUDE_SKILL_DIR, "Installing Pushary skill");
   console.log();
   console.log(`  ${dim("What this configured:")}`);
   console.log(`  ${dim("\u2022")} MCP server: your agent can send notifications and ask questions`);
@@ -196,10 +170,7 @@ var setupHermes = async (_apiKey) => {
     console.log(`  ${dim("  Install Python 3.10+ and re-run setup to fix.")}`);
   }
   await spinner("Enabling plugin", async () => {
-    try {
-      execSync("hermes plugins enable pushary", { stdio: "ignore" });
-    } catch {
-    }
+    execSync("hermes plugins enable pushary", { stdio: "ignore" });
   });
   console.log();
   console.log(`  ${dim("What this configured:")}`);
@@ -250,6 +221,7 @@ notify = ["${pusharyCodexPath}"]
       appendFileSync(codexConfig, notifyLine, "utf-8");
     }
   });
+  await installSkillToDir(CODEX_SKILL_DIR, "Installing Pushary skill");
   console.log();
   console.log(`  ${dim("What this configured:")}`);
   console.log(`  ${dim("\u2022")} MCP server: Codex can send notifications and ask questions`);
@@ -270,7 +242,7 @@ var setupCursor = async (apiKey) => {
     config.mcpServers = mcpServers;
     writeJson(CURSOR_MCP, config);
   });
-  await installSkill();
+  await installCursorRule();
 };
 var saveApiKey = async (apiKey) => {
   await spinner("Saving API key to shell profile", async () => {
@@ -379,4 +351,10 @@ var main = async () => {
   console.log(`  ${dim("3.")} Run ${cyan("npx @pushary/agent-hooks doctor")} to verify`);
   console.log();
 };
-main();
+main().catch((err) => {
+  console.log();
+  console.log(`  ${yellow("!")} Setup failed: ${formatError(err)}`);
+  console.log(`  ${dim("Run")} ${cyan("npx @pushary/agent-hooks doctor")} ${dim("after fixing the issue, then rerun setup.")}`);
+  console.log();
+  process.exit(1);
+});

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   handleStop
-} from "../chunk-EQE6Z4YQ.js";
-import "../chunk-VUNL35KE.js";
+} from "../chunk-P4JH2Q7Z.js";
+import "../chunk-KTP2EPVB.js";
+import "../chunk-VIST7ACL.js";
 
 // bin/pushary-stop-hook.ts
 var main = async () => {

package/dist/chunk-AC4UYAGX.js

@@ -0,0 +1,136 @@
+// src/claude-config.ts
+var PUSHARY_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var PUSHARY_PERMISSION_RULE = "mcp__pushary__*";
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var isPusharyPermission = (rule) => typeof rule === "string" && (rule.includes("pushary") || rule.includes("MCP(pushary"));
+var isPusharyHook = (entry) => {
+  const hooks = asRecord(entry)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    const command = String(asRecord(hook)?.command ?? "");
+    return command.includes("pushary-hook") || command.includes("pushary-post-hook") || command.includes("pushary-stop-hook");
+  });
+};
+var addClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = ensureRecord(config, "mcpServers");
+  mcpServers.pushary = {
+    type: "http",
+    url: PUSHARY_MCP_URL,
+    headers: { Authorization: `Bearer ${apiKey}` }
+  };
+};
+var removeClaudeMcpServers = (config) => {
+  let changed = false;
+  const removeFrom = (target) => {
+    const mcpServers = asRecord(target.mcpServers);
+    if (!mcpServers?.pushary) return;
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete target.mcpServers;
+    changed = true;
+  };
+  removeFrom(config);
+  const projects = asRecord(config.projects);
+  if (projects) {
+    for (const project of Object.values(projects)) {
+      const projectConfig = asRecord(project);
+      if (projectConfig) removeFrom(projectConfig);
+    }
+  }
+  return changed;
+};
+var addPusharyToolPermissions = (settings) => {
+  const permissions = ensureRecord(settings, "permissions");
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filtered = allow.filter((rule) => !isPusharyPermission(rule));
+  if (!filtered.includes(PUSHARY_PERMISSION_RULE)) {
+    filtered.push(PUSHARY_PERMISSION_RULE);
+  }
+  permissions.allow = filtered;
+};
+var addPusharyHooks = (settings) => {
+  const hooks = ensureRecord(settings, "hooks");
+  const preToolUse = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
+  if (!preToolUse.some(isPusharyHook)) {
+    preToolUse.push({
+      matcher: "Bash|Write|Edit",
+      hooks: [{
+        type: "command",
+        command: "pushary-hook",
+        timeout: 120
+      }]
+    });
+    hooks.PreToolUse = preToolUse;
+  }
+  const postToolUse = Array.isArray(hooks.PostToolUse) ? hooks.PostToolUse : [];
+  if (!postToolUse.some(isPusharyHook)) {
+    postToolUse.push({
+      matcher: "Bash|Write|Edit",
+      hooks: [{
+        type: "command",
+        command: "pushary-post-hook",
+        timeout: 10
+      }]
+    });
+    hooks.PostToolUse = postToolUse;
+  }
+  const stop = Array.isArray(hooks.Stop) ? hooks.Stop : [];
+  if (!stop.some(isPusharyHook)) {
+    stop.push({
+      hooks: [{
+        type: "command",
+        command: "pushary-stop-hook",
+        timeout: 10
+      }]
+    });
+    hooks.Stop = stop;
+  }
+};
+var removePusharySettings = (settings) => {
+  let changed = removeClaudeMcpServers(settings);
+  const permissions = asRecord(settings.permissions);
+  if (permissions && Array.isArray(permissions.allow)) {
+    const filtered = permissions.allow.filter((rule) => !isPusharyPermission(rule));
+    if (filtered.length !== permissions.allow.length) {
+      if (filtered.length === 0) {
+        delete permissions.allow;
+      } else {
+        permissions.allow = filtered;
+      }
+      if (Object.keys(permissions).length === 0) delete settings.permissions;
+      changed = true;
+    }
+  }
+  const hooks = asRecord(settings.hooks);
+  if (hooks) {
+    for (const key of ["PreToolUse", "PostToolUse", "Stop"]) {
+      const entries = hooks[key];
+      if (!Array.isArray(entries)) continue;
+      const filtered = entries.filter((entry) => !isPusharyHook(entry));
+      if (filtered.length !== entries.length) {
+        if (filtered.length === 0) {
+          delete hooks[key];
+        } else {
+          hooks[key] = filtered;
+        }
+        changed = true;
+      }
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  return changed;
+};
+
+export {
+  addClaudeMcpServer,
+  removeClaudeMcpServers,
+  addPusharyToolPermissions,
+  addPusharyHooks,
+  removePusharySettings
+};

package/dist/chunk-DF3BM6BF.js

@@ -0,0 +1,195 @@
+import {
+  askUser,
+  sendNotification,
+  waitForAnswer
+} from "./chunk-KTP2EPVB.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-VIST7ACL.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 = 5 * 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) => {
+  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}`);
+  }
+  return response.json();
+};
+var getPolicy = async (apiKey) => {
+  const path = cacheFile(apiKey);
+  if (existsSync(path)) {
+    try {
+      const stat = readFileSync(path, "utf-8");
+      const cached = JSON.parse(stat);
+      if (!cached._cachedAt || Date.now() - cached._cachedAt < CACHE_TTL_MS) {
+        return cached;
+      }
+    } catch {
+    }
+  }
+  const policy = await fetchPolicy(apiKey);
+  writeFileSync(path, JSON.stringify({ ...policy, _cachedAt: Date.now() }), "utf-8");
+  return policy;
+};
+var resolvePolicy = (config, toolName) => {
+  const exact = config.policies.find((p) => p.tool === toolName);
+  if (exact) return exact;
+  const wildcard = config.policies.find((p) => p.tool === "*");
+  if (wildcard) return wildcard;
+  return {
+    tool: toolName,
+    timeoutSeconds: config.defaultTimeoutSeconds,
+    timeoutAction: config.defaultTimeoutAction,
+    mode: config.defaultMode ?? "push_first",
+    pushFirstSeconds: config.defaultPushFirstSeconds ?? 10
+  };
+};
+
+// src/hook.ts
+import { basename } from "path";
+import { writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+var describeToolCall = (input) => {
+  const { tool_name, tool_input } = input;
+  switch (tool_name) {
+    case "Bash":
+      return `bash: ${tool_input.command ?? "(no command)"}`;
+    case "Write":
+      return `write file: ${tool_input.file_path ?? "(unknown path)"}`;
+    case "Edit":
+      return `edit file: ${tool_input.file_path ?? "(unknown path)"}`;
+    case "Read":
+      return `read file: ${tool_input.file_path ?? "(unknown path)"}`;
+    default:
+      return `${tool_name}: ${JSON.stringify(tool_input).slice(0, 200)}`;
+  }
+};
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var allow = () => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "allow"
+  }
+});
+var deny = (reason) => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "deny",
+    permissionDecisionReason: reason
+  }
+});
+var ask = (reason) => ({
+  hookSpecificOutput: {
+    hookEventName: "PreToolUse",
+    permissionDecision: "ask",
+    ...reason ? { permissionDecisionReason: reason } : {}
+  }
+});
+var PENDING_DIR = join2(tmpdir2(), "pushary-pending");
+var savePendingQuestion = (correlationId) => {
+  if (!existsSync2(PENDING_DIR)) mkdirSync(PENDING_DIR, { recursive: true });
+  writeFileSync2(join2(PENDING_DIR, correlationId), "", "utf-8");
+};
+var pollForAnswer = async (apiKey, correlationId, deadlineMs, pollInterval = 2e3) => {
+  while (Date.now() < deadlineMs) {
+    const remaining = Math.min(Math.max(deadlineMs - Date.now(), 1e3), 3e4);
+    const answer = await waitForAnswer(apiKey, correlationId, remaining);
+    if (answer.answered) return answer;
+    if (Date.now() + pollInterval >= deadlineMs) break;
+    await sleep(pollInterval);
+  }
+  return { answered: false };
+};
+var handlePushOnly = async (apiKey, description, projectName, timeoutSeconds, timeoutAction) => {
+  const result = await askUser(apiKey, {
+    question: `Allow ${description}?`,
+    type: "confirm",
+    context: `Agent wants to run this in ${projectName}`,
+    agentName: `Claude Code - ${projectName}`
+  });
+  const deadline = Date.now() + timeoutSeconds * 1e3;
+  const answer = await pollForAnswer(apiKey, result.correlationId, deadline);
+  if (answer.answered) {
+    return answer.value === "yes" ? allow() : deny("Denied via push notification");
+  }
+  switch (timeoutAction) {
+    case "approve":
+      return allow();
+    case "deny":
+      return deny("No response within timeout");
+    default:
+      return ask("No push response, asking in terminal");
+  }
+};
+var handleTerminalOnly = () => {
+  return ask();
+};
+var handlePushFirst = async (apiKey, description, projectName, pushFirstSeconds) => {
+  const result = await askUser(apiKey, {
+    question: `Allow ${description}?`,
+    type: "confirm",
+    context: `Agent wants to run this in ${projectName}`,
+    agentName: `Claude Code - ${projectName}`
+  });
+  const deadline = Date.now() + pushFirstSeconds * 1e3;
+  const answer = await pollForAnswer(apiKey, result.correlationId, deadline, 1500);
+  if (answer.answered) {
+    return answer.value === "yes" ? allow() : deny("Denied via push notification");
+  }
+  savePendingQuestion(result.correlationId);
+  return ask("Sent as push notification. You can also approve here.");
+};
+var handleNotifyOnly = async (apiKey, description, projectName) => {
+  try {
+    await sendNotification(apiKey, {
+      title: "Agent needs approval",
+      body: description,
+      agentName: `Claude Code - ${projectName}`
+    });
+  } catch {
+  }
+  return ask();
+};
+var handlePreToolUse = async (input) => {
+  const apiKey = getApiKey();
+  const policy = await getPolicy(apiKey);
+  const toolPolicy = resolvePolicy(policy, input.tool_name);
+  if (toolPolicy.timeoutSeconds === 0 && toolPolicy.timeoutAction === "approve") {
+    return allow();
+  }
+  const description = describeToolCall(input);
+  const projectName = basename(input.cwd ?? process.cwd());
+  switch (toolPolicy.mode) {
+    case "push_only":
+      return handlePushOnly(apiKey, description, projectName, toolPolicy.timeoutSeconds, toolPolicy.timeoutAction);
+    case "terminal_only":
+      return handleTerminalOnly();
+    case "push_first":
+      return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds);
+    case "notify_only":
+      return handleNotifyOnly(apiKey, description, projectName);
+    default:
+      return handlePushFirst(apiKey, description, projectName, toolPolicy.pushFirstSeconds);
+  }
+};
+
+export {
+  getPolicy,
+  resolvePolicy,
+  handlePreToolUse
+};

package/dist/chunk-KTP2EPVB.js

@@ -0,0 +1,27 @@
+import {
+  callMcpTool
+} from "./chunk-VIST7ACL.js";
+
+// src/api.ts
+var askUser = async (apiKey, params) => {
+  return callMcpTool(apiKey, "ask_user", { ...params });
+};
+var waitForAnswer = async (apiKey, correlationId, timeoutMs = 3e4) => {
+  return callMcpTool(apiKey, "wait_for_answer", {
+    correlationId,
+    timeoutMs
+  });
+};
+var cancelQuestion = async (apiKey, correlationId) => {
+  await callMcpTool(apiKey, "cancel_question", { correlationId });
+};
+var sendNotification = async (apiKey, params) => {
+  await callMcpTool(apiKey, "send_notification", { ...params });
+};
+
+export {
+  askUser,
+  waitForAnswer,
+  cancelQuestion,
+  sendNotification
+};

package/dist/{chunk-EQE6Z4YQ.js → chunk-P4JH2Q7Z.js}

@@ -1,11 +1,35 @@
+import {
+  cancelQuestion
+} from "./chunk-KTP2EPVB.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-VUNL35KE.js";
+} from "./chunk-VIST7ACL.js";
 
 // src/events.ts
 import { hostname } from "os";
 import { basename } from "path";
+import { readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+var PENDING_DIR = join(tmpdir(), "pushary-pending");
+var cleanupPendingQuestions = async () => {
+  try {
+    const files = readdirSync(PENDING_DIR);
+    const apiKey = getApiKey();
+    for (const correlationId of files) {
+      try {
+        await cancelQuestion(apiKey, correlationId);
+      } catch {
+      }
+      try {
+        unlinkSync(join(PENDING_DIR, correlationId));
+      } catch {
+      }
+    }
+  } catch {
+  }
+};
 var reportEvent = async (event) => {
   const apiKey = getApiKey();
   const baseUrl = getBaseUrl();
@@ -40,6 +64,7 @@ var handlePostToolUse = async (input) => {
     default:
       action = `${input.tool_name}: done`;
   }
+  await cleanupPendingQuestions();
   const isError = input.tool_result && ("error" in input.tool_result || "is_error" in input.tool_result);
   await reportEvent({
     event: isError ? "tool_error" : "tool_complete",