ax-audit 3.1.0 → 3.6.0

package/docs/ci.md

@@ -0,0 +1,89 @@
+# CI Integration
+
+ax-audit's exit codes (see [cli.md](./cli.md)) make it a drop-in quality gate: `0` for Good/Excellent, `1` for Fair/Poor or regressions.
+
+## GitHub Actions
+
+### Basic gate
+
+```yaml
+- name: AX Audit
+  run: npx ax-audit https://your-site.com
+  # Fails the step if the score < 70
+```
+
+### Regression gate with a committed baseline
+
+Commit `.ax-baseline.json` to the repo and fail the build only when a check drops:
+
+```yaml
+- name: AX Audit (regression gate)
+  run: npx ax-audit https://your-site.com --baseline .ax-baseline.json --fail-on-regression 5
+```
+
+Refresh the baseline deliberately (e.g., after intentional changes):
+
+```bash
+npx ax-audit https://your-site.com --save-baseline .ax-baseline.json
+git add .ax-baseline.json && git commit -m "chore: refresh AX baseline"
+```
+
+### Markdown report as a PR comment
+
+```yaml
+- name: AX Audit (markdown)
+  run: npx ax-audit ${{ env.PREVIEW_URL }} --output markdown > ax-report.md
+  continue-on-error: true
+
+- name: Comment PR
+  uses: marocchino/sticky-pull-request-comment@v2
+  with:
+    path: ax-report.md
+```
+
+This pairs naturally with Vercel/Netlify preview deployments: audit the preview URL on every PR and the reviewer sees the AX impact inline.
+
+### Artifacts
+
+```yaml
+- name: AX Audit (JSON)
+  run: npx ax-audit https://your-site.com --json > ax-report.json
+
+- uses: actions/upload-artifact@v4
+  with:
+    name: ax-audit-report
+    path: ax-report.json
+```
+
+## Auditing multiple environments
+
+```yaml
+- name: AX Audit (all properties)
+  run: npx ax-audit https://www.your-site.com https://docs.your-site.com https://api.your-site.com --concurrency 3
+  # Exit 1 if any property scores < 70
+```
+
+## Tuning for CI stability
+
+- `--retries 3` absorbs transient 5xx/timeouts from cold preview deployments (default is 2).
+- `--timeout 15000` for slow staging environments.
+- `--checks ...` to gate only on the surface you are iterating on — but remember the overall score then averages only the selected checks.
+
+## Scheduled audits
+
+A weekly audit catches drift from infrastructure changes (CDN settings, WAF rules, header changes deployed by other teams):
+
+```yaml
+on:
+  schedule:
+    - cron: '0 6 * * 1'
+
+jobs:
+  ax-audit:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: npx ax-audit https://your-site.com --baseline .ax-baseline.json --fail-on-regression 0
+```
+
+`--fail-on-regression 0` makes any per-check drop fail the workflow — appropriate for scheduled runs where every change is unexpected.

package/docs/cli.md

