pushary 1.9.134 → 1.9.136

package/dist/{chunk-MRHGK3Q3.js → chunk-D7AAAD6W.js}

@@ -27,11 +27,11 @@ import {
   toolResultErrorText,
   transcriptTokensIn,
   transcriptUsageRequest
-} from "./chunk-JYCAAQUW.js";
+} from "./chunk-A2YJ2FBR.js";
 import {
   branchFor,
   repoKeyFor
-} from "./chunk-RGVQOOGD.js";
+} from "./chunk-IRIXOH4U.js";
 import {
   cancelQuestion,
   clientErrorKindOf,
@@ -39,35 +39,39 @@ import {
   reportClientError,
   sendNotification,
   waitForAnswer
-} from "./chunk-J4UNR655.js";
+} from "./chunk-L2GADKFL.js";
+import {
+  RETRY_ACK,
+  readCommandAck,
+  refusedReceiptMessage
+} from "./chunk-Y47BMZUR.js";
 import {
   isRetryable,
   withRetry
-} from "./chunk-2KN53MPE.js";
+} from "./chunk-WXUEOHYY.js";
 import {
   fetchAsCredential
-} from "./chunk-42PVKPHM.js";
+} from "./chunk-VVN3RPV6.js";
 import {
   getMachineId
-} from "./chunk-DS7XMYUB.js";
+} from "./chunk-WNT4JHK3.js";
 import {
   reportedInstallSource
-} from "./chunk-BKH4LQJC.js";
+} from "./chunk-LNF36PTF.js";
 import {
   IDLE_PROMPT_NOTIFICATION,
   NOTIFICATION_PUSH_TYPES,
   POSTTOOLUSE_MIRROR_ONLY_TOOLS,
-  canonicalJson,
   claudeConfigDir
-} from "./chunk-W4FJR57E.js";
+} from "./chunk-R7KC57PC.js";
 import {
   compareVersion,
   parseVersion
-} from "./chunk-A44MRVWG.js";
+} from "./chunk-GS5FH3C2.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-T6HX6OTY.js";
+} from "./chunk-IKBTG3OT.js";
 import {
   writeFileAtomic,
   writeJsonAtomicDurable
@@ -96,7 +100,7 @@ import {
   resolveAutoResolveOrigin,
   resolvePolicy,
   unansweredRefusalReason
-} from "./chunk-M65LPNIO.js";
+} from "./chunk-DL67HX3D.js";
 
 // src/pending.ts
 import { join } from "path";
@@ -116,6 +120,7 @@ var commandDirFor = (sessionId, namespace = "") => join(
 );
 var legacyCommandFile = (sessionId, namespace = "") => join(commandDirFor(sessionId, namespace), "command.json");
 var commandFile = (sessionId, id, namespace = "") => join(commandDirFor(sessionId, namespace), `${createHash("sha256").update(id).digest("hex")}.json`);
