@pushary/agent-hooks 1.9.0 → 1.9.2

package/dist/{chunk-7TQQSQZ7.js → chunk-2E4SRGYD.js}

@@ -3,27 +3,27 @@ import {
   expectedLaunchCapabilities,
   hasSpawnProvider,
   resolveControlPolicy
-} from "./chunk-CFAD2LTH.js";
+} from "./chunk-HLNSTJND.js";
 import {
   daemonHasRemoteProof,
   daemonServiceManagerAvailable,
   hasDaemonServiceDefinition,
   readDaemonNeedsLogin,
   readDaemonStatus
-} from "./chunk-LQESQPIT.js";
+} from "./chunk-WCHFDVCC.js";
 import {
   readControlMode,
   readKeySource
-} from "./chunk-ZRHA4PGN.js";
+} from "./chunk-ZNUNWWCN.js";
 import {
   getMachineId
-} from "./chunk-VV4SBPCQ.js";
+} from "./chunk-3O4EBTR3.js";
 import {
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-L52OIZXV.js";
 import {
   getPackageVersion
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/machines.ts
 import { hostname } from "os";
@@ -67,7 +67,11 @@ var parseMachine = (value) => {
     online: raw.online === true
   };
 };
-var machineReadiness = (machines, machineId, expectedCapabilities, now = Date.now()) => {
+var serverClockOffsetMs = (response, receivedAt) => {
+  const serverTime = Date.parse(response.headers.get("date") ?? "");
+  return Number.isFinite(serverTime) ? serverTime - receivedAt : 0;
+};
+var machineReadiness = (machines, machineId, expectedCapabilities, now = Date.now(), clockOffsetMs = 0) => {
   const machine = machines.find((item) => item.machineId === machineId);
   if (!machine) return { kind: "not-ready", detail: "this machine has not heartbeated to the server" };
   if (!machine.online) return { kind: "not-ready", detail: "the server reports this machine offline" };
@@ -77,15 +81,15 @@ var machineReadiness = (machines, machineId, expectedCapabilities, now = Date.no
   if (machine.lastControlAt === null || !Number.isFinite(Date.parse(machine.lastControlAt))) {
     return { kind: "not-ready", detail: "the server has not observed this machine polling the control queue" };
   }
-  if (!daemonHasRemoteProof({ kind: "running", lastSuccessfulHeartbeatAt: machine.lastSeenAt, lastSuccessfulControlAt: machine.lastControlAt }, now)) {
+  if (!daemonHasRemoteProof({ kind: "running", lastSuccessfulHeartbeatAt: machine.lastSeenAt, lastSuccessfulControlAt: machine.lastControlAt }, now + clockOffsetMs)) {
     return { kind: "not-ready", detail: "the heartbeat or control-queue proof is stale; wake this machine and retry pushary doctor" };
   }
   const missing = expectedCapabilities.filter((capability) => !machine.capabilities.includes(capability));
-  return missing.length === 0 ? { kind: "ready", machine } : { kind: "not-ready", detail: `the server is missing capabilities: ${missing.join(", ")}` };
+  return missing.length === 0 ? { kind: "ready", machine, clockOffsetMs } : { kind: "not-ready", detail: `the server is missing capabilities: ${missing.join(", ")}` };
 };
 var readMachineReadiness = async (apiKey, expectedCapabilities, deps = {}) => {
   const listed = await listMachines(apiKey, deps);
-  return listed.kind === "ok" ? machineReadiness(listed.machines, deps.machineId ?? getMachineId(), expectedCapabilities, deps.now?.()) : listed.kind === "unsupported" ? { kind: "unsupported", detail: "the server does not report machine readiness yet" } : listed;
+  return listed.kind === "ok" ? machineReadiness(listed.machines, deps.machineId ?? getMachineId(), expectedCapabilities, deps.now?.(), listed.clockOffsetMs) : listed.kind === "unsupported" ? { kind: "unsupported", detail: "the server does not report machine readiness yet" } : listed;
 };
 var waitForMachineReadiness = async (apiKey, expectedCapabilities, deps = {}) => {
   const attempts = deps.attempts ?? 21;
@@ -106,11 +110,12 @@ var listMachines = async (apiKey, deps = {}) => {
       headers: { Authorization: `Bearer ${apiKey}` },
       signal: AbortSignal.timeout(1e4)
     });
+    const clockOffsetMs = serverClockOffsetMs(res, (deps.now ?? Date.now)());
     if (res.status === 404) return { kind: "unsupported" };
     if (!res.ok) return { kind: "failed", detail: `HTTP ${res.status}` };
     const body = await res.json().catch(() => null);
     const list = body && Array.isArray(body.machines) ? body.machines : [];
-    return { kind: "ok", machines: list.map(parseMachine).filter((m) => m !== null) };
+    return { kind: "ok", machines: list.map(parseMachine).filter((m) => m !== null), clockOffsetMs };
   } catch (err) {
     return { kind: "failed", detail: err instanceof Error ? err.message : "network error" };
   }
@@ -136,7 +141,7 @@ var readManagedControlEvidence = (apiKey, providers, serverProof) => {
   const keyCurrent = Boolean(apiKey) && readKeySource().key === apiKey && readDaemonNeedsLogin().kind !== "blocked";
   const policy = resolveControlPolicy({ mode: readControlMode(), providerAvailable, managerAvailable, servicePresent: serviceInstalled || daemon.kind !== "absent" });
   const localProof = daemonHasRemoteProof(daemon, now);
-  const remote = serverProof?.kind === "ready" ? machineReadiness([serverProof.machine], daemon.machineId ?? "", expectedLaunchCapabilities(providers), now) : serverProof;
+  const remote = serverProof?.kind === "ready" ? machineReadiness([serverProof.machine], daemon.machineId ?? "", expectedLaunchCapabilities(providers), now, serverProof.clockOffsetMs) : serverProof;
   return {
     ready: keyCurrent && policy === "enabled" && providerAvailable && managerAvailable && serviceInstalled && localProof && remote?.kind === "ready",
     keyCurrent,

package/dist/{chunk-TUZ7WKOF.js → chunk-2XK6D4WL.js}

@@ -1,6 +1,6 @@
 import {
   HOOK_LOCATOR_BINARY
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/diagnostics/bridge.ts
 import { execFileSync } from "child_process";

package/dist/{chunk-42E4DE6C.js → chunk-35N53QLA.js}

@@ -14,36 +14,36 @@ import {
   IDLE_PROMPT_NOTIFICATION,
   NOTIFICATION_PUSH_TYPES,
   POSTTOOLUSE_MIRROR_ONLY_TOOLS
-} from "./chunk-VYNTRHB6.js";
+} from "./chunk-RTKPR4UA.js";
 import {
   cancelQuestion,
   isPolicyConfig,
   sendNotification,
   waitForAnswer
-} from "./chunk-ZMVLKPT7.js";
+} from "./chunk-HZYUDXIH.js";
 import {
   clientErrorKindOf,
   reportClientError
-} from "./chunk-BG4QCOHQ.js";
+} from "./chunk-XXSAGQAV.js";
 import {
   withRetry
-} from "./chunk-CPBRXBLG.js";
+} from "./chunk-XOXW4D6P.js";
 import {
   getMachineId
-} from "./chunk-VV4SBPCQ.js";
+} from "./chunk-3O4EBTR3.js";
 import {
   reportedInstallSource
-} from "./chunk-US3RDXK7.js";
+} from "./chunk-UBCTOE5X.js";
 import {
   canonicalJson
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   writeFileAtomic
 } from "./chunk-T7E75EKA.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-EG46RJRF.js";
