@@ -39,6 +39,7 @@ import { licenceTerms, listStackFiles, owes, parseStack, pickPath } from "./lib/
 import { createDistWriter } from "./lib/dist-writer.mjs";
 import { serviceWorkerJs, webManifest } from "./lib/offline.mjs";
 import { auditPageHtml } from "./lib/audit-page.mjs";
+import { changeEventsFromLog, changesFeedXml } from "./lib/changes.mjs";
 import { ATTRIBUTION_RANK, categoryChipsHtml, guideRowsHtml, headMetaHtml, licenseFamily, notFoundHtml, robotsTxt, stackRowsHtml, starterRowsHtml } from "./lib/home-page.mjs";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -141,31 +142,48 @@ function loadEntries(vocab) {
  * git is unavailable (a tarball); a shallow checkout dates every file to HEAD.
  */
 function lastCommitDates() {
+  // No git: the sitemap falls back to the build date.
+  const dates = gitCached("fgda-commit-dates.json", DATED_PATHS.join(","), (git) =>
+    Object.fromEntries(commitDatesFromLog(git(["log", "--format=%x00%cs", "--name-only", "--", ...DATED_PATHS])))
+  );
+  return new Map(Object.entries(dates || {}));
+}
+
+/** Entry id => its recorded licence changes (lib/changes.mjs, #186); empty without git. */
+function licenceChanges() {
+  const events = gitCached("fgda-licence-changes.json", "catalog", (git) =>
+    Object.fromEntries(changeEventsFromLog(git(["log", "--reverse", "-p", "-M", "--unified=0", "--format=%x00%H %cs", "--", "catalog"])))
+  );
+  return new Map(Object.entries(events || {}));
+}
+
+/**
+ * `compute(git)` over the commits, cached per HEAD inside .git (never
+ * published, never committed): a no-change rebuild skips full-history logs,
+ * whose cost grows with every commit (#262). null when git is unavailable.
+ */
+function gitCached(name, keyExtra, compute) {
   const git = (args) =>
-    execFileSync("git", args, { cwd: ROOT, encoding: "utf8", maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+    execFileSync("git", args, { cwd: ROOT, encoding: "utf8", maxBuffer: 512 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
   try {
-    // The dates depend only on the commits, so they are cached per HEAD inside
-    // .git (never published, never committed): a no-change rebuild skips the
-    // full-history log, whose cost grows with every commit (#262).
     const [gitDir, head] = git(["rev-parse", "--git-dir", "HEAD"]).trim().split("\n");
-    const cacheFile = path.resolve(ROOT, gitDir, "fgda-commit-dates.json");
-    const key = `${head} ${DATED_PATHS.join(",")}`;
+    const cacheFile = path.resolve(ROOT, gitDir, name);
+    const key = `${head} ${keyExtra}`;
     try {
       const cached = JSON.parse(fs.readFileSync(cacheFile, "utf8"));
-      if (cached.key === key) return new Map(Object.entries(cached.dates));
+      if (cached.key === key && "value" in cached) return cached.value;
     } catch {
       // No cache yet, or an unreadable one: rebuild it below.
     }
-    const dates = commitDatesFromLog(git(["log", "--format=%x00%cs", "--name-only", "--", ...DATED_PATHS]));
+    const value = compute(git);
     try {
-      fs.writeFileSync(cacheFile, JSON.stringify({ key, dates: Object.fromEntries(dates) }));
+      fs.writeFileSync(cacheFile, JSON.stringify({ key, value }));
     } catch {
       // A read-only .git still builds; it just reads the log every time.
     }
-    return dates;
+    return value;
   } catch {
-    // No git: the sitemap falls back to the build date.
-    return new Map();
+    return null;
   }
 }
 
@@ -578,6 +596,11 @@ function main() {
   writeOut(path.join("audit", "index.html"), auditPageHtml({ site: config.site, stamp, total: stats.listed, hasCard }));
 
   const pages = writeEntryPages({ entries, bodies, config, stats, stamp, hasCard, now, usedIn });
+  // One licence-change feed per entry, beside its page (#186).
+  const changes = licenceChanges();
+  for (const entry of entries) {
+    writeOut(path.join("entry", entry.id, "changes.xml"), changesFeedXml({ entry, events: changes.get(entry.id) || [], siteUrl: config.site.siteUrl, generatedAt: payload.generatedAt }));
+  }
   const stackPages = writeStackPages({ stacks, entries, config, stats, stamp, hasCard, now });
   const categoryPages = writeCategoryPages({ entries: visible, config, stats, stamp, hasCard, now });
   const guidePages = writeGuidePages({ entries, config, stats, stamp, hasCard, modified });
 
@@ -0,0 +1,89 @@
+/**
+ * Licence changes per entry, from git history (#186): when an entry's
+ * `license`, `commercial`, `attribution_required` or `status` changed, and
+ * from what to what. The build publishes them as one Atom feed per entry
+ * (entry/<id>/changes.xml), and the shortlist bundles its entries' feeds
+ * as OPML, so a reader can follow the terms of the assets their game uses.
+ * Pure; build.mjs runs git.
+ */
+import { esc } from "./shared.mjs";
+
+export const WATCHED_FIELDS = ["license", "commercial", "attribution_required", "status"];
+const FIELD_RE = new RegExp(`^([+-])(${WATCHED_FIELDS.join("|")}):\\s*(.*?)\\s*$`);
+
+/**
+ * Entry id => [{ date, commit, field, from, to }], oldest first, from
+ * `git log --reverse -p -M --unified=0 --format=%x00%H %cs -- catalog`.
+ * Entries are keyed by file name, so a category move keeps its history. A
+ * file's first commit is its creation, not a change, and is skipped.
+ */
+export function changeEventsFromLog(log) {
+  const events = new Map();
+  const seen = new Set();
+  let commit = null;
+  let date = null;
+  let id = null;
+  let isNew = false;
+  let removed = {};
+  const flush = () => {
+    removed = {};
+  };
+  for (const line of String(log).split("\n")) {
+    if (line.startsWith("\0")) {
+      [commit, date] = line.slice(1).trim().split(" ");
+      id = null;
+      flush();
+      continue;
+    }
+    if (line.startsWith("diff --git ")) {
+      const m = line.match(/ b\/catalog\/[^/]+\/([^/]+)\.md$/);
+      id = m && m[1] !== "README" && m[1] !== "TEMPLATE" ? m[1] : null;
+      isNew = Boolean(id) && !seen.has(id);
+      if (id) seen.add(id);
+      flush();
+      continue;
+    }
+    if (!id || isNew) continue;
+    const m = line.match(FIELD_RE);
+    if (!m) continue;
+    const [, sign, field, value] = m;
+    if (sign === "-") removed[field] = value;
+    else if (field in removed && removed[field] !== value) {
+      if (!events.has(id)) events.set(id, []);
+      events.get(id).push({ date, commit, field, from: removed[field], to: value });
+      delete removed[field];
+    }
+  }
+  return events;
+}
+
+const LABEL = { license: "Licence", commercial: "Commercial use", attribution_required: "Credit required", status: "Status" };
+
+/** One entry's changes.xml: newest change first; an entry with none is a valid, empty feed. */
+export function changesFeedXml({ entry, events = [], siteUrl, generatedAt }) {
+  const base = String(siteUrl).replace(/\/+$/, "");
+  const page = `${base}/entry/${entry.id}/`;
+  const feedUrl = `${page}changes.xml`;
+  const items = [...events].reverse().map((e) => {
+    const title = `${entry.name}: ${LABEL[e.field] || e.field} ${e.from} → ${e.to}`;
+    return `  <entry>
+    <id>${esc(`${feedUrl}#${e.commit}-${e.field}`)}</id>
+    <title>${esc(title)}</title>
+    <updated>${esc(e.date)}T00:00:00Z</updated>
+    <link href="${esc(page)}" />
+    <summary>${esc(`${title}, recorded ${e.date}. The entry page quotes the source.`)}</summary>
+  </entry>`;
+  });
+  const updated = events.length ? `${events[events.length - 1].date}T00:00:00Z` : generatedAt;
+  return `<?xml version="1.0" encoding="utf-8"?>
+<feed xmlns="http://www.w3.org/2005/Atom">
+  <id>${esc(feedUrl)}</id>
+  <title>${esc(`${entry.name}: licence changes`)}</title>
+  <subtitle>Changes to the licence, commercial use, credit requirement or status recorded for this source.</subtitle>
+  <updated>${esc(updated)}</updated>
+  <link rel="self" href="${esc(feedUrl)}" />
+  <link href="${esc(page)}" />
+${items.join("\n")}
+</feed>
+`;
+}
@@ -42,3 +42,17 @@ export function backLinkHref(qs) {
   if (!qs || !/^[\w.~%+=&-]+$/.test(qs)) return null;
   return `../../?${qs}#catalog`;
 }
+
+/** An OPML bundle of the change feeds of `entries`, for a feed reader to import in one step. */
+export function changesOpml(entries, siteUrl, title = "Free Game Dev Assets: licence changes") {
+  const base = String(siteUrl).replace(/\/+$/, "");
+  const esx = (s) => escapeHtml(s);
+  return `<?xml version="1.0" encoding="utf-8"?>
+<opml version="2.0">
+  <head><title>${esx(title)}</title></head>
+  <body>
+${entries.map((e) => `    <outline type="rss" text="${esx(e.name)}" title="${esx(e.name)}" xmlUrl="${esx(`${base}/entry/${e.id}/changes.xml`)}" htmlUrl="${esx(`${base}/entry/${e.id}/`)}" />`).join("\n")}
+  </body>
+</opml>
+`;
+}
@@ -175,6 +175,7 @@ export function entryPageHtml({ entry, leadHtml, restHtml, deprecatedReasonHtml,
         ${c.block}
       </section>
       <p class="page-actions"><a class="btn" href="${esc(entry.url)}" rel="noopener noreferrer">Go to source</a></p>
+      <p class="entry-feed"><a href="changes.xml" type="application/atom+xml">Follow licence changes</a> (an Atom feed of changes to this licence, its commercial use, credit or status)</p>
       <p class="page-links">
         <a href="${esc(`${repo}/blob/main/${entry.path}`)}" rel="noopener noreferrer">View the file on GitHub</a>
         <a href="${esc(issue)}" rel="noopener noreferrer">Report a problem with this entry</a>
 
@@ -2630,6 +2630,46 @@ await section("catalog queries, CLI and MCP (#115)", async () => {
   }
 });
 
+/* licence-change feeds (#186) --------------------------------------------- */
+await section("licence-change feeds (#186)", async () => {
+  const { changeEventsFromLog, changesFeedXml } = await import("./changes.mjs");
+  const { changesOpml } = await import("./client-state.mjs");
+  const log = [
+    "\0aaa 2026-07-01",
+    "diff --git a/catalog/2d/a.md b/catalog/2d/a.md",
+    "+license: CC0",
+    "+status: needs-review",
+    "\0bbb 2026-08-01",
+    "diff --git a/catalog/2d/a.md b/catalog/3d/a.md",
+    "-license: CC0",
+    "+license: CC-BY-4.0",
+    "-status: needs-review",
+    "+status: needs-review",
+    "-verified: 2026-07-01",
+    "+verified: 2026-08-01",
+    "diff --git a/catalog/2d/README.md b/catalog/2d/README.md",
+    "-status: x",
+    "+status: y",
+    "\0ccc 2026-09-01",
+    "diff --git a/catalog/3d/a.md b/catalog/3d/a.md",
+    "-commercial: true",
+    "+commercial: false",
+  ].join("\n");
+  const ev = changeEventsFromLog(log);
+  eq("changes: the creating commit is not a change", (ev.get("a") || []).some((e) => e.commit === "aaa"), false);
+  eq("changes: a moved file keeps its history, unchanged values skipped", ev.get("a").map((e) => `${e.date} ${e.field} ${e.from}>${e.to}`).join("|"), "2026-08-01 license CC0>CC-BY-4.0|2026-09-01 commercial true>false");
+  eq("changes: README files are not entries", ev.has("README"), false);
+  const feed = changesFeedXml({ entry: { id: "a", name: "A & B" }, events: ev.get("a"), siteUrl: "https://x.test/s/", generatedAt: "2026-11-07T00:00:00Z" });
+  has("feed: newest first", feed.indexOf("Commercial use true → false") < feed.indexOf("Licence CC0 → CC-BY-4.0") ? "ok" : "no", "ok");
+  has("feed: self link", feed, '<link rel="self" href="https://x.test/s/entry/a/changes.xml" />');
+  has("feed: escaped title", feed, "A &amp; B: licence changes");
+  has("feed: updated is the last change", feed, "<updated>2026-09-01T00:00:00Z</updated>");
+  has("feed: an entry without changes is a valid empty feed", changesFeedXml({ entry: { id: "z", name: "Z" }, events: [], siteUrl: "https://x.test/s/", generatedAt: "2026-11-07T00:00:00Z" }), "<updated>2026-11-07T00:00:00Z</updated>");
+  const opml = changesOpml([{ id: "a", name: "A <1>" }, { id: "b", name: "B" }], "https://x.test/s/");
+  has("opml: one outline per entry", opml, 'xmlUrl="https://x.test/s/entry/b/changes.xml"');
+  has("opml: names escaped", opml, 'text="A &lt;1&gt;"');
+});
+
 /* report (keep last) ------------------------------------------------------ */
 if (failures.length) {
   console.error(`lib.test failed (${failures.length}):`);
 
@@ -193,6 +193,7 @@ <h3 id="shortlist-title">Your shortlist (<span id="shortlist-count">0</span>)</h
           <p class="shortlist-actions">
             <button type="button" class="btn-ghost" data-shortlist-action="md">Download CREDITS.md</button>
             <button type="button" class="btn-ghost" data-shortlist-action="txt">Download CREDITS.txt</button>
+            <button type="button" class="btn-ghost" data-shortlist-action="opml" title="Import into a feed reader to hear when any of these licences changes">Follow licence changes (OPML)</button>
             <button type="button" class="link-button" data-shortlist-action="clear">Clear shortlist</button>
           </p>
           <p class="filter-note" id="shortlist-storage" hidden>This browser is not saving site data, so the shortlist lasts only until you leave the page.</p>
 
@@ -4,7 +4,7 @@
  * same code as the stack pages' "What this stack owes" (owes.js).
  */
 import { creditsFile, owes, owesGroups } from "./owes.js";
-import { escapeHtml, parseShortlist } from "./client-state.js";
+import { changesOpml, escapeHtml, parseShortlist } from "./client-state.js";
 
 const KEY = "fgda:shortlist";
 
@@ -157,6 +157,10 @@ document.addEventListener("click", (e) => {
   if (!action) return;
   const what = action.getAttribute("data-shortlist-action");
   if (what === "md" || what === "txt") exportFile(what);
+  if (what === "opml") {
+    const siteUrl = data.site?.siteUrl || "";
+    download("licence-changes.opml", changesOpml(ids.map((id) => byId[id]), siteUrl), "text/x-opml");
+  }
   if (what === "clear") {
     update([]);
     announce("Shortlist cleared");