@pushary/agent-hooks 1.4.2 → 1.5.1

package/dist/{chunk-EQRS3SGM.js → chunk-66H2QQAK.js}

@@ -1,6 +1,6 @@
 import {
   getBaseUrl
-} from "./chunk-2UMNXADU.js";
+} from "./chunk-OSJEMXSR.js";
 
 // src/transcript-api.ts
 var fetchTranscriptRecipients = async (apiKey, baseUrl = getBaseUrl()) => {

package/dist/chunk-6EEANS74.js

@@ -0,0 +1,300 @@
+import {
+  spawnClaude
+} from "./chunk-XHKBHWLX.js";
+import {
+  codexHome,
+  codexHooksJsonIn,
+  isPusharyCodexCommand,
+  resolvePathBinary
+} from "./chunk-6IU45EHE.js";
+import {
+  getPackageVersion
+} from "./chunk-HWJW3CPO.js";
+
+// src/codex-app-server.ts
+import { existsSync, realpathSync } from "fs";
+import { join } from "path";
+var CODEX_HOOK_STATUS = {
+  trusted: "trusted",
+  untrusted: "untrusted",
+  modified: "modified",
+  managed: "managed",
+  disabled: "disabled",
+  notListed: "not listed"
+};
+var CODEX_APP_SERVER_ARGS = ["app-server"];
+var CODEX_APP_SERVER_TIMEOUT_MS = 1e4;
+var TERMINATE_GRACE_MS = 1e3;
+var MAX_RPC_LINE = 4 * 1024 * 1024;
+var STDERR_TAIL_LIMIT = 400;
+var PUSHARY_CLIENT_NAME = "pushary";
+var METHOD_INITIALIZE = "initialize";
+var METHOD_INITIALIZED = "initialized";
+var METHOD_HOOKS_LIST = "hooks/list";
+var METHOD_CONFIG_BATCH_WRITE = "config/batchWrite";
+var HOOKS_STATE_KEY_PATH = "hooks.state";
+var CODEX_INSTALLATION_ID_FILE = "installation_id";
+var CODEX_NOT_ASKED = {
+  notInteractive: "Pushary only starts Codex when you run setup, upgrade or doctor yourself at a terminal",
+  noCodexOnPath: "there is no codex command on PATH",
+  neverOpened: "Codex has not been opened on this machine yet"
+};
+var UNRECOGNISED_LISTING = "Codex answered hooks/list in a shape Pushary does not recognise";
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isCodexListedHook = (value) => isRecord(value) && typeof value.key === "string" && typeof value.eventName === "string" && typeof value.command === "string" && typeof value.sourcePath === "string" && typeof value.enabled === "boolean" && typeof value.isManaged === "boolean" && typeof value.currentHash === "string" && typeof value.trustStatus === "string";
+var listedHookFields = (hook) => ({
+  key: hook.key,
+  eventName: hook.eventName,
+  command: hook.command,
+  sourcePath: hook.sourcePath,
+  enabled: hook.enabled,
+  isManaged: hook.isManaged,
+  currentHash: hook.currentHash,
+  trustStatus: hook.trustStatus
+});
+var diagnosticMessages = (value) => {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) => {
+    if (typeof entry === "string") return [entry];
+    if (isRecord(entry) && typeof entry.message === "string") return [entry.message];
+    return [];
+  });
+};
+var hooksListingOf = (result) => {
+  if (!isRecord(result) || !Array.isArray(result.data)) return null;
+  const hooks = [];
+  const warnings = [];
+  for (const layer of result.data) {
+    if (!isRecord(layer) || !Array.isArray(layer.hooks)) return null;
+    hooks.push(...layer.hooks.filter(isCodexListedHook).map(listedHookFields));
+    warnings.push(...diagnosticMessages(layer.warnings), ...diagnosticMessages(layer.errors));
+  }
+  return { hooks, warnings };
+};
+var isPusharyHookIn = (hooksJsonPath, hook) => hook.sourcePath === hooksJsonPath && isPusharyCodexCommand(hook.command);
+var isTrustableByPushary = (hook) => hook.enabled && !hook.isManaged && hook.trustStatus !== CODEX_HOOK_STATUS.managed;
+var pusharyHooksIn = (hooks, hooksJsonPath) => hooks.filter((hook) => isPusharyHookIn(hooksJsonPath, hook));
+var selectPusharyCodexHooks = (hooks, hooksJsonPath) => pusharyHooksIn(hooks, hooksJsonPath).filter(isTrustableByPushary);
+var codexTrustVerdict = (hooks, hooksJsonPath) => {
+  if (pusharyHooksIn(hooks, hooksJsonPath).length === 0) return { kind: "unlisted" };
+  const untrusted = selectPusharyCodexHooks(hooks, hooksJsonPath).filter((hook) => hook.trustStatus !== CODEX_HOOK_STATUS.trusted);
+  return untrusted.length === 0 ? { kind: "trusted" } : { kind: "untrusted", hooks: untrusted };
+};
+var codexTrustEdit = (hooks) => ({
+  edits: [{
+    keyPath: HOOKS_STATE_KEY_PATH,
+    mergeStrategy: "upsert",
+    value: Object.fromEntries(hooks.map((hook) => [hook.key, { trusted_hash: hook.currentHash }]))
+  }],
+  reloadUserConfig: true
+});
+var initializeParams = (clientVersion) => ({
+  clientInfo: { name: PUSHARY_CLIENT_NAME, title: null, version: clientVersion }
+});
+var hooksListParams = (cwd) => ({ cwds: [cwd] });
+var hookEventOf = (eventName) => eventName.charAt(0).toUpperCase() + eventName.slice(1);
+var readingOf = (hook) => ({
+  event: hookEventOf(hook.eventName),
+  status: hook.enabled ? hook.trustStatus : CODEX_HOOK_STATUS.disabled
+});
+var codexHookTrustByEvent = (events, hooks) => events.map((event) => hooks.map(readingOf).find((reading) => reading.event === event) ?? { event, status: CODEX_HOOK_STATUS.notListed });
+var CODEX_TRUST_FAILURES = /* @__PURE__ */ new Set([CODEX_HOOK_STATUS.untrusted, CODEX_HOOK_STATUS.modified]);
+var isCodexTrustFailure = (reading) => CODEX_TRUST_FAILURES.has(reading.status);
+var eventsWithStatus = (readings, status) => readings.filter((reading) => reading.status === status).map((reading) => reading.event);
+var assessCodexHookTrust = (events, hooks) => {
+  const readings = codexHookTrustByEvent(events, hooks);
+  const notListed = eventsWithStatus(readings, CODEX_HOOK_STATUS.notListed);
+  if (readings.length > 0 && notListed.length === readings.length) return { kind: "unlisted" };
+  const disabled = eventsWithStatus(readings, CODEX_HOOK_STATUS.disabled);
+  const failures = readings.filter(isCodexTrustFailure);
+  if (failures.length > 0) return { kind: "untrusted", failures, notListed, disabled };
+  const trusted = eventsWithStatus(readings, CODEX_HOOK_STATUS.trusted).length;
+  return { kind: "trusted", trusted, total: readings.length, notListed, disabled };
+};
+var mayAskCodex = (conditions) => {
+  if (!conditions.interactive) return { kind: "skipped", reason: CODEX_NOT_ASKED.notInteractive };
+  if (!conditions.codexOnPath) return { kind: "skipped", reason: CODEX_NOT_ASKED.noCodexOnPath };
+  if (!conditions.codexOpenedBefore) return { kind: "skipped", reason: CODEX_NOT_ASKED.neverOpened };
+  return { kind: "ask", binary: conditions.codexOnPath };
+};
+var canonicalPath = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return path;
+  }
+};
+var withCanonicalSources = (hooks) => hooks.map((hook) => ({ ...hook, sourcePath: canonicalPath(hook.sourcePath) }));
+var hasExited = (child) => child.exitCode !== null || child.signalCode !== null;
+var waitForExit = (child, ms) => new Promise((resolve) => {
+  if (hasExited(child)) return resolve(true);
+  const timer = setTimeout(() => resolve(false), ms);
+  child.once("exit", () => {
+    clearTimeout(timer);
+    resolve(true);
+  });
+});
+var terminate = async (child) => {
+  if (child.pid === void 0 || hasExited(child)) return;
+  child.stdin?.end();
+  child.kill("SIGTERM");
+  if (await waitForExit(child, TERMINATE_GRACE_MS)) return;
+  child.kill("SIGKILL");
+  await waitForExit(child, TERMINATE_GRACE_MS);
+};
+var rpcErrorMessage = (error) => isRecord(error) && typeof error.message === "string" ? error.message : "Codex returned an error";
+var describeExit = (code, signal, stderr) => {
+  const how = signal ? `signal ${signal}` : `code ${code ?? "unknown"}`;
+  const tail = stderr.trim();
+  return tail ? `Codex app-server exited (${how}): ${tail}` : `Codex app-server exited (${how})`;
+};
+var runCodexAppServer = (launch, conversation) => {
+  const child = spawnClaude(launch.binary, CODEX_APP_SERVER_ARGS, {
+    cwd: launch.codexHome,
+    env: { ...process.env, CODEX_HOME: launch.codexHome },
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
+  });
+  const pending = /* @__PURE__ */ new Map();
+  let nextId = 1;
+  let buffer = "";
+  let stderrTail = "";
+  let stoppedReason = null;
+  let stop = () => {
+  };
+  const stopped = new Promise((resolve) => {
+    stop = (reason) => {
+      if (stoppedReason !== null) return;
+      stoppedReason = reason;
+      for (const settle of pending.values()) settle({ kind: "error", message: reason });
+      pending.clear();
+      resolve({ kind: "unavailable", reason });
+    };
+  });
+  const write = (message) => {
+    if (stoppedReason === null) child.stdin?.write(`${JSON.stringify(message)}
+`);
+  };
+  const handleLine = (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!isRecord(message) || typeof message.id !== "number" || "method" in message) return;
+    const settle = pending.get(message.id);
+    if (!settle) return;
+    pending.delete(message.id);
+    settle("error" in message && message.error !== void 0 && message.error !== null ? { kind: "error", message: rpcErrorMessage(message.error) } : { kind: "result", value: message.result });
+  };
+  child.stdin?.on("error", () => {
+  });
+  child.stdout?.setEncoding("utf8");
+  child.stdout?.on("data", (chunk) => {
+    buffer += chunk;
+    let newline = buffer.indexOf("\n");
+    while (newline >= 0) {
+      handleLine(buffer.slice(0, newline));
+      buffer = buffer.slice(newline + 1);
+      newline = buffer.indexOf("\n");
+    }
+    if (buffer.length > MAX_RPC_LINE) stop("Codex app-server sent an oversized message");
+  });
+  child.stderr?.setEncoding("utf8");
+  child.stderr?.on("data", (chunk) => {
+    stderrTail = (stderrTail + chunk).slice(-STDERR_TAIL_LIMIT);
+  });
+  child.once("error", (error) => stop(`could not start ${launch.binary}: ${error.message}`));
+  child.once("close", (code, signal) => stop(describeExit(code, signal, stderrTail)));
+  const timer = setTimeout(
+    () => stop(`Codex app-server did not answer within ${launch.timeoutMs / 1e3}s`),
+    launch.timeoutMs
+  );
+  const session = {
+    request: (method, params) => {
+      if (stoppedReason !== null) return Promise.resolve({ kind: "error", message: stoppedReason });
+      const id = nextId++;
+      return new Promise((resolve) => {
+        pending.set(id, resolve);
+        write({ id, method, params });
+      });
+    },
+    notify: (method) => write({ method })
+  };
+  const conversed = conversation(session).catch((error) => ({
+    kind: "unavailable",
+    reason: error instanceof Error ? error.message : String(error)
+  }));
+  return Promise.race([conversed, stopped]).finally(async () => {
+    clearTimeout(timer);
+    await terminate(child);
+  });
+};
+var launchOf = (options) => {
+  const home = options.codexHome ?? codexHome();
+  const decision = mayAskCodex({
+    interactive: options.interactive ?? process.stdout.isTTY === true,
+    codexOnPath: options.codexOnPath === void 0 ? resolvePathBinary("codex") ?? null : options.codexOnPath,
+    codexOpenedBefore: existsSync(join(home, CODEX_INSTALLATION_ID_FILE))
+  });
+  if (decision.kind === "skipped") return decision;
+  return { binary: decision.binary, codexHome: home, timeoutMs: options.timeoutMs ?? CODEX_APP_SERVER_TIMEOUT_MS };
+};
+var isSkipped = (value) => "kind" in value && value.kind === "skipped";
+var openSession = async (session) => {
+  const initialized = await session.request(METHOD_INITIALIZE, initializeParams(getPackageVersion()));
+  if (initialized.kind === "error") return { kind: "unavailable", reason: `Codex refused initialize: ${initialized.message}` };
+  session.notify(METHOD_INITIALIZED);
+  return null;
+};
+var listHooks = async (session, launch) => {
+  const listed = await session.request(METHOD_HOOKS_LIST, hooksListParams(launch.codexHome));
+  if (listed.kind === "error") return { kind: "unavailable", reason: `Codex could not list hooks: ${listed.message}` };
+  const listing = hooksListingOf(listed.value);
+  if (!listing) return { kind: "unavailable", reason: UNRECOGNISED_LISTING };
+  return { hooks: withCanonicalSources(listing.hooks), warnings: listing.warnings };
+};
+var isListing = (value) => !("kind" in value);
+var confirmationAfterWrite = (listing, hooksJsonPath, writeError) => {
+  const verdict = codexTrustVerdict(listing.hooks, hooksJsonPath);
+  if (verdict.kind === "trusted") return { kind: "verified", wrote: true };
+  if (verdict.kind === "unlisted") return { kind: "unlisted", warnings: listing.warnings };
+  return { kind: "refused", hooks: verdict.hooks.map(readingOf), writeError };
+};
+var trustConversation = (launch, hooksJsonPath) => async (session) => {
+  const unavailable = await openSession(session);
+  if (unavailable) return unavailable;
+  const before = await listHooks(session, launch);
+  if (!isListing(before)) return before;
+  const verdict = codexTrustVerdict(before.hooks, hooksJsonPath);
+  if (verdict.kind === "trusted") return { kind: "verified", wrote: false };
+  if (verdict.kind === "unlisted") return { kind: "unlisted", warnings: before.warnings };
+  const written = await session.request(METHOD_CONFIG_BATCH_WRITE, codexTrustEdit(verdict.hooks));
+  const after = await listHooks(session, launch);
+  if (!isListing(after)) return after;
+  return confirmationAfterWrite(after, hooksJsonPath, written.kind === "error" ? written.message : null);
+};
+var listingConversation = (launch, hooksJsonPath) => async (session) => {
+  const unavailable = await openSession(session);
+  if (unavailable) return unavailable;
+  const listing = await listHooks(session, launch);
+  if (!isListing(listing)) return listing;
+  return { kind: "listed", hooks: pusharyHooksIn(listing.hooks, hooksJsonPath) };
+};
+var ensureCodexTrustsPusharyHooks = async (options = {}) => {
+  const launch = launchOf(options);
+  if (isSkipped(launch)) return launch;
+  return runCodexAppServer(launch, trustConversation(launch, canonicalPath(codexHooksJsonIn(launch.codexHome))));
+};
+var readCodexTrustForPusharyHooks = async (options = {}) => {
+  const launch = launchOf(options);
+  if (isSkipped(launch)) return launch;
+  return runCodexAppServer(launch, listingConversation(launch, canonicalPath(codexHooksJsonIn(launch.codexHome))));
+};
+
+export {
+  assessCodexHookTrust,
+  ensureCodexTrustsPusharyHooks,
+  readCodexTrustForPusharyHooks
+};

