@pushary/agent-hooks 0.83.2 → 0.84.1

package/dist/{chunk-7PO2VEA4.js → chunk-CCCJ6BPW.js}

@@ -1,3 +1,6 @@
+import {
+  getMachineId
+} from "./chunk-RN3NOEJF.js";
 import {
   callMcpTool,
   withRetry
@@ -7,7 +10,11 @@ import {
 } from "./chunk-SAF6HGAA.js";
 import {
   reportedInstallSource
-} from "./chunk-SAA3VBDK.js";
+} from "./chunk-437T77TY.js";
+import {
+  getApiKey,
+  getBaseUrl
+} from "./chunk-2UMNXADU.js";
 import {
   ACTION_BODY_MAX,
   DECISION_LINE_MAX,
@@ -23,14 +30,7 @@ import {
   redactSecrets,
   redactSecretsDeep,
   selectGoverningRule
-} from "./chunk-YWRJGYUH.js";
-import {
-  getMachineId
-} from "./chunk-RN3NOEJF.js";
-import {
-  getApiKey,
-  getBaseUrl
-} from "./chunk-2UMNXADU.js";
+} from "./chunk-MQMPG5X4.js";
 
 // src/policy.ts
 import { createHash } from "crypto";
@@ -60,19 +60,21 @@ var CACHE_TTL_MS = 60 * 1e3;
 var STALE_CACHE_MAX_MS = 12 * 60 * 60 * 1e3;
 var policyRequestFor = (agentType) => ({
   agent: agentType,
-  repoAware: agentType === "claude_code"
+  repoAware: ["claude_code", "codex", "gemini_cli"].includes(agentType)
 });
 var policyCacheFile = (apiKey, agent, repoAware = false) => {
   const parts = [apiKey, agent, repoAware ? "repoAware" : void 0].filter(Boolean);
   const hash = createHash("sha256").update(parts.join(":")).digest("hex").slice(0, 12);
   return join(tmpdir(), `pushary-policy-${hash}.json`);
 };