+var wasRefusedByTheServer = (command) => command.refused === true;
 var readCommandFile = (file) => {
   try {
     if (!lstatSync(file).isFile()) return null;
@@ -132,6 +137,7 @@ var readCommandFile = (file) => {
       expiresAtMs: value.expiresAtMs,
       ...value.attempted === true ? { attempted: true } : {},
       ...typeof value.attemptedAtMs === "number" ? { attemptedAtMs: value.attemptedAtMs } : {},
+      ...value.refused === true ? { refused: true } : {},
       ...typeof value.sessionId === "string" ? { sessionId: value.sessionId } : {},
       delivered: value.delivered === true,
       ...value.failed === true || !value.delivered && !value.attempted && value.expiresAtMs <= Date.now() ? { failed: true } : {}
@@ -179,7 +185,7 @@ var pruneExpiredCommandStore = () => {
   }
 };
 var readPendingCommand = (sessionId, namespace = "") => {
-  const commands = pruneExpiredCommands(commandDirFor(sessionId, namespace));
+  const commands = pruneExpiredCommands(commandDirFor(sessionId, namespace)).filter((command) => !wasRefusedByTheServer(command));
   return commands.find((command) => !command.delivered && !command.failed && !command.attempted) ?? commands[0] ?? null;
 };
 var writeNewCommandFile = (file, contents) => {
@@ -228,7 +234,7 @@ var updatePendingCommand = (sessionId, id, update, namespace = "") => {
 };
 var markPendingCommandAttempted = (sessionId, id, namespace = "") => {
   const command = readPendingCommandById(sessionId, id, namespace);
-  if (!command || command.attempted || command.delivered || command.failed) return false;
+  if (!command || command.attempted || command.delivered || command.failed || wasRefusedByTheServer(command)) return false;
   try {
     const descriptor = openSync(`${commandFile(sessionId, id, namespace)}.emission`, "wx", 384);
     try {
@@ -244,13 +250,17 @@ var markPendingCommandAttempted = (sessionId, id, namespace = "") => {
 var pendingCommandReceipts = (namespace) => {
   const root = join(commandRoot(), createHash("sha256").update(namespace).digest("hex").slice(0, 16));
   try {
-    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => pruneExpiredCommands(join(root, entry.name)).filter((command) => command.delivered || command.failed || command.attempted && Date.now() - (command.attemptedAtMs ?? 0) >= COMMAND_RECOVERY.emissionRecoveryGraceMs).map((command) => ({ sessionId: command.sessionId ?? entry.name, command })));
+    return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).flatMap((entry) => pruneExpiredCommands(join(root, entry.name)).filter((command) => !wasRefusedByTheServer(command) && (command.delivered || command.failed || command.attempted && Date.now() - (command.attemptedAtMs ?? 0) >= COMMAND_RECOVERY.emissionRecoveryGraceMs)).map((command) => ({ sessionId: command.sessionId ?? entry.name, command })));
   } catch {
     return [];
   }
 };
 var markPendingCommandDelivered = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: true, failed: void 0 }, namespace);
 var markPendingCommandFailed = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: false, failed: true }, namespace);
+var REFUSED_AFTER_DELIVERY = { refused: true };
+var REFUSED_BEFORE_CONFIRMED_DELIVERY = { refused: true, failed: true };
+var refusalTombstoneFor = (command) => command?.delivered ? REFUSED_AFTER_DELIVERY : REFUSED_BEFORE_CONFIRMED_DELIVERY;
+var markPendingCommandRefused = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, refusalTombstoneFor(readPendingCommandById(sessionId, id, namespace)), namespace);
 var removePendingCommand = (sessionId, id, namespace = "") => {
   if (!readPendingCommandById(sessionId, id, namespace)) return;
   try {
@@ -350,12 +360,9 @@ var emitHookOutput = async (render, write = writeOutput) => {
       command.namespace
     ))
       continue;
-    if (await command.acknowledge())
-      removePendingCommand(
-        command.sessionId,
-        command.commandId,
-        command.namespace
-      );
+    const ack = await command.acknowledge();
+    if (ack.outcome === "settled") removePendingCommand(command.sessionId, command.commandId, command.namespace);
+    if (ack.outcome === "refused") markPendingCommandRefused(command.sessionId, command.commandId, command.namespace);
   }
 };
 
@@ -788,12 +795,48 @@ var permissionTimeoutDecision = (timeoutAction, paused) => {
   return codexPass();
 };
 