package/dist/{chunk-TRLFZKVG.js → chunk-6IU45EHE.js}

@@ -2,12 +2,19 @@ import {
   HOOK_BUDGETS,
   HOOK_LOCATOR_BINARY,
   withHookHoldBudget
-} from "./chunk-SOUZBGYJ.js";
+} from "./chunk-T4QY64OR.js";
+import {
+  isReleaseVersion
+} from "./chunk-HWJW3CPO.js";
 
 // src/npm.ts
 import { execFileSync, execSync } from "child_process";
 import { existsSync, readFileSync, realpathSync } from "fs";
 import { dirname, isAbsolute, join, relative, resolve } from "path";
+var AGENT_HOOKS_PACKAGE = "@pushary/agent-hooks";
+var LATEST_RELEASE_URL = `https://registry.npmjs.org/${AGENT_HOOKS_PACKAGE}/latest`;
+var REGISTRY_TIMEOUT_MS = 5e3;
+var LATEST_TAG = "latest";
 var cleanNpmEnv = () => {
   const env = {};
   for (const [key, value] of Object.entries(process.env)) {
@@ -16,10 +23,11 @@ var cleanNpmEnv = () => {
   }
   return env;
 };
+var NPM_ERROR_METADATA = /^(code|syscall|path|dest|errno)\s/i;
 var npmErrorMessage = (err) => {
   const e = err;
   const text = [e?.stderr, e?.stdout].map((part) => part ? part.toString() : "").join("\n");
-  const line = text.split("\n").map((l) => l.replace(/^npm error\s*/i, "").trim()).find((l) => l && !l.startsWith("A complete log") && !/^code\s/i.test(l));
+  const line = text.split("\n").map((l) => l.replace(/^npm error\s*/i, "").trim()).find((l) => l && !l.startsWith("A complete log") && !NPM_ERROR_METADATA.test(l));
   return line || e?.message || String(err);
 };
 var execNpm = (args, options = {}) => {
@@ -143,6 +151,26 @@ var resolveGlobalBinDir = (probe) => {
   return resolved ? resolved.slice(0, resolved.length - probe.length - 1) : void 0;
 };
 var quoteIfNeeded = (path) => /\s/.test(path) ? `"${path}"` : path;
+var fetchLatestPublishedVersion = async (request = {}) => {
+  try {
+    const response = await (request.fetchImpl ?? fetch)(LATEST_RELEASE_URL, {
+      signal: AbortSignal.timeout(request.timeoutMs ?? REGISTRY_TIMEOUT_MS)
+    });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    const version = body && typeof body === "object" && "version" in body ? body.version : void 0;
+    return typeof version === "string" && isReleaseVersion(version) ? version : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var POSIX_SHELL_WORD = /^[\w@%+=:,./-]+$/;
+var quoteForPosixShell = (value) => POSIX_SHELL_WORD.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+var installAgentHooksGlobally = (request, runNpm = execNpm) => {
+  const prefixFlag = request.prefix === void 0 ? "" : ` --prefix ${quoteForPosixShell(request.prefix)}`;
+  const spec = quoteForPosixShell(`${AGENT_HOOKS_PACKAGE}@${request.version}`);
+  runNpm(`install -g --no-workspaces${prefixFlag} ${spec}`, { timeout: request.timeoutMs });
+};
 var needsGlobalInstall = (requested, installed, binaryPresent) => requested !== installed || !binaryPresent;
 var installState;
 var installGlobally = (options) => {
@@ -153,13 +181,13 @@ var installGlobally = (options) => {
     const pinned = process.env.PUSHARY_PIN_GLOBAL_VERSION !== "0";
     if (pinned && !needsGlobalInstall(
       options.version,
-      resolveGlobalPackageVersion("@pushary/agent-hooks"),
-      globalPackageBinsPresent("@pushary/agent-hooks")
+      resolveGlobalPackageVersion(AGENT_HOOKS_PACKAGE),
+      globalPackageBinsPresent(AGENT_HOOKS_PACKAGE)
     )) {
       return "skipped";
     }
-    const spec = pinned && options.version && options.version !== "0.0.0" ? `@pushary/agent-hooks@${options.version}` : "@pushary/agent-hooks@latest";
-    execNpm(`install -g --no-workspaces ${spec}`, { timeout: options.timeoutMs ?? 12e4 });
+    const version = pinned && options.version && options.version !== "0.0.0" ? options.version : LATEST_TAG;
+    installAgentHooksGlobally({ version, timeoutMs: options.timeoutMs ?? 12e4 });
     return "installed";
   })();
   installState = started;
@@ -286,7 +314,8 @@ var CODEX_HOOK_BINARY = "pushary-codex-hook";
 var codexHome = () => codexHomeFrom(homedir());
 var codexHomeFrom = (home) => process.env.CODEX_HOME?.trim() || join2(home, ".codex");
 var codexConfigToml = () => join2(codexHome(), "config.toml");
-var codexHooksJson = () => join2(codexHome(), "hooks.json");
+var codexHooksJsonIn = (home) => join2(home, "hooks.json");
+var codexHooksJson = () => codexHooksJsonIn(codexHome());
 var codexAgentsMd = () => join2(codexHome(), "AGENTS.md");
 var codexSkillDir = () => join2(codexHome(), "skills", "pushary");
 var CODEX_HOOK_EVENTS = [
@@ -358,10 +387,11 @@ var readCodexMcpAuth = (config) => {
   if (typeof pushary.bearer_token === "string") return { method: "legacy-bearer" };
   return void 0;
 };
+var isPusharyCodexCommand = (command) => command.includes(CODEX_HOOK_BINARY) || command.includes(HOOK_LOCATOR_BINARY);
 var isPusharyCommand = (hook, scope) => {
   const command = String(asRecord2(hook)?.command ?? "");
   if (isProtectedByScope(command, scope)) return false;
-  return command.includes(CODEX_HOOK_BINARY) || command.includes(HOOK_LOCATOR_BINARY);
+  return isPusharyCodexCommand(command);
 };
 var isPusharyCodexHook = (entry, scope) => {
   const hooks = asRecord2(entry)?.hooks;
@@ -435,23 +465,6 @@ var codexEntryTrustHash = (eventKey, entry) => {
   if (typeof entry.matcher === "string") identity.matcher = entry.matcher;
   return "sha256:" + createHash("sha256").update(canonicalJson(identity), "utf8").digest("hex");
 };
-var codexTrustSchemeAgrees = (hooksConfig, config, hooksJsonPath) => {
-  const hooks = asRecord2(hooksConfig?.hooks);
-  const state = asRecord2(asRecord2(config.hooks)?.state);
-  if (!hooks || !state) return false;
-  for (const [event, entries] of Object.entries(hooks)) {
-    if (!Array.isArray(entries)) continue;
-    const eventKey = CODEX_EVENT_KEY[event] ?? codexEventKeyOf(event);
-    for (const [index, entry] of entries.entries()) {
-      const record = asRecord2(entry);
-      if (!record) continue;
-      const stored = asRecord2(state[`${hooksJsonPath}:${eventKey}:${index}:0`])?.trusted_hash;
-      if (typeof stored !== "string") continue;
-      if (stored === codexEntryTrustHash(eventKey, record)) return true;
-    }
-  }
-  return false;
-};
 var codexHookPositions = (hooksConfig) => {
   const hooks = asRecord2(hooksConfig?.hooks);
   const positions = {};
@@ -609,6 +622,9 @@ var claudeSettingsLocal = () => join3(homedir2(), ".claude", "settings.local.jso
 var pusharyDir = () => join3(homedir2(), ".pushary");
 var claudeMcpReceipt = () => join3(pusharyDir(), "setup", "claude-mcp.json");
 var bridgeAgentKey = () => join3(pusharyDir(), "bridge-auth", "agent-key.json");
+var autoUpdateState = () => join3(pusharyDir(), "auto-update.json");
+var autoUpdateLock = () => join3(pusharyDir(), "auto-update.lock");
+var autoUpdateLog = () => join3(pusharyDir(), "logs", "auto-update.log");
 var claudeRegistrationReceipt = () => join3(pusharyDir(), "setup", "claude-registration.json");
 var hermesConfigReceipt = () => join3(pusharyDir(), "setup", "hermes-config.json");
 var hookTakeoverReceipt = (agent) => join3(pusharyDir(), "setup", `hook-takeover-${agent}.json`);
@@ -622,6 +638,7 @@ export {
   registeredCommands,
   namesOurBinary,
   registrationHolderOf,
+  LATEST_TAG,
   npmErrorMessage,
   execNpm,
   resolveGlobalBinary,
@@ -630,6 +647,8 @@ export {
   resolvePackageVersionFromBinary,
   resolveGlobalPackageVersion,
   resolveGlobalBinDir,
+  fetchLatestPublishedVersion,
+  installAgentHooksGlobally,
   installGlobally,
   holdBudgetOf,
   guardBinary,
@@ -642,18 +661,19 @@ export {
   codexHome,
   codexHomeFrom,
   codexConfigToml,
+  codexHooksJsonIn,
   codexHooksJson,
   codexAgentsMd,
   codexSkillDir,
   CODEX_HOOK_EVENTS,
   addCodexMcpServer,
   readCodexMcpAuth,
+  isPusharyCodexCommand,
   codexRegistrationHolder,
   addCodexHooks,
   removeCodexHooks,
   hasCodexHooks,
   missingCodexHookEvents,
-  codexTrustSchemeAgrees,
   codexHookPositions,
   codexVacatedIndexes,
   dropVacatedCodexHookTrust,
@@ -675,6 +695,9 @@ export {
   pusharyDir,
   claudeMcpReceipt,
   bridgeAgentKey,
+  autoUpdateState,
+  autoUpdateLock,
+  autoUpdateLog,
   claudeRegistrationReceipt,
   hermesConfigReceipt,
   hookTakeoverReceipt,

package/dist/{chunk-JVTOML54.js → chunk-6QFEQIPM.js}

@@ -1,9 +1,9 @@
 import {
   registerTranscript
-} from "./chunk-UJBZIKSY.js";
+} from "./chunk-TZGCUNOX.js";
 import {
   degradedLine
-} from "./chunk-SOUZBGYJ.js";
+} from "./chunk-T4QY64OR.js";
 
 // src/tool-hook-input.ts
 var OPTIONAL_TEXT_FIELDS = ["hook_event_name", "session_id", "cwd", "transcript_path", "tool_use_id", "permission_mode"];

package/dist/chunk-BY2CRWBO.js

@@ -0,0 +1,38 @@
+import {
+  NPX_LATEST_COMMAND
+} from "./chunk-EA3IELHP.js";
+
+// src/setup/codex-trust.ts
+var CODEX_TRUST_TELEMETRY = {
+  verified: "verified",
+  refused: "manual",
+  unlisted: "manual",
+  skipped: "unverified",
+  unavailable: "unverified"
+};
+var isUnanswered = (confirmation) => confirmation.kind === "skipped" || confirmation.kind === "unavailable";
+var codexTrustOutcome = (confirmation, portedTrustWritten) => isUnanswered(confirmation) && !portedTrustWritten ? "manual" : CODEX_TRUST_TELEMETRY[confirmation.kind];
+var CODEX_TRUST_REFUSED = "Codex did not accept the trust Pushary asked for, so its hooks are not trusted yet. Open Codex, run /hooks, and choose Trust for the Pushary hooks.";
+var describeUnlistedCodexHooks = (warnings) => {
+  const said = warnings[0] ? ` Codex said: ${warnings[0]}` : "";
+  return `Codex does not list the Pushary hooks, so it will not run them.${said} Run ${NPX_LATEST_COMMAND} doctor for details.`;
+};
+var describeCodexTrustConfirmation = (confirmation) => {
+  switch (confirmation.kind) {
+    case "verified":
+      return confirmation.wrote ? "Codex trusted the Pushary hooks when asked, and confirmed it." : "Codex confirms the Pushary hooks are trusted.";
+    case "refused":
+      return confirmation.writeError ? `${CODEX_TRUST_REFUSED} Codex said: ${confirmation.writeError}` : CODEX_TRUST_REFUSED;
+    case "unlisted":
+      return describeUnlistedCodexHooks(confirmation.warnings);
+    case "skipped":
+      return `Pushary did not ask Codex to confirm the trust: ${confirmation.reason}.`;
+    case "unavailable":
+      return `Codex could not be asked to confirm the Pushary hooks are trusted (${confirmation.reason}).`;
+  }
+};
+
+export {
+  codexTrustOutcome,
+  describeCodexTrustConfirmation
+};

package/dist/{chunk-G653QPTR.js → chunk-D573TLP6.js}

@@ -1,26 +1,26 @@
 import {
   NOTIFICATION_PUSH_TYPES,
   POSTTOOLUSE_MIRROR_ONLY_TOOLS
-} from "./chunk-YXP3WPAI.js";
+} from "./chunk-UYDTFCHW.js";
 import {
   cancelQuestion,
   isPolicyConfig,
   sendNotification,
   waitForAnswer
-} from "./chunk-LGXUGYUH.js";
+} from "./chunk-PYCQXCI5.js";
 import {
   getMachineId
-} from "./chunk-NHTAHAIS.js";
+} from "./chunk-WOLPADR6.js";
 import {
   withRetry
-} from "./chunk-EYRGBYZG.js";
+} from "./chunk-HETOKNIL.js";
 import {
   reportedInstallSource
-} from "./chunk-UM5J3J4V.js";
+} from "./chunk-HU5LSYL2.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-2UMNXADU.js";
+} from "./chunk-OSJEMXSR.js";
 import {
   ACTION_BODY_MAX,
   AGENT_LABELS_BY_TYPE,
@@ -44,7 +44,7 @@ import {
   resolveAutoResolveOrigin,
   resolvePolicy,
   toToolLookup
-} from "./chunk-SOUZBGYJ.js";
+} from "./chunk-T4QY64OR.js";
 
 // src/policy.ts
 import { createHash } from "crypto";

package/dist/{chunk-25RTLTQD.js → chunk-DTQNDR7C.js}

@@ -1,6 +1,6 @@
 import {
   readConfigFileKey
-} from "./chunk-FU2DFEAZ.js";
+} from "./chunk-USQDVBEV.js";
 
 // src/bell/fleet.ts
 import { closeSync, constants, futimesSync, lstatSync, mkdirSync, openSync, readdirSync, unlinkSync } from "fs";

package/dist/{chunk-FAH3D74E.js → chunk-EA3IELHP.js}

@@ -1,4 +1,5 @@
 // src/cli/commands.ts
+var NPX_LATEST_COMMAND = "npx @pushary/agent-hooks@latest";
 var COMMAND_LIST = [
   {
     name: "cowork",
@@ -132,6 +133,10 @@ var COMMAND_OPTIONS = {
     ["--bundle", "Write a redacted diagnostics file you can attach to a support thread"]
   ],
   suggestions: [["accept <id>", "Turn a mined suggestion into an always-allow rule"]],
+  upgrade: [
+    ["--auto=off", "Stop Pushary updating itself in the background"],
+    ["--auto=on", "Update in the background again: once a day at session start, within the same major version"]
+  ],
   bell: [
     ["(no flags)", "Turn the bell on for Claude Code"],
     ["--test", "Ring once, now, so you can hear what it does"],
@@ -232,6 +237,7 @@ var renderCommandHelp = (name, version) => {
 };
 
 export {
+  NPX_LATEST_COMMAND,
   COMMANDS,
   isCommandName,
   renderHelp,

package/dist/{chunk-EYRGBYZG.js → chunk-HETOKNIL.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SAF6HGAA.js";
 import {
   getBaseUrl
-} from "./chunk-2UMNXADU.js";
+} from "./chunk-OSJEMXSR.js";
 
 // src/retry.ts
 var isRetryable = (err) => {

package/dist/{chunk-UM5J3J4V.js → chunk-HU5LSYL2.js}

@@ -1,9 +1,9 @@
 import {
   configFilePath
-} from "./chunk-2UMNXADU.js";
+} from "./chunk-OSJEMXSR.js";
 import {
   normalizeInstallSource
-} from "./chunk-SOUZBGYJ.js";
+} from "./chunk-T4QY64OR.js";
 
 // src/install-source.ts
 import { readFileSync } from "fs";

package/dist/{chunk-PC6DU5C4.js → chunk-HUAOMX4U.js}

@@ -1,6 +1,6 @@
 import {
   parseVersion
-} from "./chunk-LPYCPFBZ.js";
+} from "./chunk-2AUIEZYS.js";
 
 // src/setup/agent-probe.ts
 import { execSync } from "child_process";

package/dist/{chunk-2V2IKOGJ.js → chunk-HVBF35GT.js}

@@ -3,11 +3,11 @@ import {
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-GZ7E6VOB.js";
+} from "./chunk-TIWURSLS.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
-} from "./chunk-EQRS3SGM.js";
+} from "./chunk-66H2QQAK.js";
 
 // src/live-session.ts
 var MAX_TRANSCRIPT_QUEUE = 100;