@@ -0,0 +1,67 @@
+# CLI Reference
+
+```bash
+ax-audit <urls...> [options]
+```
+
+One or more fully qualified URLs (scheme required). A single URL produces a full report; multiple URLs run in batch mode with a summary table.
+
+## Options
+
+| Flag | Default | Description |
+| --- | --- | --- |
+| `--output <format>` | `terminal` | Output format: `terminal`, `json`, `html`, `markdown`. Invalid values error out. |
+| `--json` | — | Shorthand for `--output json`. |
+| `--checks <list>` | all | Comma-separated check IDs to run (see [checks.md](./checks.md)). Unknown IDs error with the list of valid ones. |
+| `--timeout <ms>` | `10000` | Per-request timeout in milliseconds. |
+| `--retries <n>` | `2` | Retry attempts for transient fetch failures (network errors, timeouts, 408/425/429/5xx) with exponential backoff from 250ms. `0` disables retries. |
+| `--concurrency <n>` | `1` | Batch mode only: maximum URLs audited in parallel. Output order always matches input order. |
+| `--verbose` | — | Log every HTTP request, cache hit, retry, and per-check score to stderr. |
+| `--only-failures` | — | Hide passing findings; checks with only passes are omitted entirely. |
+| `--save-baseline <path>` | — | Save this audit as a baseline JSON file. |
+| `--baseline <path>` | — | Compare against a saved baseline; shows per-check deltas (▲/▼). Single-URL mode only. |
+| `--fail-on-regression <points>` | — | Exit 1 if any check regresses more than N points vs the baseline. Requires `--baseline`. |
+| `-v, --version` | — | Print version. |
+
+## Output formats
+
+- **terminal** — colored report with score bar, per-check sections, and PASS/WARN/FAIL findings.
+- **json** — the full `AuditReport` (plus `baselineDiff` when `--baseline` is used). Stable shape for CI pipelines.
+- **html** — self-contained page (score gauge, dark/light mode, collapsible sections). Pipe to a file: `ax-audit <url> --output html > report.html`.
+- **markdown** — summary table + per-check findings with status emoji. Built for CI logs and PR comments: `ax-audit <url> --output markdown > report.md`.
+
+## Exit codes
+
+| Code | Meaning |
+| --- | --- |
+| `0` | Score ≥ 70 (single), or all URLs ≥ 70 (batch), and no regression beyond the `--fail-on-regression` threshold. |
+| `1` | Score < 70, any batch URL < 70, invalid arguments, or regression beyond threshold. |
+| `2` | Fatal error (network failure on the audit itself, unreadable baseline file). |
+
+## Baseline workflow
+
+```bash
+# First run — record the baseline
+ax-audit https://your-site.com --save-baseline .ax-baseline.json
+
+# Subsequent runs — compare and gate
+ax-audit https://your-site.com --baseline .ax-baseline.json --fail-on-regression 5
+```
+
+The baseline stores the overall score and per-check scores. Checks added after the baseline was saved appear as new (no delta); removed checks are ignored.
+
+## Examples
+
+```bash
+# Quick audit
+npx ax-audit https://your-site.com
+
+# Only the AI-licensing surface
+npx ax-audit https://your-site.com --checks robots-txt,rsl,content-negotiation
+
+# Batch, 4 at a time, machine-readable
+npx ax-audit $(cat urls.txt) --concurrency 4 --json > batch.json
+
+# Show me only what is broken
+npx ax-audit https://your-site.com --only-failures
+```

package/docs/concepts.md

