@event4u/agent-config 17.2.1 → 17.4.0

package/dist/hooks/update_notice.chunk.cjs

@@ -0,0 +1,914 @@
+#!/usr/bin/env node
+const __acChunkMetaUrl = require('node:url').pathToFileURL(__filename).href; const __acChunkMeta = { url: __acChunkMetaUrl, dirname: __dirname, filename: __filename };
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/update_notice_hook.ts
+var update_notice_hook_exports = {};
+__export(update_notice_hook_exports, {
+  CONCERN: () => CONCERN,
+  NOTICE_STATE_FILENAME: () => NOTICE_STATE_FILENAME,
+  NOTICE_STATE_SCHEMA: () => NOTICE_STATE_SCHEMA,
+  NOTICE_THROTTLE_FILENAME: () => NOTICE_THROTTLE_FILENAME,
+  confirmDelivered: () => confirmDelivered,
+  main: () => main,
+  noticeOncePerDay: () => noticeOncePerDay,
+  ranToday: () => ranToday,
+  readNoticeState: () => readNoticeState,
+  readUpdateMode: () => readUpdateMode,
+  runNotice: () => runNotice,
+  writeNoticeState: () => writeNoticeState
+});
+module.exports = __toCommonJS(update_notice_hook_exports);
+var import_node_crypto2 = require("node:crypto");
+var fs8 = __toESM(require("node:fs"), 1);
+var path7 = __toESM(require("node:path"), 1);
+var import_node_url2 = require("node:url");
+var import_yaml = require("yaml");
+
+// src/scripts/_cli/doctor_install_mode.ts
+var fs2 = __toESM(require("node:fs"), 1);
+var path2 = __toESM(require("node:path"), 1);
+
+// src/scripts/_lib/user_global_paths.ts
+var fs = __toESM(require("node:fs"), 1);
+var os = __toESM(require("node:os"), 1);
+var path = __toESM(require("node:path"), 1);
+var EVENT4U_HOME_ENV = "EVENT4U_CONFIG_HOME";
+var DEFAULT_EVENT4U_ROOT_RELATIVE = path.join(".event4u", "agent-config");
+var LEGACY_XDG_ROOT_RELATIVE = path.join(".config", "agent-config");
+function expanduser(p) {
+  if (p === "~") {
+    return os.homedir();
+  }
+  if (p.startsWith("~/") || process.platform === "win32" && p.startsWith("~\\")) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+function is_absolute_like_python(p) {
+  if (process.platform === "win32") {
+    return /^[a-zA-Z]:[\\/]/.test(p) || /^([\\/]{2})[^\\/]+[\\/][^\\/]+/.test(p);
+  }
+  return p.startsWith("/");
+}
+function event4u_root(env) {
+  const env_map = env ?? process.env;
+  const override = env_map[EVENT4U_HOME_ENV];
+  if (override) {
+    return expanduser(override);
+  }
+  return path.join(os.homedir(), DEFAULT_EVENT4U_ROOT_RELATIVE);
+}
+function legacy_xdg_root() {
+  return path.join(os.homedir(), LEGACY_XDG_ROOT_RELATIVE);
+}
+function resolve_with_fallback(relative_name, options = {}) {
+  if (is_absolute_like_python(relative_name)) {
+    throw new Error(
+      `resolve_with_fallback expects a relative path, got '${relative_name}'`
+    );
+  }
+  const new_path = path.join(event4u_root(options.env ?? null), relative_name);
+  if (fs.existsSync(new_path)) {
+    return new_path;
+  }
+  const legacy_path = path.join(legacy_xdg_root(), relative_name);
+  if (fs.existsSync(legacy_path)) {
+    return legacy_path;
+  }
+  return null;
+}
+function write_target(relative_name, options = {}) {
+  if (is_absolute_like_python(relative_name)) {
+    throw new Error(`write_target expects a relative path, got '${relative_name}'`);
+  }
+  return path.join(event4u_root(options.env ?? null), relative_name);
+}
+
+// src/scripts/_lib/version_order.ts
+var NUM = "(0|[1-9]\\d*)";
+var IDENT = "[0-9A-Za-z-]+";
+var VERSION_RE = new RegExp(
+  `^v*${NUM}\\.${NUM}\\.${NUM}(?:-(${IDENT}(?:\\.${IDENT})*))?(?:\\+${IDENT}(?:\\.${IDENT})*)?$`
+);
+function parse_version(v) {
+  if (typeof v !== "string") return null;
+  const m = VERSION_RE.exec(v.trim());
+  if (!m) return null;
+  const pre = m[4] === void 0 ? [] : m[4].split(".").map((id) => /^\d+$/.test(id) ? Number(id) : id);
+  return { major: Number(m[1]), minor: Number(m[2]), patch: Number(m[3]), pre };
+}
+function cmp_num(a, b) {
+  return a === b ? 0 : a < b ? -1 : 1;
+}
+function compare_parsed(a, b) {
+  const core = cmp_num(a.major, b.major) || cmp_num(a.minor, b.minor) || cmp_num(a.patch, b.patch);
+  if (core !== 0) return core;
+  if (a.pre.length === 0 || b.pre.length === 0) return cmp_num(b.pre.length, a.pre.length);
+  for (let i = 0; i < Math.max(a.pre.length, b.pre.length); i += 1) {
+    const x = a.pre[i];
+    const y = b.pre[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (typeof x === "number" && typeof y === "number") {
+      if (x !== y) return cmp_num(x, y);
+    } else if (typeof x === "number") {
+      return -1;
+    } else if (typeof y === "number") {
+      return 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function compare_versions(a, b) {
+  const pa = parse_version(a);
+  const pb = parse_version(b);
+  if (pa === null || pb === null) return null;
+  return compare_parsed(pa, pb);
+}
+
+// src/scripts/_lib/update_check.ts
+var PACKAGE_NAME = "@event4u/agent-config";
+var NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+var CHECK_WINDOW_MS = 24 * 60 * 60 * 1e3;
+var STATE_FILENAME = "update-check.json";
+var DEFAULT_STATE_PATH = write_target(STATE_FILENAME);
+var GLOBAL_TREE = /[\\/](?:lib|npm)[\\/]node_modules[\\/]@event4u[\\/]agent-config[\\/]?$/;
+function classify_install_origin(signals) {
+  const pin = signals.project_pin?.trim() ?? "";
+  if (pin !== "") {
+    return signals.latest && _is_newer(signals.latest, pin) ? "project-pin" : "unknown";
+  }
+  if (signals.package_root.split(/[\\/]+/).includes("_npx")) {
+    return "ephemeral";
+  }
+  if (signals.is_global_consumer || GLOBAL_TREE.test(signals.package_root)) {
+    return "global";
+  }
+  return "unknown";
+}
+function _int_or_zero(part) {
+  const trimmed = part.trim();
+  if (/^[+-]?\d+$/.test(trimmed)) {
+    return parseInt(trimmed, 10);
+  }
+  return 0;
+}
+function _is_newer(latest, installed) {
+  const parse = (v) => {
+    const core = v.replace(/^v+/, "").split("-")[0] ?? "";
+    const parts = core.split(".");
+    const out = [];
+    for (const p of parts.slice(0, 3)) {
+      out.push(_int_or_zero(p));
+    }
+    while (out.length < 3) {
+      out.push(0);
+    }
+    return [out[0], out[1], out[2]];
+  };
+  const a = parse(latest);
+  const b = parse(installed);
+  for (let i = 0; i < 3; i += 1) {
+    if (a[i] > b[i]) {
+      return true;
+    }
+    if (a[i] < b[i]) {
+      return false;
+    }
+  }
+  return false;
+}
+
+// src/scripts/_cli/doctor_install_mode.ts
+function isSourceCheckoutPackage(packageRoot) {
+  return fs2.existsSync(path2.join(packageRoot, ".git"));
+}
+function originForPackageRoot(root) {
+  if (isSourceCheckoutPackage(root)) return "source-checkout";
+  return classify_install_origin({ package_root: root, project_pin: null, latest: null, is_global_consumer: false });
+}
+
+// src/scripts/_lib/agent_settings.ts
+var import_node_module = require("node:module");
+var path4 = __toESM(require("node:path"), 1);
+
+// src/scripts/_lib/package_root.ts
+var fs3 = __toESM(require("node:fs"), 1);
+var path3 = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+var PACKAGE_NAME2 = "@event4u/agent-config";
+var MAX_ASCENT = 16;
+function resolvePackageRoot(fromUrlOrPath, legacyHops = 3) {
+  const start = fromUrlOrPath.startsWith("file:") ? (0, import_node_url.fileURLToPath)(fromUrlOrPath) : fromUrlOrPath;
+  const startDir = path3.dirname(start);
+  let dir = startDir;
+  for (let i = 0; i < MAX_ASCENT; i++) {
+    const manifest = path3.join(dir, "package.json");
+    if (fs3.existsSync(manifest)) {
+      try {
+        const parsed = JSON.parse(fs3.readFileSync(manifest, "utf8"));
+        if (parsed.name === PACKAGE_NAME2) {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    const parent = path3.dirname(dir);
+    if (parent === dir) {
+      break;
+    }
+    dir = parent;
+  }
+  return path3.resolve(startDir, ...Array.from({ length: legacyHops }, () => ".."));
+}
+
+// src/scripts/_lib/agent_settings.ts
+var _require = (0, import_node_module.createRequire)(__acChunkMetaUrl);
+var Logger = class {
+  name = "scripts._lib.agent_settings";
+  records = [];
+  info(message, ...args) {
+    this.records.push({ level: "INFO", message: _format(message, args) });
+  }
+  warning(message, ...args) {
+    this.records.push({ level: "WARNING", message: _format(message, args) });
+  }
+};
+function _format(template, args) {
+  let i = 0;
+  return template.replace(/%s/g, () => {
+    if (i < args.length) {
+      const value = args[i];
+      i += 1;
+      return _pystr(value);
+    }
+    return "%s";
+  });
+}
+function _pystr(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((v) => _pyrepr(v)).join(", ")}]`;
+  }
+  return String(value);
+}
+function _pyrepr(value) {
+  if (typeof value === "string") {
+    return `'${value}'`;
+  }
+  return String(value);
+}
+var logger = new Logger();
+var USER_GLOBAL_FILENAME = "agent-settings.yml";
+function DEFAULT_USER_GLOBAL_FILE() {
+  return write_target(USER_GLOBAL_FILENAME);
+}
+var USER_GLOBAL_CANONICAL_RELATIVE = "settings/.agent-settings.yml";
+function user_global_settings_paths() {
+  const paths = [];
+  const flat = resolve_with_fallback(USER_GLOBAL_FILENAME);
+  if (flat !== null) {
+    paths.push(flat);
+  }
+  const canonical = resolve_with_fallback(USER_GLOBAL_CANONICAL_RELATIVE);
+  if (canonical !== null) {
+    paths.push(canonical);
+  }
+  if (paths.length === 0) {
+    paths.push(DEFAULT_USER_GLOBAL_FILE());
+  }
+  return paths;
+}
+var TEMPLATE_RELATIVE = path4.join("src", "config", "agent-settings.template.yml");
+var _PACKAGE_ROOT = resolvePackageRoot(__acChunkMetaUrl);
+
+// src/scripts/_lib/session_register.ts
+var import_node_fs2 = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+
+// src/scripts/_lib/fs_atomic.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_crypto = require("node:crypto");
+function _normalize_encoding(encoding) {
+  const compact = encoding.toLowerCase().replace(/[-_\s]/g, "");
+  const candidates = [encoding, compact];
+  if (compact === "latin1" || compact === "iso88591") candidates.push("latin1");
+  if (compact === "utf8") candidates.push("utf8");
+  if (compact === "utf16le" || compact === "utf16") candidates.push("utf16le");
+  if (compact === "usascii") candidates.push("ascii");
+  for (const c of candidates) {
+    if (Buffer.isEncoding(c)) return c;
+  }
+  throw new Error(`unknown encoding: ${encoding}`);
+}
+function write_atomic(p, data, options = {}) {
+  const encoding = options.encoding ?? "utf-8";
+  const target = import_node_path.default.normalize(p);
+  const parent = import_node_path.default.dirname(target);
+  import_node_fs.default.mkdirSync(parent, { recursive: true });
+  let payload;
+  if (typeof data === "string") {
+    payload = Buffer.from(data, _normalize_encoding(encoding));
+  } else if (data instanceof Uint8Array) {
+    payload = Buffer.from(data);
+  } else {
+    throw new TypeError(
+      `write_atomic: data must be str or bytes, got ${typeof data}`
+    );
+  }
+  let fd = null;
+  let tmp_path = "";
+  for (let attempt = 0; attempt < 32; attempt += 1) {
+    tmp_path = import_node_path.default.join(
+      parent,
+      `.${import_node_path.default.basename(target)}.tmp.${(0, import_node_crypto.randomBytes)(6).toString("hex")}`
+    );
+    try {
+      fd = import_node_fs.default.openSync(tmp_path, "wx", 384);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") continue;
+      throw err;
+    }
+  }
+  if (fd === null) {
+    throw new Error("write_atomic: could not create a unique temp file");
+  }
+  let closed = false;
+  try {
+    let offset = 0;
+    while (offset < payload.length) {
+      offset += import_node_fs.default.writeSync(fd, payload, offset, payload.length - offset);
+    }
+    try {
+      import_node_fs.default.fsyncSync(fd);
+    } catch {
+    }
+    import_node_fs.default.closeSync(fd);
+    closed = true;
+    import_node_fs.default.renameSync(tmp_path, target);
+  } catch (err) {
+    if (!closed) {
+      try {
+        import_node_fs.default.closeSync(fd);
+      } catch {
+      }
+    }
+    try {
+      import_node_fs.default.unlinkSync(tmp_path);
+    } catch {
+    }
+    throw err;
+  }
+  _fsync_dir(parent);
+  return target;
+}
+function _fsync_dir(directory) {
+  let dir_fd;
+  try {
+    dir_fd = import_node_fs.default.openSync(directory, import_node_fs.default.constants.O_RDONLY);
+  } catch {
+    return;
+  }
+  try {
+    try {
+      import_node_fs.default.fsyncSync(dir_fd);
+    } catch {
+    }
+  } finally {
+    import_node_fs.default.closeSync(dir_fd);
+  }
+}
+
+// src/scripts/_lib/session_register.ts
+var TTL_MEASURED_SECONDS = Object.freeze({
+  claude: 14400
+  // 4 h — raw p99 13 705 s / raw user→user max 14 199 s, rounded up
+});
+var TTL_DEFAULT_SECONDS = 43200;
+function ttl_seconds_for(platform) {
+  const key = String(platform ?? "").trim().toLowerCase();
+  return TTL_MEASURED_SECONDS[key] ?? TTL_DEFAULT_SECONDS;
+}
+function safe_stem(session_id) {
+  const collapsed = String(session_id ?? "").replace(/\.\./g, "_").replace(/[/\\]/g, "_").replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 128);
+  return /[A-Za-z0-9]/.test(collapsed) ? collapsed : "unknown-session";
+}
+function global_register_dir(env) {
+  return import_node_path2.default.join(event4u_root(env), "runtime", "sessions");
+}
+function epoch_ms(stamp) {
+  if (typeof stamp !== "string" || stamp.length === 0) return null;
+  const ms = Date.parse(stamp);
+  return Number.isFinite(ms) ? ms : null;
+}
+function is_expired(rec, now = /* @__PURE__ */ new Date()) {
+  const seen = epoch_ms(rec.last_seen);
+  if (seen === null) return true;
+  const age_s = (now.getTime() - seen) / 1e3;
+  return age_s > ttl_seconds_for(rec.platform);
+}
+function is_record(v) {
+  if (typeof v !== "object" || v === null) return false;
+  const o = v;
+  return typeof o["session_id"] === "string" && typeof o["last_seen"] === "string";
+}
+var PRUNE_GRACE_MS = 24 * 60 * 60 * 1e3;
+function read_live_records(dir, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const prune = options.prune === true;
+  const grace = options.prune_grace_ms ?? PRUNE_GRACE_MS;
+  let names;
+  try {
+    names = import_node_fs2.default.readdirSync(dir).filter((n) => n.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  const live = [];
+  for (const name of names) {
+    const full = import_node_path2.default.join(dir, name);
+    let rec = null;
+    try {
+      const parsed = JSON.parse(import_node_fs2.default.readFileSync(full, "utf-8"));
+      rec = is_record(parsed) ? parsed : null;
+    } catch {
+      rec = null;
+    }
+    if (rec === null || is_expired(rec, now)) {
+      if (prune && (rec === null || is_expired(rec, new Date(now.getTime() - grace)))) {
+        try {
+          import_node_fs2.default.unlinkSync(full);
+        } catch {
+        }
+      }
+      continue;
+    }
+    live.push(rec);
+  }
+  return live;
+}
+function foreign_live_records(dir, session_id, options = {}) {
+  const own = safe_stem(session_id);
+  return read_live_records(dir, options).filter((r) => safe_stem(r.session_id) !== own);
+}
+function any_live_session(dir, session_id, now = /* @__PURE__ */ new Date()) {
+  const records = session_id === void 0 || session_id === null ? read_live_records(dir, { now }) : foreign_live_records(dir, session_id, { now });
+  return records.length > 0;
+}
+
+// src/scripts/_lib/consumer_impact.ts
+var CONSUMER_IMPACT_VALUES = ["none", "automatic", "notice", "action"];
+var NO_IMPACT_TRAILERS = Object.freeze({
+  impact: "none",
+  recorded: false,
+  invalid: null,
+  security: false
+});
+var IMPACT_RANK = Object.freeze({
+  none: 0,
+  automatic: 1,
+  notice: 2,
+  action: 3
+});
+
+// src/scripts/_lib/update_notice.ts
+var SECURITY_POLICY_REF = "SECURITY.md:21 \u2014 fixes land on the latest version only; older releases are not backported";
+var HEAD_PRIORITY = [
+  "Security and correctness",
+  "Default changes + migration",
+  "Known limitations",
+  "Behaviour changes",
+  "Honest nulls"
+];
+function sanitiseImpactMap(map) {
+  const clean = /* @__PURE__ */ new Map();
+  if (map === null || typeof map !== "object" || Array.isArray(map)) return clean;
+  for (const [version, entry] of Object.entries(map)) {
+    if (parse_version(version) === null) continue;
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry)) continue;
+    const impact = entry["impact"];
+    if (!CONSUMER_IMPACT_VALUES.includes(impact)) continue;
+    clean.set(version, { impact, security: entry["security"] === true });
+  }
+  return clean;
+}
+function impactInRange(map, installed, candidate) {
+  const rank = (i) => CONSUMER_IMPACT_VALUES.indexOf(i);
+  let worst = null;
+  let security = false;
+  for (const [version, entry] of map) {
+    if (compare_versions(version, installed) !== 1 || compare_versions(version, candidate) === 1) continue;
+    if (worst === null || rank(entry.impact) > rank(worst)) worst = entry.impact;
+    security = security || entry.security;
+  }
+  return { worst, security };
+}
+var NOTHING = (reason) => ({ lines: [], stage: null, activate: null, suppressed: reason });
+var RECONCILE_REASONS = /* @__PURE__ */ new Set(["no cached candidate", "nothing newer cached"]);
+function noticeSuppression(input) {
+  if (input.env.ci) return "CI";
+  if (!input.env.interactive) return "non-interactive";
+  if (input.env.noUpdateCheck) return "AGENT_CONFIG_NO_UPDATE_CHECK=1";
+  if (input.origin === "source-checkout") return "source checkout";
+  if (input.origin === "ephemeral") return "ephemeral run";
+  if (input.mode === "off") return "update.mode off";
+  return null;
+}
+function oneCuratedLine(head) {
+  for (const label of HEAD_PRIORITY) {
+    const text = head.get(label);
+    if (text !== void 0 && text.trim() !== "" && text.trim() !== "_none_") {
+      return `${label}: ${text.trim()}`;
+    }
+  }
+  return null;
+}
+function shownVersion(candidate) {
+  const v = parse_version(candidate);
+  return `${v.major}.${v.minor}.${v.patch}${v.pre.length > 0 ? " (pre-release)" : ""}`;
+}
+function updateNotice(input) {
+  const suppressed = noticeSuppression(input);
+  if (suppressed !== null) return NOTHING(suppressed);
+  if (input.lastSeenInstalled !== null && compare_versions(input.installed, input.lastSeenInstalled) === 1) {
+    const line = oneCuratedLine(input.curatedHead);
+    const lines2 = [`agent-config is now ${input.installed} (was ${input.lastSeenInstalled}).`];
+    if (line !== null) lines2.push(`  ${line}`);
+    return { lines: lines2, stage: null, activate: null, suppressed: null };
+  }
+  if (input.candidate === null || parse_version(input.candidate) === null) return NOTHING("no cached candidate");
+  if (compare_versions(input.candidate, input.installed) !== 1) return NOTHING("nothing newer cached");
+  const range = impactInRange(sanitiseImpactMap(input.impactMap), input.installed, input.candidate);
+  const lines = [`agent-config ${shownVersion(input.candidate)} is available (installed: ${input.installed}).`];
+  if (range.security) lines.push(`  Security fix in range. ${SECURITY_POLICY_REF}.`);
+  if (range.worst === "notice") lines.push("  A release in range carries a notice \u2014 read it before upgrading.");
+  if (range.worst === "action") lines.push("  A release in range needs a hand; it is never installed unattended.");
+  const stageable = range.worst !== "action";
+  if (input.mode === "auto" && stageable) {
+    lines.push(
+      input.foreignSessionLive ? "  Staged. Another session is open on this machine, so a swap would break its hooks." : "  Staged. Run `agent-config upgrade --unattended` to install it."
+    );
+  } else {
+    lines.push("  Run `agent-config upgrade` to install it.");
+  }
+  return { lines, stage: stageable ? input.candidate : null, activate: null, suppressed: null };
+}
+function parseCuratedHead(changelog, version) {
+  const head = /* @__PURE__ */ new Map();
+  const lines = changelog.split("\n");
+  const sectionStart = lines.findIndex((l) => new RegExp(`^## \\[?${version.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\]?(\\s|$)`).test(l));
+  if (sectionStart < 0) return head;
+  let inHighlights = false;
+  for (let i = sectionStart + 1; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (/^#{1,2} /.test(line)) break;
+    if (/^### /.test(line)) {
+      inHighlights = /^### Release highlights\s*$/.test(line);
+      continue;
+    }
+    if (!inHighlights) continue;
+    const m = /^- \*\*(.+?):\*\*\s*(.*)$/.exec(line);
+    if (m !== null) head.set(m[1], m[2].trim());
+  }
+  return head;
+}
+
+// src/scripts/hooks/hook_stdin.ts
+var tty = __toESM(require("node:tty"), 1);
+
+// src/scripts/_lib/stdin.ts
+var fs6 = __toESM(require("node:fs"), 1);
+var CHUNK = 64 * 1024;
+var RETRY_SLEEP_MS = 5;
+var MAX_RETRIES = 2e3;
+function _sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+function readStdinText(fd = 0, opts = {}) {
+  const chunks = [];
+  const buf = Buffer.alloc(CHUNK);
+  let retries = 0;
+  let got_any = false;
+  const first_byte_deadline = opts.firstByteTimeoutMs === void 0 ? null : Date.now() + opts.firstByteTimeoutMs;
+  for (; ; ) {
+    let read;
+    try {
+      read = fs6.readSync(fd, buf, 0, CHUNK, null);
+      retries = 0;
+    } catch (exc) {
+      const code = exc.code;
+      if (code === "EAGAIN") {
+        if (!got_any && first_byte_deadline !== null && Date.now() >= first_byte_deadline) {
+          return "";
+        }
+        retries += 1;
+        if (retries > MAX_RETRIES) {
+          throw new Error(
+            `readStdinText: stdin stayed unreadable across ${String(MAX_RETRIES)} retries (~${String(MAX_RETRIES * RETRY_SLEEP_MS / 1e3)}s). Refusing to report an empty read as empty input.`
+          );
+        }
+        _sleepSync(RETRY_SLEEP_MS);
+        continue;
+      }
+      if (code === "EOF") break;
+      throw exc;
+    }
+    if (read === 0) break;
+    got_any = true;
+    chunks.push(Buffer.from(buf.subarray(0, read)));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// src/scripts/hooks/hook_stdin.ts
+var OVERRIDE_KEY = /* @__PURE__ */ Symbol.for("agent-config.hookStdinOverride");
+function host() {
+  return globalThis;
+}
+var HOOK_FIRST_BYTE_TIMEOUT_MS = 25;
+function readFd0ToEnd() {
+  void process.stdin;
+  return readStdinText(0, { firstByteTimeoutMs: HOOK_FIRST_BYTE_TIMEOUT_MS });
+}
+function readHookStdin() {
+  const override = host()[OVERRIDE_KEY];
+  if (override !== null && override !== void 0) return override;
+  try {
+    if (tty.isatty(0)) return "";
+    return readFd0ToEnd();
+  } catch {
+    return "";
+  }
+}
+
+// src/scripts/hooks/state_io.ts
+var REPLAY_ENV_VAR = "AGENT_CONFIG_REPLAY";
+function is_replay_mode() {
+  return (process.env[REPLAY_ENV_VAR] ?? "").trim() === "1";
+}
+
+// src/scripts/hooks/user_notice.ts
+var fs7 = __toESM(require("node:fs"), 1);
+var USER_NOTICE_KEY = "user_notice";
+var USER_NOTICE_ID_KEY = "notice_id";
+var USER_NOTICE_HOSTS = /* @__PURE__ */ new Set(["claude"]);
+function hostShowsUserNotice(platform) {
+  return typeof platform === "string" && USER_NOTICE_HOSTS.has(platform);
+}
+function receiptPath(concern) {
+  return write_target(`user-notice-${concern}.delivered`);
+}
+function readNoticeReceipt(concern) {
+  try {
+    const o = JSON.parse(fs7.readFileSync(receiptPath(concern), "utf-8"));
+    return typeof o["session_id"] === "string" && typeof o["notice_id"] === "string" && typeof o["at"] === "string" ? { session_id: o["session_id"], notice_id: o["notice_id"], at: o["at"] } : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/scripts/update_notice_hook.ts
+var CONCERN = "update-notice";
+var NOTICE_STATE_FILENAME = "update-notice.json";
+var NOTICE_THROTTLE_FILENAME = "update-notice.stamp";
+var VALID_MODES = ["off", "notify", "ask", "auto"];
+var NOTICE_STATE_SCHEMA = 1;
+function readNoticeState(statePath) {
+  try {
+    if (statePath === null) return { staged: null, last_seen_installed: null };
+    const raw = JSON.parse(fs8.readFileSync(statePath, "utf-8"));
+    const o = raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+    if (o["schema"] !== void 0 && o["schema"] !== NOTICE_STATE_SCHEMA) return { staged: null, last_seen_installed: null };
+    const str = (v) => typeof v === "string" && parse_version(v.trim()) !== null ? v.trim() : null;
+    const p = o["pending"];
+    const installed = str(p?.["installed"]);
+    const pending = typeof p?.["session_id"] === "string" && typeof p["notice_id"] === "string" && installed !== null ? { session_id: p["session_id"], notice_id: p["notice_id"], installed } : void 0;
+    return { staged: str(o["staged"]), last_seen_installed: str(o["last_seen_installed"]), ...pending ? { pending } : {} };
+  } catch {
+    return { staged: null, last_seen_installed: null };
+  }
+}
+function confirmDelivered(state, receipt) {
+  const p = state.pending;
+  if (p === void 0 || receipt === null || !receipt.notice_id || receipt.notice_id !== p.notice_id || receipt.session_id !== p.session_id) return state;
+  return { staged: state.staged, last_seen_installed: p.installed };
+}
+function writeNoticeState(statePath, state) {
+  try {
+    write_atomic(statePath, `${JSON.stringify({ schema: NOTICE_STATE_SCHEMA, ...state }, null, 2)}
+`);
+  } catch {
+  }
+}
+function readUpdateMode(paths = user_global_settings_paths()) {
+  let found;
+  for (const p of paths) {
+    try {
+      const doc = (0, import_yaml.parse)(fs8.readFileSync(p, "utf-8"), { version: "1.1" });
+      const block = doc?.["update"];
+      if (block === null || typeof block !== "object" || Array.isArray(block)) continue;
+      const mode = block["mode"];
+      if (typeof mode === "string" && VALID_MODES.includes(mode)) found = mode;
+    } catch {
+    }
+  }
+  return found;
+}
+function readJson(p) {
+  try {
+    const raw = JSON.parse(fs8.readFileSync(p, "utf-8"));
+    return raw !== null && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function readText(p) {
+  try {
+    return fs8.readFileSync(p, "utf-8");
+  } catch {
+    return "";
+  }
+}
+function envelopeField(raw, key) {
+  try {
+    const doc = JSON.parse(raw);
+    const value = doc?.[key];
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+  } catch {
+    return null;
+  }
+}
+function runNotice(deps, apply = true) {
+  const pkg = readJson(path7.join(deps.packageRoot, "package.json"));
+  const installed = typeof pkg["version"] === "string" ? pkg["version"] : "";
+  if (installed === "") return { lines: [], stage: null, activate: null, suppressed: "installed version unreadable" };
+  const probe = deps.probeStatePath === null ? {} : readJson(deps.probeStatePath);
+  const seen = probe["last_seen_version"];
+  const state = confirmDelivered(readNoticeState(deps.noticeStatePath), deps.receipt?.() ?? null);
+  const outcome = updateNotice({
+    installed,
+    candidate: typeof seen === "string" && seen.trim() !== "" ? seen.trim() : null,
+    impactMap: probe["last_seen_impact"] ?? null,
+    mode: deps.mode,
+    origin: originForPackageRoot(deps.packageRoot),
+    env: {
+      ci: ["1", "true"].includes((deps.env["CI"] ?? "").trim().toLowerCase()) || deps.env["GITHUB_ACTIONS"] === "true",
+      interactive: deps.isTty,
+      noUpdateCheck: deps.env["AGENT_CONFIG_NO_UPDATE_CHECK"] === "1"
+    },
+    curatedHead: parseCuratedHead(readText(path7.join(deps.packageRoot, "CHANGELOG.md")), installed),
+    staged: state.staged,
+    lastSeenInstalled: state.last_seen_installed,
+    foreignSessionLive: any_live_session(deps.registerDir, deps.sessionId)
+  });
+  if (!apply) return outcome;
+  if (outcome.suppressed !== null) {
+    if (RECONCILE_REASONS.has(outcome.suppressed) && (state.staged !== null || state.last_seen_installed !== installed)) {
+      writeNoticeState(deps.noticeStatePath, { staged: null, last_seen_installed: installed });
+    }
+    return outcome;
+  }
+  if (deps.notice !== void 0) {
+    const noticeId = (0, import_node_crypto2.randomUUID)();
+    if (outcome.lines.length > 0) {
+      deps.notice.write(JSON.stringify({ [USER_NOTICE_KEY]: outcome.lines.join("\n"), [USER_NOTICE_ID_KEY]: noticeId }));
+    }
+    writeNoticeState(deps.noticeStatePath, {
+      staged: outcome.stage,
+      last_seen_installed: state.last_seen_installed,
+      ...outcome.lines.length > 0 && deps.sessionId ? { pending: { session_id: deps.sessionId, notice_id: noticeId, installed } } : {}
+    });
+    return outcome;
+  }
+  for (const line of outcome.lines) deps.err.write(`[update] ${line}
+`);
+  writeNoticeState(deps.noticeStatePath, { staged: outcome.stage, last_seen_installed: installed });
+  return outcome;
+}
+function noticeOncePerDay(deps) {
+  const dry = runNotice(deps, false);
+  if (dry.suppressed !== null && !RECONCILE_REASONS.has(dry.suppressed)) return null;
+  if (deps.notice !== void 0) {
+    const receipt = deps.receipt?.() ?? null;
+    if (receipt !== null && localDay(new Date(receipt.at)) === localDay(/* @__PURE__ */ new Date())) {
+      const stored = readNoticeState(deps.noticeStatePath);
+      const confirmed = confirmDelivered(stored, receipt);
+      if (confirmed !== stored) writeNoticeState(deps.noticeStatePath, confirmed);
+      if (confirmed.pending === void 0) return null;
+    }
+    return runNotice(deps);
+  }
+  if (ranToday(deps.throttlePath)) return null;
+  const outcome = runNotice(deps);
+  stampToday(deps.throttlePath);
+  return outcome;
+}
+function localDay(d) {
+  return `${String(d.getFullYear())}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function ranToday(throttlePath) {
+  try {
+    const st = fs8.lstatSync(throttlePath);
+    return st.isFile() && localDay(st.mtime) === localDay(/* @__PURE__ */ new Date());
+  } catch {
+    return false;
+  }
+}
+function stampToday(throttlePath) {
+  if (is_replay_mode()) return;
+  try {
+    write_atomic(throttlePath, `${(/* @__PURE__ */ new Date()).toISOString()}
+`);
+  } catch {
+  }
+}
+function packageRootOf() {
+  const env = process.env["AGENT_CONFIG_PACKAGE_ROOT"];
+  if (env) return env;
+  return path7.resolve(path7.dirname((0, import_node_url2.fileURLToPath)(__acChunkMetaUrl)), "..", "..");
+}
+function main(argv) {
+  void argv;
+  const raw = readHookStdin();
+  if (is_replay_mode()) return 0;
+  try {
+    const packageRoot = packageRootOf();
+    const mode = readUpdateMode();
+    const viaHost = envelopeField(raw, "session_id") !== null && hostShowsUserNotice(envelopeField(raw, "platform"));
+    const deps = {
+      packageRoot,
+      sessionId: envelopeField(raw, "session_id"),
+      env: process.env,
+      isTty: viaHost || Boolean(process.stderr.isTTY) || Boolean(process.stdout.isTTY),
+      ...viaHost ? { notice: process.stdout, receipt: () => readNoticeReceipt(CONCERN) } : {},
+      mode,
+      probeStatePath: resolve_with_fallback(STATE_FILENAME),
+      noticeStatePath: write_target(NOTICE_STATE_FILENAME),
+      throttlePath: write_target(NOTICE_THROTTLE_FILENAME),
+      registerDir: global_register_dir(),
+      err: process.stderr
+    };
+    noticeOncePerDay(deps);
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+function _isCliEntry() {
+  if (true) return false;
+  if (process.argv[1] === void 0) return false;
+  if (__acChunkMetaUrl === (0, import_node_url2.pathToFileURL)(path7.resolve(process.argv[1])).href) return true;
+  try {
+    return fs8.realpathSync((0, import_node_url2.fileURLToPath)(__acChunkMetaUrl)) === fs8.realpathSync(path7.resolve(process.argv[1]));
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry()) {
+  process.exit(main(process.argv.slice(2)));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONCERN,
+  NOTICE_STATE_FILENAME,
+  NOTICE_STATE_SCHEMA,
+  NOTICE_THROTTLE_FILENAME,
+  confirmDelivered,
+  main,
+  noticeOncePerDay,
+  ranToday,
+  readNoticeState,
+  readUpdateMode,
+  runNotice,
+  writeNoticeState
+});