-// src/codex-call-decision.ts
-import { createHash as createHash4 } from "crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, readdirSync as readdirSync3, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync4 } from "fs";
-import { tmpdir as tmpdir4, userInfo } from "os";
+// 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 join4 } from "path";
-var CODEX_DECISION_TTL_MS = 60 * 1e3;
+import { tmpdir as tmpdir4 } from "os";
+import { createHash as createHash4 } from "crypto";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, statSync as statSync3, writeFileSync as writeFileSync4, rmSync as rmSync2 } from "fs";
+var THROTTLE_DIR = join4(tmpdir4(), "pushary-throttle");
+var markerPath = (key) => join4(THROTTLE_DIR, createHash4("sha256").update(key).digest("hex").slice(0, 16));
+var claimThrottle = (key, windowMs) => {
+  try {
+    const path = markerPath(key);
+    if (existsSync3(path) && Date.now() - statSync3(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 existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync4, rmSync as rmSync4, statSync as statSync4, utimesSync as utimesSync2 } from "fs";
+import { tmpdir as tmpdir6 } from "os";
+import { join as join6 } from "path";
+
+// src/call-decision-store.ts
+import { randomUUID } from "crypto";
+import { lstatSync as lstatSync3, mkdirSync as mkdirSync4, readFileSync as readFileSync4, readdirSync as readdirSync3, renameSync, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { tmpdir as tmpdir5, userInfo } from "os";
+import { join as join5 } from "path";
 var userScope = () => {
   try {
     const info = userInfo();
@@ -803,8 +846,6 @@ var userScope = () => {
     return "default";
   }
 };
-var decisionDir = () => join4(tmpdir4(), `pushary-codex-decisions-${userScope()}`);
-var decisionFile = (key) => join4(decisionDir(), key);
 var PRESENTATION_ONLY_INPUT_KEYS = ["description"];
 var identifyingToolInput = (toolInput) => {
   if (!toolInput) return {};
@@ -815,105 +856,128 @@ var identifyingToolInput = (toolInput) => {
   }
   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 createHash4("sha256").update(material, "utf-8").digest("hex").slice(0, 32);
+var PRIVATE_FOLDER_MODE = 448;
+var PRIVATE_FILE_MODE = 384;
+var GROUP_OR_OTHER_PERMISSIONS = 63;
+var isPrivateFolder = (path) => {
+  try {
+    const folder = lstatSync3(path);
+    if (!folder.isDirectory()) return false;
+    if (typeof process.getuid !== "function") return true;
+    return folder.uid === process.getuid() && (folder.mode & GROUP_OR_OTHER_PERMISSIONS) === 0;
+  } catch {
+    return false;
+  }
 };
-var parseDecision = (raw) => {
+var privateFolderAt = (path) => {
   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;
+    mkdirSync4(path, { recursive: true, mode: PRIVATE_FOLDER_MODE });
   } catch {
     return null;
   }
+  return isPrivateFolder(path) ? path : null;
 };
-var sweepExpired = (dir, nowMs) => {
+var removeQuietly = (path) => {
   try {
-    for (const name of readdirSync3(dir)) {
-      const path = join4(dir, name);
-      try {
-        if (nowMs - statSync3(path).mtimeMs >= CODEX_DECISION_TTL_MS) rmSync2(path, { force: true });
-      } catch {
-        continue;
-      }
-    }
+    rmSync3(path, { force: true });
   } catch {
     return;
   }
 };
-var recordCodexCallDecision = (key, decision) => {
-  if (!key) return;
+var reportedUnrecordedDecision = false;
+var reportUnrecordedDecision = (reason) => {
+  if (reportedUnrecordedDecision) return;
+  reportedUnrecordedDecision = true;
   try {
-    const dir = decisionDir();
-    if (!existsSync3(dir)) mkdirSync3(dir, { recursive: true, mode: 448 });
-    else sweepExpired(dir, Date.now());
-    writeFileSync4(decisionFile(key), JSON.stringify(decision), { encoding: "utf-8", mode: 384 });
+    process.stderr.write(`[pushary] Could not record this decision for the agent's next hook: ${reason}
+`);
   } catch {
     return;
   }
 };
-var consumeCodexCallDecision = (key) => {
-  if (!key) return null;
-  const path = decisionFile(key);
+var parseDecision = (raw) => {
+  let parsed;
   try {
-    const fresh = Date.now() - statSync3(path).mtimeMs < CODEX_DECISION_TTL_MS;
-    const raw = readFileSync4(path, "utf-8");
-    rmSync2(path, { force: true });
-    return fresh ? parseDecision(raw) : null;
+    parsed = JSON.parse(raw);
   } catch {
     return null;
   }
+  if (!isRecord(parsed)) return null;
+  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;
 };
-
-// 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 tmpdir5 } from "os";
-import { createHash as createHash5 } from "crypto";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, statSync as statSync4, writeFileSync as writeFileSync5, rmSync as rmSync3 } from "fs";
-var THROTTLE_DIR = join5(tmpdir5(), "pushary-throttle");
-var markerPath = (key) => join5(THROTTLE_DIR, createHash5("sha256").update(key).digest("hex").slice(0, 16));
-var claimThrottle = (key, windowMs) => {
+var sweepExpired = (dir, nowMs, ttlMs) => {
   try {
-    const path = markerPath(key);
-    if (existsSync4(path) && Date.now() - statSync4(path).mtimeMs < windowMs) return "throttled";
-    mkdirSync4(THROTTLE_DIR, { recursive: true });
-    writeFileSync5(path, "", "utf-8");
-    return "passed";
+    for (const name of readdirSync3(dir)) {
+      const path = join5(dir, name);
+      try {
+        if (nowMs - lstatSync3(path).mtimeMs >= ttlMs) rmSync3(path, { force: true });
+      } catch {
+        continue;
+      }
+    }
   } catch {
-    return "unavailable";
+    return;
   }
 };
-var releaseThrottle = (key) => {
-  rmSync3(markerPath(key), { force: true });
+var readClaimed = (claimed, ttlMs) => {
+  try {
+    const record = lstatSync3(claimed);
+    if (!record.isFile() || Date.now() - record.mtimeMs >= ttlMs) return null;
+    return parseDecision(readFileSync4(claimed, "utf-8"));
+  } catch {
+    return null;
+  } finally {
+    removeQuietly(claimed);
+  }
+};
+var callDecisionStore = (name, ttlMs) => {
+  const decisionDir = () => join5(tmpdir5(), `pushary-${name}-decisions-${userScope()}`);
+  return {
+    record: (key, decision) => {
+      if (!key) return;
+      const dir = privateFolderAt(decisionDir());
+      if (!dir) {
+        reportUnrecordedDecision(`${decisionDir()} is not a folder only this user can open`);
+        return;
+      }
+      sweepExpired(dir, Date.now(), ttlMs);
+      const pending = join5(dir, `${key}.${randomUUID()}.pending`);
+      try {
+        writeFileSync5(pending, JSON.stringify(decision), { encoding: "utf-8", mode: PRIVATE_FILE_MODE, flag: "wx" });
+        renameSync(pending, join5(dir, key));
+      } catch (error) {
+        removeQuietly(pending);
+        reportUnrecordedDecision(error instanceof Error ? error.message : String(error));
+      }
+    },
+    consume: (key) => {
+      if (!key) return null;
+      const dir = decisionDir();
+      if (!isPrivateFolder(dir)) return null;
+      const claimed = join5(dir, `${key}.${randomUUID()}.claimed`);
+      try {
+        renameSync(join5(dir, key), claimed);
+      } catch {
+        return null;
+      }
+      return readClaimed(claimed, ttlMs);
+    },
+    forget: (key) => {
+      if (!key) return;
+      const dir = decisionDir();
+      if (isPrivateFolder(dir)) removeQuietly(join5(dir, key));
+    }
+  };
 };
 
 // src/blocked-action-hint.ts
-import { createHash as createHash6 } from "crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync5, readdirSync as readdirSync4, rmSync as rmSync4, statSync as statSync5, utimesSync as utimesSync2 } from "fs";
-import { tmpdir as tmpdir6 } 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);
@@ -928,7 +992,7 @@ var blockedActionFingerprint = ({ source = "claude", sessionId, toolName, toolIn
   const [canonicalInput] = canonical.toolInputs;
   if (!canonicalInput) return null;
   const subject = blockedActionSubject(source, sessionId, canonical.toolName, canonicalInput, cwd);
-  return subject ? createHash6("sha256").update(blockedActionIdentity(subject), "utf8").digest("hex") : null;
+  return subject ? createHash5("sha256").update(blockedActionIdentity(subject), "utf8").digest("hex") : null;
 };
 var hintDir = () => join6(tmpdir6(), `pushary-blocked-action-hints-${userScope()}`);
 var hintFile = (fingerprint) => join6(hintDir(), fingerprint);
@@ -938,7 +1002,7 @@ var sweepFilesOlderThan = (dir, ttlMs, nowMs) => {
     for (const name of readdirSync4(dir)) {
       const path = join6(dir, name);
       try {
-        if (nowMs - statSync5(path).mtimeMs >= ttlMs) rmSync4(path, { force: true });
+        if (nowMs - statSync4(path).mtimeMs >= ttlMs) rmSync4(path, { force: true });
       } catch {
         continue;
       }
@@ -951,7 +1015,7 @@ var recordBlockedActionHint = (fingerprint, approved) => {
   if (!isFingerprint(fingerprint)) return false;
   try {
     const dir = hintDir();
-    if (!existsSync5(dir)) mkdirSync5(dir, { recursive: true, mode: 448 });
+    if (!existsSync4(dir)) mkdirSync5(dir, { recursive: true, mode: 448 });
     else sweepFilesOlderThan(dir, BLOCKED_ACTION_HINT_TTL_MS, Date.now());
     writeFileAtomic(hintFile(fingerprint), JSON.stringify({ fingerprint, ...approved }), 384);
     return true;
@@ -962,7 +1026,7 @@ var recordBlockedActionHint = (fingerprint, approved) => {
 var readLiveHint = (fingerprint) => {
   const path = hintFile(fingerprint);
   try {
-    const stat = statSync5(path);
+    const stat = statSync4(path);
     if (!stat.isFile()) return null;
     if (isExpired(stat.mtimeMs, Date.now())) {
       rmSync4(path, { force: true });
@@ -995,7 +1059,7 @@ var approvalAwaitingRetry = (sessionId) => {
 var markApprovalReminded = (approval) => {
   const path = hintFile(approval.fingerprint);
   try {
-    const { atime, mtime } = statSync5(path);
+    const { atime, mtime } = statSync4(path);
     const { fingerprint, sessionId, toolName } = approval;
     writeFileAtomic(path, JSON.stringify({ fingerprint, sessionId, toolName, reminded: true }), 384);
     utimesSync2(path, atime, mtime);
@@ -1013,7 +1077,7 @@ var forgetBlockedActionHint = (fingerprint) => {
 };
 
 // src/claude-session-record.ts
-import { readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync6, readdirSync as readdirSync5, statSync as statSync5 } from "fs";
 import { join as join7 } from "path";
 var UNREADABLE = { kind: "unreadable" };
 var OTHER_SESSION = { kind: "other_session" };
@@ -1030,7 +1094,7 @@ var isRunning = (pid) => {
 };
 var isSmallRegularFile = (path) => {
   try {
-    const stats = statSync6(path);
+    const stats = statSync5(path);
     return stats.isFile() && stats.size <= SESSION_FILE_MAX_BYTES;
   } catch {
     return false;
@@ -1077,13 +1141,13 @@ var claudeSessionVersion = (sessionId, environment = process.env) => {
 };
 
 // src/background-work.ts
-import { createHash as createHash7 } from "crypto";
-import { mkdirSync as mkdirSync6, rmSync as rmSync5, statSync as statSync7, writeFileSync as writeFileSync6 } from "fs";
+import { createHash as createHash6 } from "crypto";
+import { mkdirSync as mkdirSync6, rmSync as rmSync5, statSync as statSync6, writeFileSync as writeFileSync6 } from "fs";
 import { tmpdir as tmpdir7 } from "os";
 import { join as join8 } from "path";
 var BACKGROUND_WORK_TTL_MS = 60 * 60 * 1e3;
 var backgroundWorkDir = () => join8(tmpdir7(), "pushary-background-work");
-var markerFor = (sessionKey) => join8(backgroundWorkDir(), createHash7("sha256").update(sessionKey).digest("hex"));
+var markerFor = (sessionKey) => join8(backgroundWorkDir(), createHash6("sha256").update(sessionKey).digest("hex"));
 var hasRunningBackgroundTasks = (backgroundTasks) => Array.isArray(backgroundTasks) && backgroundTasks.length > 0;
 var noteBackgroundWork = (sessionKey, running) => {
   try {
@@ -1099,7 +1163,7 @@ var noteBackgroundWork = (sessionKey, running) => {
 };
 var isWaitingOnBackgroundWork = (sessionKey, nowMs = Date.now()) => {
   try {
-    return nowMs - statSync7(markerFor(sessionKey)).mtimeMs < BACKGROUND_WORK_TTL_MS;
+    return nowMs - statSync6(markerFor(sessionKey)).mtimeMs < BACKGROUND_WORK_TTL_MS;
   } catch {
     return false;
   }
@@ -1107,7 +1171,7 @@ var isWaitingOnBackgroundWork = (sessionKey, nowMs = Date.now()) => {
 
 // src/events.ts
 import { basename, join as join9 } from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync7, statSync as statSync8, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync7, statSync as statSync7, writeFileSync as writeFileSync7 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
 var INTENT_DIR = join9(tmpdir8(), "pushary-intent");
 var INTENT_MAX_BYTES = 2048;
@@ -1126,7 +1190,7 @@ var saveLastPrompt = (sessionId, prompt) => {
 var readLastPrompt = (sessionId) => {
   try {
     const path = intentFile(sessionId);
-    if (isDefaultSession(sessionId) && statSync8(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
+    if (isDefaultSession(sessionId) && statSync7(path).mtimeMs < Date.now() - INTENT_GRACE_MS) return void 0;
     const value = readFileSync7(path, "utf-8").trim();
     return value.length > 0 ? value : void 0;
   } catch {
@@ -1191,7 +1255,7 @@ 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, sessionId);
-  if (!existsSync6(path)) return null;
+  if (!existsSync5(path)) return null;
   const cached = JSON.parse(readFileSync7(path, "utf-8"));
   if (!isCachedPolicyRead(cached)) return null;
   if ((cached._sessionId ?? null) !== (sessionId ?? null)) return null;
@@ -1266,7 +1330,7 @@ var detectInstallMode = () => (process.argv[1] ?? "").includes("_npx") ? "npx" :
 var acknowledgePendingCommand = async (apiKey, baseUrl, commandId, sessionId, machineId, timeoutMs, state = "delivered", signal) => {
   try {
     signal?.throwIfAborted();
-    if (timeoutMs <= 0) return false;
+    if (timeoutMs <= 0) return RETRY_ACK;
     const response = await fetchAsCredential(apiKey, `${baseUrl}/api/agent/command/ack`, {
       method: "POST",
       headers: {
@@ -1282,9 +1346,12 @@ var acknowledgePendingCommand = async (apiKey, baseUrl, commandId, sessionId, ma
       }),
       signal: AbortSignal.any([AbortSignal.timeout(timeoutMs), ...signal ? [signal] : []])
     });
-    return response.ok;
+    const ack = await readCommandAck(response);
+    if (ack.outcome === "refused") process.stderr.write(`${refusedReceiptMessage(commandId, ack.status)}
+`);
+    return ack;
   } catch {
-    return false;
+    return RETRY_ACK;
   }
 };
 var ACK_RESERVE_MS = 1500;
@@ -1358,7 +1425,11 @@ var reportEvent = async (event, options = {}) => {
           failed ? "failed" : storedCommand.attempted && !storedCommand.delivered ? "uncertain" : "delivered",
           options.signal
         );
-        if (!acknowledged) return withoutPending();
+        if (acknowledged.outcome === "retry") return withoutPending();
+        if (acknowledged.outcome === "refused") {
+          markPendingCommandRefused(sessionKey, storedCommand.id, receiptNamespace);
+          return withoutPending();
+        }
         if (storedCommand.delivered || storedCommand.attempted || failed) {
           removePendingCommand(sessionKey, storedCommand.id, receiptNamespace);
           return withoutPending();
@@ -1391,7 +1462,8 @@ var reportEvent = async (event, options = {}) => {
           "delivered",
           options.signal
         );
-        if (!acknowledged || !markPendingCommandDelivered(sessionKey, result.pendingCommandId, receiptNamespace)) {
+        if (acknowledged.outcome === "refused") markPendingCommandRefused(sessionKey, result.pendingCommandId, receiptNamespace);
+        if (acknowledged.outcome !== "settled" || !markPendingCommandDelivered(sessionKey, result.pendingCommandId, receiptNamespace)) {
           return withoutPending();
         }
       }
@@ -1734,6 +1806,7 @@ export {
   pendingCommandReceipts,
   markPendingCommandDelivered,
   markPendingCommandFailed,
+  markPendingCommandRefused,
   removePendingCommand,
   emitHookOutput,
   PHONE_DRIVER,
@@ -1759,9 +1832,8 @@ export {
   codexQuestionLimitDecision,
   permissionTimeoutDecision,
   userScope,
-  codexCallKey,
-  recordCodexCallDecision,
-  consumeCodexCallDecision,
+  identifyingToolInput,
+  callDecisionStore,
   blockedActionFingerprint,
   sweepFilesOlderThan,
   recordBlockedActionHint,

package/dist/{chunk-X23GSBOH.js → chunk-DBIPNY7J.js}

@@ -1,6 +1,6 @@
 import {
   realpath
-} from "./chunk-UJZ5YHSR.js";
+} from "./chunk-EJHD44ZN.js";
 import {
   findNativeClaudeInstall
 } from "./chunk-CYTPQDQY.js";
@@ -13,10 +13,10 @@ import {
   resolvePackageVersionFromBinary,
   resolvePathBinary,
   resolvePathBinaryAsync
-} from "./chunk-A44MRVWG.js";
+} from "./chunk-GS5FH3C2.js";
 import {
   MANAGED_PROVIDERS
-} from "./chunk-M65LPNIO.js";
+} from "./chunk-DL67HX3D.js";
 
 // src/live-capabilities.ts
 import { homedir } from "os";