-var fetchPolicy = async (apiKey, agent, repoAware = false) => {
+var fetchPolicy = async (apiKey, agent, repoAware = false, sessionId) => {
   return withRetry(async () => {
     const baseUrl = getBaseUrl();
     const params = new URLSearchParams();
     if (agent) params.set("agent", agent);
     if (repoAware) params.set("repoAware", "1");
+    params.set("scopeAware", "1");
+    if (sessionId) params.set("sessionId", sessionId);
     const query = params.toString();
     const url = query ? `${baseUrl}/api/mcp/policy?${query}` : `${baseUrl}/api/mcp/policy`;
     const response = await fetch(url, {
@@ -87,7 +89,7 @@ var fetchPolicy = async (apiKey, agent, repoAware = false) => {
     return raw;
   }, { maxAttempts: 2 });
 };
-var getPolicy = async (apiKey, expectedVersion, agent, repoAware = false) => {
+var getPolicy = async (apiKey, expectedVersion, agent, repoAware = false, sessionId) => {
   const path = policyCacheFile(apiKey, agent, repoAware);
   let staleCache = null;
   if (existsSync(path)) {
@@ -96,19 +98,20 @@ var getPolicy = async (apiKey, expectedVersion, agent, repoAware = false) => {
       const cached = JSON.parse(stat);
       if (!isPolicyConfig(cached)) throw new Error("Corrupted cache");
       const versionStale = expectedVersion != null && (cached._policyVersion ?? null) !== expectedVersion;
+      const sessionStale = (cached._sessionId ?? null) !== (sessionId ?? null);
       const age = cached._cachedAt ? Date.now() - cached._cachedAt : 0;
       const ttlFresh = !cached._cachedAt || age < CACHE_TTL_MS;
-      if (ttlFresh && !versionStale) {
+      if (ttlFresh && !versionStale && !sessionStale) {
         return cached;
       }
-      if (age < STALE_CACHE_MAX_MS) staleCache = cached;
+      if (!sessionStale && age < STALE_CACHE_MAX_MS) staleCache = cached;
     } catch {
     }
   }
   try {
-    const policy = await fetchPolicy(apiKey, agent, repoAware);
+    const policy = await fetchPolicy(apiKey, agent, repoAware, sessionId);
     try {
-      writeFileSync(path, JSON.stringify({ ...policy, _cachedAt: Date.now(), _policyVersion: expectedVersion ?? null }), { encoding: "utf-8", mode: 384 });
+      writeFileSync(path, JSON.stringify({ ...policy, _cachedAt: Date.now(), _policyVersion: expectedVersion ?? null, _sessionId: sessionId ?? null }), { encoding: "utf-8", mode: 384 });
     } catch {
     }
     return policy;
@@ -124,20 +127,20 @@ var autoApprove = (tool) => ({
   mode: "terminal_only",
   pushFirstSeconds: 0
 });
-var resolveAutoResolveOrigin = (config, toolName, toolInput, cwd, repoKey) => {
+var resolveAutoResolveOrigin = (config, toolName, toolInput, cwd, repoKey, sessionId) => {
   const args = toolInput ? policyArgForms(toolName, toolInput, cwd) : [];
   const arg = args[0];
-  const match = selectGoverningRule(config.policies, toolName, args, repoKey);
+  const match = selectGoverningRule(config.policies, toolName, args, repoKey, sessionId);
   const governedBySpecificRule = match?.rank === "exact" || match?.rank === "prefix";
   if (!governedBySpecificRule && toolName === "Bash" && typeof arg === "string" && isSafeReadOnlyCommand(arg)) {
     return "safe_readonly";
   }
   return "policy_timeout";
 };
-var resolvePolicy = (config, toolName, modeOverride, toolInput, cwd, repoKey) => {
+var resolvePolicy = (config, toolName, modeOverride, toolInput, cwd, repoKey, sessionId) => {
   const args = toolInput ? policyArgForms(toolName, toolInput, cwd) : [];
   const arg = args[0];
-  const match = selectGoverningRule(config.policies, toolName, args, repoKey);
+  const match = selectGoverningRule(config.policies, toolName, args, repoKey, sessionId);
   let base = match?.policy ?? config.policies.find((p) => p.tool === "*") ?? {
     tool: toolName,
     timeoutSeconds: config.defaultTimeoutSeconds,
@@ -172,9 +175,9 @@ var restraintRank = (policy) => {
   return policy.mode === "terminal_only" || policy.mode === "notify_only" ? 1 : 2;
 };
 var strictestPolicy = (a, b) => restraintRank(b) > restraintRank(a) ? b : a;
-var resolvePolicyAcross = (config, toolName, modeOverride, toolInputs, cwd, repoKey) => {
-  if (toolInputs.length === 0) return resolvePolicy(config, toolName, modeOverride, void 0, cwd, repoKey);
-  return toolInputs.map((input) => resolvePolicy(config, toolName, modeOverride, input, cwd, repoKey)).reduce(strictestPolicy);
+var resolvePolicyAcross = (config, toolName, modeOverride, toolInputs, cwd, repoKey, sessionId) => {
+  if (toolInputs.length === 0) return resolvePolicy(config, toolName, modeOverride, void 0, cwd, repoKey, sessionId);
+  return toolInputs.map((input) => resolvePolicy(config, toolName, modeOverride, input, cwd, repoKey, sessionId)).reduce(strictestPolicy);
 };
 var isModeStateDegraded = (state) => state?.degraded === true;
 var MODE_GRACE_MS = 60 * 1e3;
@@ -930,12 +933,13 @@ var notifyLateAnswers = async (apiKey, late, agentName, sessionId) => {
 };
 var CLAUDE_CODE_AGENT = { type: "claude_code", label: "Claude Code" };
 var POLICY_CACHE_TTL_MS = 5 * 60 * 1e3;
-var readFreshCachedPolicy = (apiKey, agentType) => {
+var readFreshCachedPolicy = (apiKey, agentType, sessionId) => {
   const request = policyRequestFor(agentType);
   const path = policyCacheFile(apiKey, request.agent, request.repoAware);
   if (!existsSync5(path)) return null;
   const cached = JSON.parse(readFileSync4(path, "utf-8"));
   if (!isPolicyConfig(cached)) return null;
+  if ((cached._sessionId ?? null) !== (sessionId ?? null)) return null;
   if (!cached._cachedAt || Date.now() - cached._cachedAt >= POLICY_CACHE_TTL_MS) return null;
   return cached;
 };
@@ -943,13 +947,13 @@ var autoDecisionEnabled = () => {
   const flag = process.env.PUSHARY_AUTO_DECISION_BEACON;
   return flag === "1" || flag === "true";
 };
-var deriveDecisionSource = (toolName, toolInput, liveMode, agentType, cwd) => {
+var deriveDecisionSource = (toolName, toolInput, liveMode, agentType, cwd, sessionId) => {
   try {
     if (liveMode.kill) return "terminal";
     if (!autoDecisionEnabled()) return void 0;
-    const policy = readFreshCachedPolicy(getApiKey(), agentType);
+    const policy = readFreshCachedPolicy(getApiKey(), agentType, sessionId);
     if (!policy) return void 0;
-    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput, cwd, repoKeyFor(cwd));
+    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput, cwd, repoKeyFor(cwd), sessionId);
     if (isAutoApprove(resolved)) return "policy_auto";
     if (resolved.mode === "push_only" || resolved.mode === "push_first") return "human";
     return "terminal";
@@ -957,16 +961,16 @@ var deriveDecisionSource = (toolName, toolInput, liveMode, agentType, cwd) => {
     return void 0;
   }
 };
-var deriveAutoDecisionBeacon = (toolName, toolInput, liveMode, agentType, cwd) => {
+var deriveAutoDecisionBeacon = (toolName, toolInput, liveMode, agentType, cwd, sessionId) => {
   try {
     if (liveMode.kill) return void 0;
     if (!autoDecisionEnabled()) return void 0;
-    const policy = readFreshCachedPolicy(getApiKey(), agentType);
+    const policy = readFreshCachedPolicy(getApiKey(), agentType, sessionId);
     if (!policy) return void 0;
-    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput, cwd, repoKeyFor(cwd));
+    const resolved = resolvePolicy(policy, toolName, liveMode.mode, toolInput, cwd, repoKeyFor(cwd), sessionId);
     if (resolved.timeoutSeconds !== 0 || resolved.timeoutAction !== "approve") return void 0;
     return {
-      decisionOrigin: resolveAutoResolveOrigin(policy, toolName, toolInput, cwd, repoKeyFor(cwd)),
+      decisionOrigin: resolveAutoResolveOrigin(policy, toolName, toolInput, cwd, repoKeyFor(cwd), sessionId),
       toolName,
       toolTarget: deriveToolTarget(toolName, toolInput)
     };
@@ -1009,7 +1013,7 @@ var reportEvent = async (event, options = {}) => {
         machineId: event.machineId ?? getMachineId(),
         // Lets the phone's Stop end this process instead of only denying its next
         // tool call. Ours alone: never another process, never a parent.
-        pid: event.pid ?? process.pid,
+        pid: event.pid,
         repoKey: event.repoKey ?? repoKeyFor(),
         installMode: detectInstallMode(),
         // How the binary was INVOKED this time and which front door produced the
@@ -1031,6 +1035,7 @@ var reportEvent = async (event, options = {}) => {
       }),
       signal: AbortSignal.timeout(options.timeoutMs ?? 1e4)
     });
+    if (options.requireOk && !res.ok) throw new Error(`/api/agent/event rejected (${res.status})`);
     try {
       return await res.json();
     } catch {
@@ -1056,8 +1061,8 @@ var handlePostToolUse = async (input, agent = CLAUDE_CODE_AGENT) => {
       for (const l of late) removePendingQuestion(sessionKey, l.correlationId);
     }
     const isMirrorOnly = NON_GATED_MIRROR_TOOLS.has(input.tool_name);
-    const decisionSource = isMirrorOnly ? void 0 : deriveDecisionSource(lookup.tool, lookup.input, liveMode, agent.type, input.cwd);
-    const beacon = !isMirrorOnly && decisionSource === "policy_auto" && throttlePass(`autodecision:${sessionKey}:${lookup.tool}`, AUTO_DECISION_WINDOW_MS) ? deriveAutoDecisionBeacon(lookup.tool, lookup.input, liveMode, agent.type, input.cwd) : void 0;
+    const decisionSource = isMirrorOnly ? void 0 : deriveDecisionSource(lookup.tool, lookup.input, liveMode, agent.type, input.cwd, input.session_id);
+    const beacon = !isMirrorOnly && decisionSource === "policy_auto" && throttlePass(`autodecision:${sessionKey}:${lookup.tool}`, AUTO_DECISION_WINDOW_MS) ? deriveAutoDecisionBeacon(lookup.tool, lookup.input, liveMode, agent.type, input.cwd, input.session_id) : void 0;
     const toolReport = reportEvent({
       event: isError ? "tool_error" : "tool_complete",
       agentType: agent.type,
@@ -1313,6 +1318,7 @@ var handleStopFailure = async (input, agent = CLAUDE_CODE_AGENT) => {
 };
 
 export {
+  policyRequestFor,
   getPolicy,
   resolveAutoResolveOrigin,
   resolvePolicy,

package/dist/chunk-CCH775Y6.js

@@ -0,0 +1,343 @@
+import {
+  needsShell,
+  spawnClaude
+} from "./chunk-XHKBHWLX.js";
+import {
+  resolveGlobalBinary
+} from "./chunk-VT4IVERX.js";
+import {
+  pusharyDir
+} from "./chunk-SEAHGHCE.js";
+import {
+  getMachineId
+} from "./chunk-RN3NOEJF.js";
+import {
+  getPackageVersion
+} from "./chunk-DINDL2CF.js";
+import {
+  readJsonSafe,
+  writeJsonAtomic
+} from "./chunk-6MTNS63X.js";
+import {
+  getApiKey
+} from "./chunk-2UMNXADU.js";
+
+// src/daemon-lifecycle.ts
+import { dirname, join } from "path";
+import { existsSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
+import { createHash, randomUUID } from "crypto";
+var daemonNeedsHandoff = (status) => status.kind === "version-mismatch" || status.kind === "configuration-mismatch" || status.kind === "unresponsive" && status.processAlive === true;
+var statePath = (dir) => join(dir, "daemon-state.json");
+var lockPath = (dir) => join(dir, "daemon.lock");
+var targetPath = (dir) => join(dir, "daemon-target.json");
+var DAEMON_LEASE_RENEW_INTERVAL_MS = 3e4;
+var LOCAL_LEASE_TIMEOUT_MS = DAEMON_LEASE_RENEW_INTERVAL_MS * 3;
+var buildDaemonLaunch = (input) => input.siblingEntry ? { command: input.execPath, args: [input.siblingEntry], shell: false } : {
+  command: input.daemonBinary,
+  args: [],
+  shell: needsShell(input.daemonBinary, input.platform ?? process.platform)
+};
+var spawnDetachedDaemon = (plan, options = {}) => {
+  const spawnImpl = options.spawnImpl ?? spawnClaude;
+  const child = spawnImpl(plan.command, plan.args, {
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true,
+    shell: plan.shell
+  });
+  child.once?.("error", () => {
+  });
+  child.unref();
+  return typeof child.pid === "number" ? child.pid : null;
+};
+var processIsAlive = (pid) => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+};
+var isString = (value) => typeof value === "string" && value.length > 0;
+var isTimestamp = (value) => isString(value) && Number.isFinite(Date.parse(value));
+var currentConfigurationId = () => {
+  try {
+    return createHash("sha256").update(getApiKey()).digest("hex").slice(0, 16);
+  } catch {
+    return null;
+  }
+};
+var parseDaemonState = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const state = value;
+  if (!isString(state.instanceId) || !Number.isInteger(state.pid) || state.pid <= 0 || !isString(state.version) || !(state.configurationId === void 0 || state.configurationId === null || isString(state.configurationId)) || !isString(state.machineId) || !isTimestamp(state.startedAt) || !isTimestamp(state.updatedAt) || !(state.lastSuccessfulHeartbeatAt === null || isTimestamp(state.lastSuccessfulHeartbeatAt))) return null;
+  return {
+    instanceId: state.instanceId,
+    pid: state.pid,
+    version: state.version,
+    configurationId: state.configurationId ?? null,
+    machineId: state.machineId,
+    startedAt: state.startedAt,
+    updatedAt: state.updatedAt,
+    lastSuccessfulHeartbeatAt: state.lastSuccessfulHeartbeatAt
+  };
+};
+var parseLockOwner = (value) => {
+  if (typeof value !== "object" || value === null) return null;
+  const owner = value;
+  return isString(owner.instanceId) && Number.isInteger(owner.pid) && owner.pid > 0 ? { instanceId: owner.instanceId, pid: owner.pid } : null;
+};
+var readDaemonStatus = (options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const installedVersion = options.installedVersion ?? getPackageVersion();
+  const state = readJsonSafe(statePath(dir));
+  if (state.kind === "missing") {
+    return {
+      kind: "absent",
+      installedVersion,
+      machineId: null,
+      pid: null,
+      processAlive: null,
+      daemonVersion: null,
+      startedAt: null,
+      updatedAt: null,
+      lastSuccessfulHeartbeatAt: null
+    };
+  }
+  const value = state.kind === "ok" ? parseDaemonState(state.value) : null;
+  if (value) {
+    const alive = (options.isProcessAlive ?? processIsAlive)(value.pid);
+    const fresh = (options.now ?? Date.now)() - Date.parse(value.updatedAt) <= LOCAL_LEASE_TIMEOUT_MS;
+    const expectedConfigurationId = options.configurationId === void 0 ? currentConfigurationId() : options.configurationId;
+    return {
+      kind: !alive || !fresh ? "unresponsive" : value.version !== installedVersion ? "version-mismatch" : expectedConfigurationId !== null && value.configurationId !== null && value.configurationId !== expectedConfigurationId ? "configuration-mismatch" : "running",
+      installedVersion,
+      machineId: value.machineId,
+      pid: value.pid,
+      processAlive: alive,
+      daemonVersion: value.version,
+      startedAt: value.startedAt,
+      updatedAt: value.updatedAt,
+      lastSuccessfulHeartbeatAt: value.lastSuccessfulHeartbeatAt
+    };
+  }
+  return {
+    kind: "invalid",
+    installedVersion,
+    machineId: null,
+    pid: null,
+    processAlive: null,
+    daemonVersion: null,
+    startedAt: null,
+    updatedAt: null,
+    lastSuccessfulHeartbeatAt: null
+  };
+};
+var safeUnlink = (path) => {
+  try {
+    unlinkSync(path);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+};
+var requestDaemonVersion = (version, options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const now = options.now ?? Date.now;
+  writeJsonAtomic(targetPath(dir), { version, requestedAt: new Date(now()).toISOString() }, 384);
+};
+var acquireDaemonLease = (options = {}) => {
+  const dir = options.dir ?? pusharyDir();
+  const installedVersion = options.installedVersion ?? getPackageVersion();
+  const machineId = options.machineId ?? getMachineId();
+  const pid = options.pid ?? process.pid;
+  const now = options.now ?? Date.now;
+  const instanceId = randomUUID();
+  const startedAt = new Date(now()).toISOString();
+  const writeLock = () => {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(lockPath(dir), JSON.stringify({ instanceId, pid }), { flag: "wx", mode: 384 });
+  };
+  try {
+    writeLock();
+  } catch (err) {
+    if (err.code !== "EEXIST") {
+      return { kind: "unavailable", detail: err instanceof Error ? err.message : String(err) };
+    }
+    const status = readDaemonStatus(options);
+    if (status.kind === "running" || status.kind === "version-mismatch" || status.kind === "configuration-mismatch") {
+      return { kind: "already-running", status };
+    }
+    const lock = readJsonSafe(lockPath(dir));
+    const owner = lock.kind === "ok" ? parseLockOwner(lock.value) : null;
+    if (!owner) return { kind: "unavailable", detail: "daemon lock is invalid" };
+    if ((options.isProcessAlive ?? processIsAlive)(owner.pid)) {
+      return { kind: "unavailable", detail: "daemon owner is still running or starting" };
+    }
+    const stale = join(dir, `daemon.lock.${instanceId}.stale`);
+    let ownsReplacement = false;
+    try {
+      renameSync(lockPath(dir), stale);
+      writeLock();
+      ownsReplacement = true;
+      safeUnlink(statePath(dir));
+      safeUnlink(stale);
+    } catch (retryError) {
+      if (ownsReplacement) safeUnlink(lockPath(dir));
+      try {
+        safeUnlink(stale);
+      } catch {
+      }
+      return { kind: "unavailable", detail: retryError instanceof Error ? retryError.message : String(retryError) };
+    }
+  }
+  const state = {
+    instanceId,
+    pid,
+    version: installedVersion,
+    configurationId: options.configurationId === void 0 ? currentConfigurationId() : options.configurationId,
+    machineId,
+    startedAt,
+    updatedAt: startedAt,
+    lastSuccessfulHeartbeatAt: null
+  };
+  try {
+    writeJsonAtomic(statePath(dir), state, 384);
+  } catch (err) {
+    safeUnlink(lockPath(dir));
+    return { kind: "unavailable", detail: err instanceof Error ? err.message : String(err) };
+  }
+  let currentState = state;
+  const isOwner = () => {
+    const owner = readJsonSafe(lockPath(dir));
+    return owner.kind === "ok" && owner.value.instanceId === instanceId;
+  };
+  const updateState = (next) => {
+    if (!isOwner()) return;
+    try {
+      writeJsonAtomic(statePath(dir), next, 384);
+      currentState = next;
+    } catch {
+    }
+  };
+  return {
+    kind: "acquired",
+    lease: {
+      isOwner,
+      renew: (at = now()) => {
+        updateState({ ...currentState, updatedAt: new Date(at).toISOString() });
+      },
+      recordSuccessfulHeartbeat: (at = now()) => {
+        const timestamp = new Date(at).toISOString();
+        updateState({
+          ...currentState,
+          updatedAt: timestamp,
+          lastSuccessfulHeartbeatAt: timestamp
+        });
+      },
+      shouldYield: () => {
+        if (!isOwner()) return true;
+        const target = readJsonSafe(targetPath(dir));
+        return target.kind === "ok" && (typeof target.value.version === "string" && target.value.version !== installedVersion || isTimestamp(target.value.requestedAt) && Date.parse(target.value.requestedAt) > Date.parse(startedAt));
+      },
+      release: () => {
+        if (!isOwner()) return;
+        safeUnlink(statePath(dir));
+        safeUnlink(lockPath(dir));
+      }
+    }
+  };
+};
+var hasConfiguration = () => {
+  try {
+    getApiKey();
+    return true;
+  } catch {
+    return false;
+  }
+};
+var wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var requestDaemonHandoff = async (initial, options = {}) => {
+  const now = options.now ?? Date.now;
+  const requestedAt = Math.max(
+    now(),
+    initial.startedAt === null ? 0 : Date.parse(initial.startedAt) + 1
+  );
+  requestDaemonVersion(options.installedVersion ?? initial.installedVersion, {
+    dir: options.dir,
+    now: () => requestedAt
+  });
+  if (initial.pid === null || initial.processAlive !== true) return initial;
+  const sleep = options.sleep ?? wait;
+  const pollIntervalMs = options.pollIntervalMs ?? 50;
+  const attempts = Math.max(1, Math.ceil((options.waitTimeoutMs ?? 5e3) / pollIntervalMs));
+  let status = initial;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    await sleep(pollIntervalMs);
+    status = readDaemonStatus(options);
+    if (status.pid !== initial.pid || status.processAlive !== true) break;
+  }
+  return status;
+};
+var launchInstalledDaemon = (options) => {
+  const entryExists = options.entryExists ?? existsSync;
+  const argvEntry = process.argv[1];
+  const candidate = options.daemonEntry !== void 0 ? options.daemonEntry : argvEntry ? join(dirname(argvEntry), "pushary-daemon.js") : null;
+  const siblingEntry = candidate && entryExists(candidate) ? candidate : null;
+  const platform = options.platform ?? process.platform;
+  const daemonBinary = options.daemonBinary ?? resolveGlobalBinary("pushary-daemon") ?? (platform === "win32" ? "pushary-daemon.cmd" : "pushary-daemon");
+  const plan = buildDaemonLaunch({
+    siblingEntry,
+    execPath: options.execPath ?? process.execPath,
+    daemonBinary,
+    platform
+  });
+  spawnDetachedDaemon(plan, { spawnImpl: options.spawnImpl });
+};
+var ensureDaemonRunning = async (options = {}) => {
+  const initial = readDaemonStatus(options);
+  if (!(options.configured ?? hasConfiguration)()) {
+    return { kind: "not-configured", status: initial, detail: "Pushary is not configured on this machine" };
+  }
+  if (initial.kind === "running") return { kind: "running", status: initial };
+  let handoffStatus;
+  try {
+    handoffStatus = await requestDaemonHandoff(initial, options);
+  } catch (err) {
+    return {
+      kind: "unavailable",
+      status: initial,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+  const sleep = options.sleep ?? wait;
+  const pollIntervalMs = options.pollIntervalMs ?? 50;
+  const attempts = Math.max(1, Math.ceil((options.waitTimeoutMs ?? 5e3) / pollIntervalMs));
+  if (handoffStatus.kind === "running") return { kind: "running", status: handoffStatus };
+  if (daemonNeedsHandoff(handoffStatus)) {
+    return { kind: "unavailable", status: handoffStatus, detail: "unhealthy daemon did not yield" };
+  }
+  try {
+    (options.spawnDaemon ?? (() => launchInstalledDaemon(options)))();
+  } catch (err) {
+    return {
+      kind: "unavailable",
+      status: initial,
+      detail: err instanceof Error ? err.message : String(err)
+    };
+  }
+  let status = initial;
+  for (let attempt = 0; attempt < attempts; attempt++) {
+    status = readDaemonStatus(options);
+    if (status.kind === "running") return { kind: "started", status };
+    await sleep(pollIntervalMs);
+  }
+  return { kind: "unavailable", status, detail: `daemon did not become healthy (${status.kind})` };
+};
+
+export {
+  DAEMON_LEASE_RENEW_INTERVAL_MS,
+  readDaemonStatus,
+  acquireDaemonLease,
+  requestDaemonHandoff,
+  ensureDaemonRunning
+};

package/dist/chunk-DINDL2CF.js

@@ -0,0 +1,45 @@
+// src/cli/version.ts
+import { readFileSync } from "fs";
+import { dirname, join, parse } from "path";
+import { fileURLToPath } from "url";
+var PACKAGE_NAME = "@pushary/agent-hooks";
+var findOwnPackageJson = (start) => {
+  const { root } = parse(start);
+  let dir = start;
+  while (true) {
+    const candidate = join(dir, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+      if (pkg.name === PACKAGE_NAME) return candidate;
+    } catch {
+    }
+    if (dir === root) return void 0;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+};
+var getPackageVersion = () => {
+  try {
+    const found = findOwnPackageJson(dirname(fileURLToPath(import.meta.url)));
+    if (!found) return "0.0.0";
+    const pkg = JSON.parse(readFileSync(found, "utf-8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+};
+var isNewerVersion = (candidate, current) => {
+  const a = candidate.split(".").map((part) => parseInt(part, 10) || 0);
+  const b = current.split(".").map((part) => parseInt(part, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+};
+
+export {
+  getPackageVersion,
+  isNewerVersion
+};

package/dist/{chunk-TXF4QZSQ.js → chunk-DOXSWT4Q.js}

@@ -1,6 +1,6 @@
 import {
   HOOK_BUDGETS
-} from "./chunk-YWRJGYUH.js";
+} from "./chunk-MQMPG5X4.js";
 
 // src/gemini-config.ts
 var GEMINI_HOOK_BINARY = "pushary-gemini-hook";