+} from "./chunk-L52OIZXV.js";
 import {
   ACTION_BODY_MAX,
   AGENT_LABELS_BY_TYPE,
@@ -70,7 +70,7 @@ import {
   resolvePolicy,
   toToolLookup,
   truncateLine
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/policy.ts
 import { createHash } from "crypto";
@@ -576,6 +576,7 @@ var rawActionBody = (toolName, toolInput) => {
   if (toolName === "Bash" || toolName === "PowerShell" || toolName === "Monitor" || toolName === "run_shell_command" || toolName === "shell" || toolName === "apply_patch") {
     return firstString(toolInput.command);
   }
+  if (toolName === "write_stdin" || toolName === "request_permissions") return JSON.stringify(toolInput, null, 2);
   return firstString(toolInput.url, toolInput.href);
 };
 var deriveActionBody = (toolName, toolInput) => {

package/dist/{chunk-VV4SBPCQ.js → chunk-3O4EBTR3.js}

@@ -1,6 +1,6 @@
 import {
   pusharyDir
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   writeFileAtomic
 } from "./chunk-T7E75EKA.js";

package/dist/{chunk-XGS2DHGF.js → chunk-4KMTRXNL.js}

@@ -1,10 +1,10 @@
 import {
   pusharyHookExecutable
-} from "./chunk-NAJ3UV4E.js";
+} from "./chunk-EUNYNLDU.js";
 import {
   isProtectedByScope,
   registerHookEntry
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 
 // src/skills-cli.ts
 import { execSync } from "child_process";

package/dist/chunk-6S727YUV.js

@@ -0,0 +1,242 @@
+import {
+  claimUpgradeLock,
+  finishWithUpgradeLock,
+  installWithUpgradeLock,
+  releaseAutoUpdateLock
+} from "./chunk-JXLANQLV.js";
+import {
+  describeAutoUpdateCheck,
+  globalInstallLocation,
+  hasPendingUpgradeFinish,
+  readAutoUpdateState,
+  updateAutoUpdateState,
+  upgradeEntryFor
+} from "./chunk-COVPHB56.js";
+import {
+  EXIT
+} from "./chunk-KZERVKTD.js";
+import {
+  autoUpdateLock,
+  autoUpdateLog,
+  autoUpdateState,
+  execNpm,
+  fetchLatestPublishedVersion,
+  npmErrorMessage,
+  readGlobalCliInstallAt,
+  readGlobalPrefix
+} from "./chunk-HZ57E6LS.js";
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-ABIW72ST.js";
+import {
+  commandsPackage,
+  globalUpgradeEntry,
+  isNewerVersion,
+  isReleaseVersion,
+  isSameMajorVersion,
+  ownPackageRoot,
+  packageVersionAt
+} from "./chunk-ZFDGCEKO.js";
+
+// src/global-upgrade.ts
+import { existsSync } from "fs";
+
+// src/auto-update-run.ts
+import { closeSync, mkdirSync, openSync, statSync, writeSync } from "fs";
+import { dirname } from "path";
+var FINISH_UPGRADE_FLAG = "--finish-upgrade";
+var INSTALL_TIMEOUT_MS = 12e4;
+var LOG_LIMIT_BYTES = 256 * 1024;
+var UNREADABLE_INSTALLED_VERSION = "could not read the installed version";
+var UNREACHABLE_REGISTRY = "could not read the latest version from the npm registry";
+var MANUAL_UPGRADE_COMMAND = `${NPX_LATEST_COMMAND} upgrade`;
+var openAutoUpdateLog = (logPath) => {
+  mkdirSync(dirname(logPath), { recursive: true });
+  const size = statSync(logPath, { throwIfNoEntry: false })?.size ?? 0;
+  return openSync(logPath, size > LOG_LIMIT_BYTES ? "w" : "a");
+};
+var appendAutoUpdateLog = (logPath, line) => {
+  try {
+    const handle = openAutoUpdateLog(logPath);
+    try {
+      writeSync(handle, `${line}
+`);
+    } finally {
+      closeSync(handle);
+    }
+  } catch {
+    return;
+  }
+};
+var finishInNewInstall = async (request) => {
+  const handle = openAutoUpdateLog(request.logPath);
+  try {
+    await finishWithUpgradeLock({
+      entry: request.entry,
+      args: [FINISH_UPGRADE_FLAG],
+      lockPath: request.lockPath,
+      stdio: ["ignore", handle, handle, "ipc"],
+      env: { npm_config_prefix: request.prefix }
+    });
+  } finally {
+    closeSync(handle);
+  }
+};
+var incompleteFinishDetail = (logPath) => `installed, but refreshing the agent configs did not finish cleanly; see ${logPath}`;
+var newMajorDetail = (latest) => `${latest} is a new major version; run ${MANUAL_UPGRADE_COMMAND}`;
+var finishInstalledUpgrade = async (context, from, to) => {
+  const pending = { result: "finish_pending", from, to, detail: incompleteFinishDetail(context.logPath) };
+  recordAutoUpdateCheck(context.statePath, pending, new Date(context.now()).toISOString());
+  try {
+    await context.finish({ lockPath: context.lockPath, entry: upgradeEntryFor(context.location), prefix: context.location.prefix, logPath: context.logPath });
+    return { result: "updated", from, to };
+  } catch {
+    return pending;
+  }
+};
+var isInstallableRelease = (latest, installed) => latest !== void 0 && isNewerVersion(latest, installed) && isSameMajorVersion(latest, installed);
+var checkAndInstall = async (context) => {
+  const installed = packageVersionAt(context.packageRoot);
+  if (installed === void 0 || !isReleaseVersion(installed)) {
+    return { result: "failed", from: installed, detail: UNREADABLE_INSTALLED_VERSION };
+  }
+  const previous = readAutoUpdateState(context.statePath);
+  const pendingFinish = hasPendingUpgradeFinish(previous, installed);
+  const latest = await fetchLatestPublishedVersion({ packageName: context.location.packageName, fetchImpl: context.fetchImpl });
+  if (pendingFinish && !isInstallableRelease(latest, installed)) return finishInstalledUpgrade(context, previous.from, installed);
+  if (latest === void 0) return { result: "failed", from: installed, detail: UNREACHABLE_REGISTRY };
+  if (!isNewerVersion(latest, installed)) return { result: "current", from: installed };
+  if (!isSameMajorVersion(latest, installed)) {
+    return { result: "needs_manual", from: installed, to: latest, detail: newMajorDetail(latest) };
+  }
+  appendAutoUpdateLog(context.logPath, `${new Date(context.now()).toISOString()} installing ${context.location.packageName}@${latest} into ${context.location.prefix}`);
+  try {
+    installWithUpgradeLock({
+      packageName: context.location.packageName,
+      version: latest,
+      prefix: context.location.prefix,
+      timeoutMs: INSTALL_TIMEOUT_MS
+    }, context.lockPath, context.runNpm);
+  } catch (error) {
+    return { result: "failed", from: installed, to: latest, detail: npmErrorMessage(error) };
+  }
+  return finishInstalledUpgrade(context, installed, latest);
+};
+var recordAutoUpdateCheck = (statePath, check, at) => updateAutoUpdateState(statePath, {
+  lastCheckAt: at,
+  lastResult: check.result,
+  from: check.from,
+  to: check.to,
+  at,
+  detail: check.detail,
+  announced: check.result === "updated" ? false : void 0
+});
+var runAutoUpdate = async (run = {}) => {
+  if ((run.platform ?? process.platform) === "linux") return { kind: "linux" };
+  const packageRoot = run.packageRoot ?? ownPackageRoot();
+  const location = packageRoot === void 0 ? null : globalInstallLocation(packageRoot);
+  if (packageRoot === void 0 || location === null) return { kind: "not_global_install" };
+  const now = run.now ?? Date.now;
+  const lockPath = run.lockPath ?? autoUpdateLock();
+  const logPath = run.logPath ?? autoUpdateLog();
+  const claim = await claimUpgradeLock({ lockPath });
+  if (claim.kind === "unavailable") {
+    const at = new Date(now()).toISOString();
+    const state = recordAutoUpdateCheck(run.statePath ?? autoUpdateState(), { result: "failed", detail: claim.reason }, at);
+    appendAutoUpdateLog(logPath, `${at} ${describeAutoUpdateCheck(state)}`);
+    return { kind: "recorded", state };
+  }
+  if (claim.kind !== "acquired") return { kind: "locked" };
+  try {
+    const check = await checkAndInstall({
+      lockPath,
+      packageRoot,
+      statePath: run.statePath ?? autoUpdateState(),
+      location,
+      logPath,
+      now,
+      fetchImpl: run.fetchImpl ?? fetch,
+      runNpm: run.runNpm ?? execNpm,
+      finish: run.finish ?? finishInNewInstall
+    });
+    const at = new Date(now()).toISOString();
+    const state = recordAutoUpdateCheck(run.statePath ?? autoUpdateState(), check, at);
+    appendAutoUpdateLog(logPath, `${at} ${describeAutoUpdateCheck(state)}`);
+    return { kind: "recorded", state };
+  } finally {
+    releaseAutoUpdateLock(lockPath);
+  }
+};
+
+// src/global-upgrade.ts
+var NOT_INSTALLED = { kind: "not_installed" };
+var globalUpgradeSubject = (prefix, install) => {
+  if (prefix === void 0) return NOT_INSTALLED;
+  const commands = commandsPackage(install);
+  if (commands?.version !== void 0) return { kind: "installed", prefix, name: commands.name, version: commands.version };
+  return install.kind === "both" ? { kind: "both_installed" } : NOT_INSTALLED;
+};
+var readGlobalUpgradeSubject = (platform = process.platform) => {
+  const prefix = readGlobalPrefix();
+  return globalUpgradeSubject(prefix, prefix === void 0 ? { kind: "unavailable" } : readGlobalCliInstallAt(prefix, platform));
+};
+var finishWithThisNode = (entry) => finishWithUpgradeLock({ entry, args: [FINISH_UPGRADE_FLAG] });
+var finishGlobalUpgrade = async (subject, platform = process.platform, runFinish = finishWithThisNode) => {
+  const entry = globalUpgradeEntry(subject.prefix, subject.name, platform);
+  if (!existsSync(entry)) return { kind: "entry_missing", entry };
+  try {
+    await runFinish(entry);
+    return { kind: "finished" };
+  } catch {
+    return { kind: "failed" };
+  }
+};
+var describeHeldUpgradeLock = (holderPid) => `Another Pushary upgrade is already running${holderPid === void 0 ? "" : ` (pid ${holderPid})`}. Try again when it has finished.`;
+var withUpgradeLock = async (run, request = {}) => {
+  const claim = await claimUpgradeLock(request);
+  if (claim.kind === "unavailable") return { kind: "refused", exitCode: EXIT.FAILED, message: `Could not lock the Pushary upgrade: ${claim.reason}` };
+  if (claim.kind === "held") return { kind: "refused", exitCode: EXIT.FAILED, message: describeHeldUpgradeLock(claim.holderPid) };
+  try {
+    await run();
+  } finally {
+    releaseAutoUpdateLock(request.lockPath ?? autoUpdateLock());
+  }
+  return { kind: "ran" };
+};
+var finishUpgradeWithLock = async (run, request) => {
+  const outcome = await withUpgradeLock(run, request);
+  if (outcome.kind === "refused") {
+    updateAutoUpdateState(request.statePath, { lastResult: "finish_pending", to: request.installedVersion, detail: outcome.message });
+  }
+  return outcome;
+};
+var describeUpgradeStart = (subject, latest) => `Upgrading ${subject.name} ${subject.version} -> ${latest ?? "latest"}`;
+var upgradeInstalledPackage = async (subject, effects) => {
+  const pendingFinish = effects.hasPendingFinish(subject.version);
+  const latest = await effects.fetchLatest(subject.name);
+  const newerPublished = latest !== void 0 && isNewerVersion(latest, subject.version);
+  if (pendingFinish && !newerPublished) {
+    const finish = await effects.finish(subject);
+    if (finish.kind !== "finished") return { kind: "pending_finish_failed", finish };
+    effects.recordFinished();
+  }
+  if (latest !== void 0 && !newerPublished) return { kind: "current", version: subject.version };
+  effects.announce(describeUpgradeStart(subject, latest));
+  try {
+    effects.install(subject.name);
+  } catch (error) {
+    return { kind: "install_failed", detail: npmErrorMessage(error) };
+  }
+  return { kind: "installed", finish: await effects.finish(subject) };
+};
+
+export {
+  FINISH_UPGRADE_FLAG,
+  runAutoUpdate,
+  globalUpgradeSubject,
+  readGlobalUpgradeSubject,
+  finishGlobalUpgrade,
+  withUpgradeLock,
+  finishUpgradeWithLock,
+  upgradeInstalledPackage
+};

package/dist/{chunk-K75TP4JY.js → chunk-73BH4SZY.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-KZERVKTD.js";
 import {
   renderCommandHelp
-} from "./chunk-SDSKTRIV.js";
+} from "./chunk-ABIW72ST.js";
 import {
   getPackageVersion
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/cli/usage.ts
 var exitOnHelpFlag = (command) => {

package/dist/{chunk-SDSKTRIV.js → chunk-ABIW72ST.js}

@@ -1,6 +1,6 @@
 import {
   SETUP_AGENT_CHOICES
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/cli/commands.ts
 var NPX_LATEST_COMMAND = "npx pushary@latest";

package/dist/{chunk-HHNFGWR5.js → chunk-AL4NHBZ6.js}

@@ -1,7 +1,7 @@
 import {
   HOOK_BUDGETS,
   OPENCODE_APPROVAL_EVENT
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/opencode-plugin.ts
 var OPENCODE_PLUGIN_MARKER = "pushary-opencode-plugin w1";

package/dist/{chunk-YFS4HYCI.js → chunk-B6BLCHJW.js}

@@ -5,16 +5,16 @@ import {
 import {
   NOTIFICATION_MATCHED_TYPES,
   POSTTOOLUSE_MIRRORED_TOOLS
-} from "./chunk-VYNTRHB6.js";
+} from "./chunk-RTKPR4UA.js";
 import {
   isProtectedByScope,
   registerHookEntry
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   CLAUDE_PRETOOLUSE_MATCHER,
   HOOK_BUDGETS,
   HOOK_LOCATOR_BINARY
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/gemini-config.ts
 var GEMINI_HOOK_BINARY = "pushary-gemini-hook";

package/dist/{chunk-JOQEPWDH.js → chunk-BFVE3WPB.js}

@@ -3,11 +3,11 @@ import {
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-MGXXQHCM.js";
+} from "./chunk-U4DLXAGD.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
-} from "./chunk-HSM5FIA3.js";
+} from "./chunk-UX2YSFKS.js";
 
 // src/live-session.ts
 var MAX_TRANSCRIPT_QUEUE = 100;

package/dist/{chunk-IQUBCAEK.js → chunk-BK3R5NRE.js}

@@ -1,7 +1,7 @@
 import {
   HOOK_HOLD_BUDGET_ENV,
   hookHoldBudgetProof
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/hold-budget.ts
 var takeHookHoldBudget = (args = process.argv.slice(2), env = process.env) => {

package/dist/{chunk-ET6QSY3H.js → chunk-CEHDCHXK.js}

@@ -9,7 +9,7 @@ import {
   SETUP_CONNECT_MODES,
   isSetupConnectMode,
   isValidApiKey
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/setup/options.ts
 var AGENT_CHOICES = SETUP_AGENT_CHOICES;

package/dist/{chunk-P25O4K3J.js → chunk-COVPHB56.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-POFBE6ZY.js";
 import {
   autoUpdateState
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   readJsonSafe,
   writeJsonAtomic
@@ -14,13 +14,14 @@ import {
   cliPackagePathSegments,
   globalUpgradeEntry,
   ownPackageRoot
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/auto-update.ts
 import { spawn } from "child_process";
 import { dirname } from "path";
 var AUTO_UPDATE_DISABLE_ENV = "PUSHARY_DISABLE_AUTOUPDATE";
 var AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var PENDING_FINISH_RETRY_MS = 5 * 60 * 1e3;
 var AUTO_UPDATE_FLAG = "--auto";
 var NON_GLOBAL_INSTALL_SEGMENTS = ["/_npx/", "/.volta/"];
 var AUTO_UPDATE_RESULTS = ["updated", "current", "needs_manual", "failed", "finish_pending"];
@@ -75,11 +76,11 @@ var globalInstallLocation = (packageRoot) => {
   return null;
 };
 var upgradeEntryFor = (location, platform = process.platform) => globalUpgradeEntry(location.prefix, location.packageName, platform);
-var checkedWithinInterval = (lastCheckAt, now) => {
+var checkedWithinInterval = (lastCheckAt, now, interval) => {
   const last = lastCheckAt === void 0 ? Number.NaN : Date.parse(lastCheckAt);
   if (Number.isNaN(last)) return false;
   const elapsed = now - last;
-  return elapsed >= 0 && elapsed < AUTO_UPDATE_INTERVAL_MS;
+  return elapsed >= 0 && elapsed < interval;
 };
 var autoUpdateDecision = (input) => {
   if (input.isSubagentStart) return { kind: "skip", reason: "subagent_start" };
@@ -87,7 +88,8 @@ var autoUpdateDecision = (input) => {
   if (offReason !== null) return { kind: "skip", reason: offReason };
   const location = input.packageRoot === void 0 ? null : globalInstallLocation(input.packageRoot);
   if (location === null) return { kind: "skip", reason: "not_global_install" };
-  if (checkedWithinInterval(input.state.lastCheckAt, input.now)) return { kind: "skip", reason: "checked_recently" };
+  const interval = input.state.lastResult === "finish_pending" ? PENDING_FINISH_RETRY_MS : AUTO_UPDATE_INTERVAL_MS;
+  if (checkedWithinInterval(input.state.lastCheckAt, input.now, interval)) return { kind: "skip", reason: "checked_recently" };
   return { kind: "check", ...location };
 };
 var parseAutoUpdateFlag = (args) => {

package/dist/{chunk-MBVV3RX3.js → chunk-CTYCABBH.js}

@@ -1,6 +1,6 @@
 import {
   readTranscriptPreference
-} from "./chunk-ZRHA4PGN.js";
+} from "./chunk-ZNUNWWCN.js";
 
 // src/transcript-setting.ts
 var transcriptEnvironmentPreference = () => {

package/dist/{chunk-RZXQFAWR.js → chunk-DKDZXJHZ.js}

@@ -1,6 +1,6 @@
 import {
   guardBinary
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 
 // src/bell/install.ts
 import { join } from "path";

package/dist/chunk-EO23EUOK.js

@@ -0,0 +1,14 @@
+// src/cli/json.ts
+var writeStdoutFully = (text) => new Promise((resolve, reject) => {
+  const settle = (error) => {
+    if (!error) process.stdout.off("error", settle);
+    if (error && (!("code" in error) || error.code !== "EPIPE")) reject(error);
+    else resolve();
+  };
+  process.stdout.once("error", settle);
+  process.stdout.write(text, settle);
+});
+
+export {
+  writeStdoutFully
+};

package/dist/{chunk-CKPDSFY3.js → chunk-ESME4HN2.js}

@@ -3,28 +3,28 @@ import {
   addPusharyToolPermissions,
   isPusharyHook,
   removeClaudeMcpServers
-} from "./chunk-MQJWO3AA.js";
+} from "./chunk-FHLRRCUZ.js";
 import {
   CLAUDE_HOOK_EVENTS,
   addGeminiMcpServer,
   removeGeminiMcpServer
-} from "./chunk-YFS4HYCI.js";
+} from "./chunk-B6BLCHJW.js";
 import {
   CLAUDE_CODE_AGENT,
   parseApplyPatchFiles
-} from "./chunk-42E4DE6C.js";
+} from "./chunk-35N53QLA.js";
 import {
   guardBinary,
   holdBudgetOf,
   registerHookEntry
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   PHONE_ANSWERED_TOOLS,
   hookCompatibleProfile,
   hookCompatibleProfileBySource,
   toToolLookup,
   withHookHoldBudget
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/compatible-config.ts
 import { homedir } from "os";

package/dist/{chunk-NAJ3UV4E.js → chunk-EUNYNLDU.js}

@@ -2,17 +2,17 @@ import {
   CLAUDE_HOOK_EVENTS,
   GEMINI_HOOK_EVENTS,
   hasGeminiHooks
-} from "./chunk-YFS4HYCI.js";
+} from "./chunk-B6BLCHJW.js";
 import {
   CODEX_HOOK_EVENTS,
   hasCodexHooks,
   holdBudgetOf
-} from "./chunk-R76C43H7.js";
+} from "./chunk-HZ57E6LS.js";
 import {
   CURSOR_GATE_EVENTS,
   HOOK_LOCATOR_BINARY,
   hookCommandHoldBudget
-} from "./chunk-4PCF34AB.js";
+} from "./chunk-ZFDGCEKO.js";
 
 // src/diagnostics/wiring.ts
 var record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;