@@ -0,0 +1,87 @@
+# Concepts: the AX standards landscape
+
+"AI Agent Experience" (AX) is the sum of the conventions a site uses to be discovered, read, governed, and transacted with by autonomous AI agents and crawlers — the way "web accessibility" is the sum of conventions for assistive technology. This page maps the standards ax-audit checks against, why each exists, and how they relate. It's the conceptual companion to the mechanical detail in [checks.md](./checks.md).
+
+## Why AX is its own discipline
+
+Agents are not browsers. Three differences drive every check:
+
+1. **They mostly don't run JavaScript.** GPTBot, ClaudeBot, CCBot and most crawlers fetch raw HTML. A client-rendered SPA that returns an empty `<div id="root">` is, to them, a blank page. (`html-rendering`, `content-negotiation`)
+2. **They look for declared structure, not visual layout.** An agent would rather read a `/llms.txt` summary or a JSON-LD graph than infer meaning from your CSS grid. (`llms-txt`, `structured-data`, `meta-tags`, `agent-json`, `mcp`, `openapi`)
+3. **Their access is a policy and economic question, not just a technical one.** Who may crawl, for what use, at what price, under what license — these now have machine-readable answers. (`robots-txt`, Content Signals, `rsl`, `agent-access`)
+
+Bot traffic is projected to exceed human traffic by 2029. AX is the interface layer for that shift.
+
+## The four families of standards
+
+### 1. Content discovery & readability
+
+| Standard | What it is | Check |
+| --- | --- | --- |
+| **[llms.txt](https://llmstxt.org)** | A Markdown file at your root summarizing your site for LLMs, with curated links. The "sitemap for AI." | `llms-txt` |
+| **Server-side rendering** | Delivering real content in the HTML response, not assembling it client-side. | `html-rendering` |
+| **[Markdown for Agents](https://developers.cloudflare.com/fundamentals/reference/markdown-for-agents/)** | Content negotiation: serve clean Markdown when a client sends `Accept: text/markdown`. ~80% fewer tokens than HTML. | `content-negotiation` |
+| **schema.org / JSON-LD** | Structured data describing entities (Person, Organization, Product) in a graph agents can parse. | `structured-data` |
+| **Sitemaps** | The classic XML index, still how crawlers enumerate your URLs. | `sitemap` |
+
+These answer: *can an agent find your content and actually read it?*
+
+### 2. Agent interaction surface
+
+| Standard | What it is | Check |
+| --- | --- | --- |
+| **[A2A — Agent2Agent](https://a2a-protocol.org)** | An "Agent Card" at `/.well-known/agent.json` advertising your agent's identity and skills, so other agents can interoperate. | `agent-json` |
+| **[MCP — Model Context Protocol](https://modelcontextprotocol.io)** | A manifest at `/.well-known/mcp.json` describing tools and resources an agent can call. The emerging standard for exposing capabilities to LLMs. | `mcp` |
+| **[OpenAPI](https://www.openapis.org)** | The long-standing machine-readable API description; agents use it to call your endpoints. | `openapi` |
+| **Emerging discovery files** | `ai.txt`, `genai.txt`, `ai-plugin.json`, `agents.json`, `nlweb.json` — competing/early conventions, scored as coverage bonus. | `well-known-ai` |
+| **AI meta tags & discovery links** | `ai:*` meta tags and `rel="alternate"` links pointing agents to your llms.txt / agent.json. | `meta-tags` |
+
+These answer: *once an agent arrives, can it understand what you offer and act on it?*
+
+### 3. Access governance & licensing
+
+This is the newest and fastest-moving family — the response to "AI scraped my content and now competes with me."
+
+| Standard | What it is | Check |
+| --- | --- | --- |
+| **[Robots Exclusion Protocol](https://www.rfc-editor.org/rfc/rfc9309.html)** | The original robots.txt — *who* may crawl *what*. ax-audit grades coverage of 48 known AI crawlers. | `robots-txt` |
+| **[Content Signals](https://contentsignals.org)** | A robots.txt extension (Cloudflare, CC0) declaring *how* content may be used after access: `search`, `ai-input`, `ai-train`. Served by default on 3.8M+ Cloudflare domains. | `robots-txt` (findings) |
+| **[RSL — Really Simple Licensing](https://rslstandard.org)** | A full machine-readable licensing layer (license.xml): permits/prohibits vocabularies, payment models (free, attribution, pay-per-crawl, pay-per-inference). Endorsed by 1,500+ publishers. | `rsl` |
+| **Cloaking integrity** | Not a standard but a failure mode: your stated policy (robots.txt allows GPTBot) contradicting enforcement (WAF returns 403). | `agent-access` |
+
+These answer: *have you expressed your access and usage policy in a form agents can honor — and does your infrastructure actually match it?*
+
+The progression is one of increasing expressiveness: robots.txt says **who/where**, Content Signals adds **how it may be used**, RSL adds **under what license and price**.
+
+### 4. Transport, efficiency & hygiene
+
+| Standard | What it is | Check |
+| --- | --- | --- |
+| **TLS / HSTS** | HTTPS everywhere; many agents refuse plaintext origins. | `tls-https` |
+| **HTTP security & discovery headers** | Security headers plus `Link` headers advertising your AI files. | `http-headers` |
+| **Compression & conditional GET** | Brotli/gzip and `ETag`/`304` — crawl cost matters when bots dominate traffic. | `crawl-efficiency` |
+| **[RFC 9116 security.txt](https://www.rfc-editor.org/rfc/rfc9116)** | A machine-readable security contact. | `security-txt` |
+| **SEO basics** | Title, description, canonical, lang, hreflang — agents use the same head-tag fundamentals search engines do. | `seo-basics` |
+
+These answer: *is the connection trustworthy, cheap, and well-formed?*
+
+## On the horizon (not yet scored)
+
+Two standards are maturing and worth watching:
+
+- **[Web Bot Auth](https://datatracker.ietf.org/doc/draft-meunier-web-bot-auth-architecture/)** — cryptographic crawler verification via HTTP Message Signatures (RFC 9421). Bots sign requests with a key published at `/.well-known/http-message-signatures-directory`; sites verify identity instead of guessing from user-agent strings. Already implemented by Cloudflare and Google (`agent.bot.goog`). It directly affects the `agent-access` check: a WAF using Web Bot Auth may pass a real, signed crawler while rejecting ax-audit's unsigned probe — which is why that check's findings carry an explicit verified-bots caveat.
+- **Pay-per-crawl / HTTP 402** — Cloudflare and the RSL payment vocabulary point toward metered, paid agent access. RSL already encodes the terms; enforcement protocols (Open License Protocol, x402) are emerging.
+
+## How the families compose
+
+A fully AX-ready site tells a coherent story across all four:
+
+> "Here's my content in a form you can read **(family 1)**, here's the interface to interact with me **(family 2)**, here's exactly who may use it and how, for what license **(family 3)**, over a fast and trustworthy connection **(family 4)**."
+
+ax-audit's weighting reflects today's leverage: discovery and readability (`llms-txt`, `robots-txt`, `html-rendering`, `structured-data`, `http-headers`) carry the most weight because they're the highest-impact, most-adopted signals. The governance and efficiency standards are informational in 3.x — real and worth adopting, but still stabilizing — and gain weight in v4.0.
+
+## See also
+
+- [getting-started.md](./getting-started.md) — run your first audit
+- [checks.md](./checks.md) — exact scoring per standard
+- The [remediation guides](https://lucioduran.com/projects/ax-audit/guides) — how to implement each one

package/docs/faq.md

@@ -0,0 +1,77 @@
+# FAQ & Troubleshooting
+
+## Scores & results
+
+### Why did my score change after upgrading ax-audit?
+
+In 3.x, score changes on the same site are treated as **breaking** and only happen in major or minor releases that explicitly say so. The 3.0.0 release redistributed weights across 14 checks and added Content-Type penalties — see its CHANGELOG entry. Every check added since (3.1.0–3.6.0) ships at **weight 0** precisely so your score and baselines don't move. To track changes deliberately, use `--baseline` (see [cli.md](./cli.md)).
+
+### Why is my score lower than my Lighthouse / SEO score?
+
+ax-audit measures the *AI-agent* surface, not performance, accessibility, or human SEO. A fast, beautiful site can still score poorly if it has no `llms.txt`, ships an empty SPA shell to non-JS crawlers, and exposes no structured data. That gap is the reason the tool exists.
+
+### A check shows 0 but the file exists — why?
+
+Most "not found" hard-fails mean the request didn't return a 2xx. Common causes: the file is served with a redirect chain that breaks, a non-2xx status, or — most often — a WAF/bot-rule blocking ax-audit's request (see below). Re-run with `--verbose` to see the exact status per request.
+
+### What's the difference between a weighted and an informational check?
+
+Weighted checks (14) sum to 100% and determine your overall score. Informational checks (4: `content-negotiation`, `rsl`, `agent-access`, `crawl-efficiency`) run and report full findings but contribute 0 to the score in 3.x. They gain weight in v4.0. The Content Signals findings inside `robots-txt` are likewise informational.
+
+## False positives & caveats
+
+### `agent-access` flags crawlers as blocked, but my real crawlers work fine
+
+This is the most important caveat in the tool. ax-audit's probe sends a user-agent *containing* the crawler token (e.g. `...GPTBot/1.0`) but it is **not** the real, verified crawler. If your WAF verifies bots cryptographically ([Web Bot Auth](./concepts.md)) or by IP range, it will correctly pass the genuine GPTBot while rejecting ax-audit's unverified probe. **Before changing any WAF rule, confirm against your WAF logs** whether real crawler traffic is actually being served. If it is, this finding is a false positive for your setup.
+
+### `well-known-ai` is low — should I worry?
+
+No. It's scored as *coverage bonus* over five emerging, partly-competing files (`ai.txt`, `genai.txt`, `ai-plugin.json`, `agents.json`, `nlweb.json`). None is universally adopted; a low score here is not a defect. Implement the ones relevant to your stack.
+
+### `crawl-efficiency` says no compression, but my CDN compresses
+
+The check reads the `Content-Encoding` header on the response it received. If a proxy between ax-audit and your origin strips or fails to negotiate compression, you'll see this. Verify directly: `curl -sI -H 'Accept-Encoding: br, gzip' https://your-site.com | grep -i content-encoding`.
+
+### `content-negotiation` fails but I don't serve Markdown
+
+That's expected — most sites don't yet. It's informational (weight 0). Adopt it when you're ready; the [guide](https://lucioduran.com/projects/ax-audit/guides/content-negotiation) covers Cloudflare/Vercel zero-code options.
+
+## Running the tool
+
+### My WAF is blocking ax-audit itself
+
+ax-audit sends a `User-Agent` of `ax-audit/<version> (+https://github.com/lucioduran/ax-audit)`. If your firewall challenges unknown agents, allowlist that UA (or the IP you run from) for the duration of the audit. Note that several checks deliberately send *other* user-agents (`agent-access`) and unusual `Accept` headers (`content-negotiation`) — a WAF rejecting those is itself a finding, not a tool bug.
+
+### How do I audit a staging site behind auth?
+
+ax-audit has no auth support today. Options: run it from inside the network perimeter, temporarily allowlist its UA/IP, or audit a public preview deployment (the typical CI pattern — see [ci.md](./ci.md)).
+
+### Audits are slow / flaky on cold deployments
+
+Transient failures (timeouts, 5xx) retry automatically with backoff — raise `--retries` (default 2) for very cold preview environments and `--timeout` (default 10000ms) for slow origins. In batch mode, `--concurrency` speeds up multi-URL runs.
+
+### Can I run only some checks?
+
+Yes: `--checks llms-txt,robots-txt,rsl`. Note the overall score then averages *only* those checks, so a subset run isn't comparable to a full-audit score. Unknown IDs error out with the valid list.
+
+### Is there rate limiting I should know about?
+
+The tool itself doesn't rate-limit, but it makes several requests per audit (one per check, plus follow-ups for conditional GET, content negotiation, and the 8 `agent-access` probes). All responses are cached per run, so repeated checks of the same URL don't re-fetch. Be considerate auditing sites you don't own.
+
+## Integration
+
+### Does it work in CI?
+
+Yes — exit codes gate the build (`0` = Good/Excellent, `1` = Fair/Poor). See [ci.md](./ci.md) for GitHub Actions recipes including PR comments via `--output markdown` and regression gates via `--baseline`.
+
+### Can I consume results programmatically?
+
+Yes — `import { audit } from 'ax-audit'` returns a typed `AuditReport`. See [api.md](./api.md).
+
+### How do I generate the files ax-audit checks for?
+
+Use [ax-init](https://github.com/lucioduran/ax-init) — it generates `llms.txt`, `robots.txt`, `agent.json`, `mcp.json`, `security.txt`, structured data, and header snippets, then you verify with `npx ax-audit`.
+
+## Still stuck?
+
+Open an issue at [github.com/lucioduran/ax-audit/issues](https://github.com/lucioduran/ax-audit/issues) with the output of `npx ax-audit <url> --verbose`.

package/docs/getting-started.md

@@ -0,0 +1,101 @@
+# Getting Started
+
+This walkthrough takes you from zero to a passing AX score: run your first audit, learn to read the report, and fix findings in the order that moves your score most.
+
+## 1. Run your first audit
+
+No install needed:
+
+```bash
+npx ax-audit https://your-site.com
+```
+
+You get a report like:
+
+```
+  AX Audit Report
+  https://your-site.com
+
+  ██████████████████████░░░░░░░░░░░░░░░░░░  56/100  Fair
+
+  LLMs.txt (0/100)
+    FAIL  /llms.txt not found
+  ...
+```
+
+Three things to locate immediately:
+
+- **The overall score and grade.** 0–100, weighted across 14 checks. Grades: Excellent (≥90), Good (≥70), Fair (≥50), Poor (<50). The CLI exits `0` at Good or better — that is the CI gate.
+- **Per-check scores.** Each check is independent and scored 0–100. The weight of each check is in [checks.md](./checks.md).
+- **Findings.** Every `WARN`/`FAIL` line carries a hint and a `learnMoreUrl` to a remediation guide with copy-pasteable fixes.
+
+To see only what needs fixing:
+
+```bash
+npx ax-audit https://your-site.com --only-failures
+```
+
+## 2. Understand what you're optimizing
+
+AI agents interact with your site differently than browsers: most don't execute JavaScript, they look for machine-readable discovery files, and they respect (or at least read) your declared crawler policy. The audit measures three layers — if you're new to the standards involved (llms.txt, A2A, MCP, RSL, Content Signals), read [concepts.md](./concepts.md) first:
+
+1. **Can agents find and read your content?** (`html-rendering`, `robots-txt`, `sitemap`, `tls-https`, `agent-access`)
+2. **Did you publish the AI-specific surface?** (`llms-txt`, `agent-json`, `mcp`, `openapi`, `well-known-ai`, `meta-tags`, `structured-data`)
+3. **Is the interaction efficient and well-governed?** (`content-negotiation`, `crawl-efficiency`, `rsl`, Content Signals, `http-headers`, `security-txt`, `seo-basics`)
+
+## 3. Fix in impact order
+
+The fastest path from Fair to Good, by weight and typical effort:
+
+| Step | Check | Weight | Typical effort |
+| --- | --- | --- | --- |
+| 1 | Create `/llms.txt` | 11% | 30 minutes — it's a Markdown file. `npx ax-init` generates it. |
+| 2 | Configure `robots.txt` for the 8 core AI crawlers | 11% | 15 minutes; `npx ax-init` generates this too |
+| 3 | Verify server-rendered content | 9% | Free if you SSR; significant if you ship an SPA shell |
+| 4 | Add JSON-LD structured data | 9% | 1–2 hours |
+| 5 | Security + discovery headers | 9% | 30 minutes of server config |
+| 6 | `agent.json` + `mcp.json` | 14% combined | An hour with the spec links in the guides |
+
+The remaining weighted checks (`seo-basics`, `security-txt`, `meta-tags`, `openapi`, `tls-https`, `sitemap`, `well-known-ai`) are mostly configuration; the remediation guides give exact snippets for Nginx, Vercel, Netlify, and Express.
+
+Re-run after each fix — all requests are cached per run, so audits are fast and cheap.
+
+## 4. Lock in your progress with a baseline
+
+Once you reach a score you're happy with, freeze it:
+
+```bash
+npx ax-audit https://your-site.com --save-baseline .ax-baseline.json
+git add .ax-baseline.json && git commit -m "chore: AX baseline"
+```
+
+From then on, compare every run against it:
+
+```bash
+npx ax-audit https://your-site.com --baseline .ax-baseline.json --fail-on-regression 5
+```
+
+This catches drift you didn't cause — a CDN toggle, a WAF rule, a header dropped in a refactor. Wire it into CI with the recipes in [ci.md](./ci.md).
+
+## 5. Look at the informational checks
+
+Four checks report findings without affecting your score yet (they will in v4.0): `content-negotiation`, `rsl`, `agent-access`, `crawl-efficiency`. Treat them as the early-warning lane — they cover the newest standards, and fixing them now means v4.0 changes nothing for you.
+
+The one to check first is `agent-access`: it detects the failure mode you cannot see — your robots.txt allows GPTBot while your WAF returns it a 403:
+
+```bash
+npx ax-audit https://your-site.com --checks agent-access
+```
+
+## Common first-run questions
+
+- **"My score seems harsh."** The audit measures the AI-agent surface, not site quality. A beautiful SPA with no llms.txt, no structured data, and an empty `#root` div is genuinely poor AX — that's the point of the tool.
+- **"A check crashed / network error."** Transient failures retry automatically (`--retries`, default 2). For slow staging environments raise `--timeout`.
+- **"Which findings are safe to ignore?"** See the [FAQ](./faq.md) — notably the `agent-access` verified-bots caveat and `well-known-ai`, which is coverage bonus rather than baseline.
+
+## Next steps
+
+- [checks.md](./checks.md) — exact scoring of all 18 checks
+- [concepts.md](./concepts.md) — the AX standards landscape explained
+- [cli.md](./cli.md) — every flag · [ci.md](./ci.md) — CI recipes · [api.md](./api.md) — programmatic use
+- [ax-init](https://github.com/lucioduran/ax-init) — generates most of the files this tool audits

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ax-audit",
-  "version": "3.1.0",
+  "version": "3.6.0",
   "description": "Audit websites for AI Agent Experience (AX) readiness. Lighthouse for AI Agents.",
   "type": "module",
   "license": "Apache-2.0",
@@ -40,6 +40,7 @@
   "files": [
     "bin/",
     "dist/",
+    "docs/",
     "LICENSE",
     "README.md",
     "CHANGELOG.md"