jekyll-theme-zer0 1.27.0 → 1.29.0

data/scripts/propagate.rb

@@ -0,0 +1,277 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# =============================================================================
+# scripts/propagate.rb — theme release fan-out
+# =============================================================================
+#
+# Reads _data/consumers.yml (the downstream registry) and either REPORTS which
+# consumers have drifted behind the current theme version, or DISPATCHES a
+# `theme-release` event to each one so it opens its own bump PR.
+#
+# The problem this solves: a release used to end at RubyGems. Nothing told the
+# five sites built on this theme that a new version existed, so their pins sat
+# where someone last edited them by hand — all of them a full minor behind when
+# 1.27.0 shipped.
+#
+# Dispatch, rather than this repo opening PRs directly, because every consumer
+# gates differently: it-journey runs `make build-ci` + `make content-audit`,
+# bashconsultants builds in Docker and runs its editorial lint, the org hubs
+# re-roll member configs with provision-org-sites.rb. Each repo owns its own
+# validation; this script only announces the release.
+#
+# Usage:
+#   ruby scripts/propagate.rb                    # report drift (default)
+#   ruby scripts/propagate.rb --format json      # machine-readable report
+#   ruby scripts/propagate.rb --strict           # exit 1 if any consumer is behind
+#   ruby scripts/propagate.rb --dispatch         # fire theme-release events
+#   ruby scripts/propagate.rb --dispatch --dry-run
+#
+# Auth: uses `gh` when available, else GH_TOKEN / GITHUB_TOKEN / LIFECYCLE_PAT
+# against the REST API. Reporting works unauthenticated for public repos;
+# --dispatch always needs a token with `repo` scope on the target.
+# =============================================================================
+
+require 'yaml'
+require 'json'
+require 'net/http'
+require 'uri'
+require 'optparse'
+require 'base64'
+
+REPO_ROOT = File.expand_path('..', __dir__)
+REGISTRY  = File.join(REPO_ROOT, '_data', 'consumers.yml')
+VERSION_RB = File.join(REPO_ROOT, 'lib', 'jekyll-theme-zer0', 'version.rb')
+
+# Version-bearing patterns per pin kind. `theme_name` and `path_gem` carry no
+# version by design — they are tracked so a bump does not miss the file that
+# activates the theme, but they never report drift.
+PIN_PATTERNS = {
+  'remote_theme' => /remote_theme\s*:\s*["']?bamr87\/zer0-mistakes(?:@v?([0-9][^"'\s]*))?/,
+  'hub_registry' => /theme_repo\s*:\s*["']?bamr87\/zer0-mistakes(?:@v?([0-9][^"'\s]*))?/,
+  'gem_constraint' => /gem\s+["']jekyll-theme-zer0["']\s*,\s*["'][^0-9]*([0-9][^"']*)["']/,
+  'theme_name' => nil,
+  'path_gem' => nil
+}.freeze
+
+options = {
+  format: 'text', strict: false, dispatch: false, dry_run: false, version: nil
+}
+
+OptionParser.new do |o|
+  o.banner = 'Usage: ruby scripts/propagate.rb [options]'
+  o.on('--dispatch', 'Send theme-release events instead of reporting') { options[:dispatch] = true }
+  o.on('--dry-run', 'Show what --dispatch would send; send nothing') { options[:dry_run] = true }
+  o.on('--strict', 'Exit 1 when a consumer is behind the current version') { options[:strict] = true }
+  o.on('--format FMT', %w[text json github], 'Output format (text|json|github)') { |v| options[:format] = v }
+  o.on('--version VER', 'Theme version to compare against (default: version.rb)') { |v| options[:version] = v }
+  o.on('-h', '--help', 'Show this help') { puts o; exit 0 }
+end.parse!
+
+# -----------------------------------------------------------------------------
+def theme_version
+  content = File.read(VERSION_RB)
+  content[/VERSION\s*=\s*"([^"]+)"/, 1] or abort('could not parse version.rb')
+end
+
+def gh_available?
+  return @gh_available unless @gh_available.nil?
+
+  @gh_available = system('command -v gh > /dev/null 2>&1')
+end
+
+def token
+  ENV['GH_TOKEN'] || ENV['GITHUB_TOKEN'] || ENV['LIFECYCLE_PAT']
+end
+
+def http_get(uri, headers = {})
+  req = Net::HTTP::Get.new(uri)
+  headers.each { |k, v| req[k] = v }
+  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 15) do |http|
+    http.request(req)
+  end
+  res.is_a?(Net::HTTPSuccess) ? res.body : nil
+rescue StandardError
+  nil
+end
+
+# Fetch one file from a consumer repo. Returns nil (never raises) when the repo,
+# branch, or path is unreachable — an unreachable consumer must degrade to
+# "unknown" in the report, not take the whole fan-out down.
+#
+# Two transports, in order of capability:
+#   1. api.github.com/contents with a token — the only path that reads PRIVATE
+#      consumer repos, and the one CI uses.
+#   2. raw.githubusercontent.com unauthenticated — public repos only.
+# Never send the token to raw.githubusercontent.com: a token that is valid for
+# the API but not for raw turns a public 200 into a 404, which silently reports
+# every consumer as unreachable.
+def fetch_file(repo, branch, path)
+  if gh_available?
+    out = `gh api "repos/#{repo}/contents/#{path}?ref=#{branch}" --jq .content 2>/dev/null`
+    return Base64.decode64(out) if $?.success? && !out.strip.empty?
+  end
+
+  if token
+    body = http_get(
+      URI("https://api.github.com/repos/#{repo}/contents/#{path}?ref=#{branch}"),
+      'Authorization' => "Bearer #{token}",
+      'Accept' => 'application/vnd.github.raw',
+      'X-GitHub-Api-Version' => '2022-11-28'
+    )
+    return body if body
+  end
+
+  http_get(URI("https://raw.githubusercontent.com/#{repo}/#{branch}/#{path}"))
+end
+
+def extract_pin(kind, content)
+  pattern = PIN_PATTERNS[kind]
+  return { versioned: false, version: nil } if pattern.nil?
+  return { versioned: true, version: nil, missing: true } if content.nil?
+
+  match = content.match(pattern)
+  return { versioned: true, version: nil, missing: true } if match.nil?
+
+  # A matched pin with no captured version is a deliberate floating ref
+  # (`remote_theme: bamr87/zer0-mistakes`), not a parse failure.
+  { versioned: true, version: match[1] }
+end
+
+def compare(pinned, current)
+  return :floating if pinned.nil?
+
+  a = Gem::Version.new(pinned.sub(/\A[v=~> ]+/, ''))
+  b = Gem::Version.new(current)
+  return :current if a == b
+  return :behind if a < b
+
+  :ahead
+rescue ArgumentError
+  :unknown
+end
+
+def dispatch(repo, event, version, dry_run)
+  payload = {
+    event_type: event,
+    client_payload: { version: version, theme: 'bamr87/zer0-mistakes', tag: "v#{version}" }
+  }
+
+  if dry_run
+    puts "  [DRY RUN] POST repos/#{repo}/dispatches #{payload[:client_payload].to_json}"
+    return :dry_run
+  end
+
+  unless token
+    warn "  ✗ #{repo}: no token (GH_TOKEN / GITHUB_TOKEN / LIFECYCLE_PAT) — cannot dispatch"
+    return :no_token
+  end
+
+  uri = URI("https://api.github.com/repos/#{repo}/dispatches")
+  req = Net::HTTP::Post.new(uri)
+  req['Authorization'] = "Bearer #{token}"
+  req['Accept'] = 'application/vnd.github+json'
+  req['Content-Type'] = 'application/json'
+  req.body = payload.to_json
+  res = Net::HTTP.start(uri.host, uri.port, use_ssl: true, open_timeout: 10, read_timeout: 15) do |http|
+    http.request(req)
+  end
+
+  if res.is_a?(Net::HTTPSuccess)
+    :dispatched
+  else
+    warn "  ✗ #{repo}: dispatch failed (HTTP #{res.code})"
+    :failed
+  end
+rescue StandardError => e
+  warn "  ✗ #{repo}: dispatch error (#{e.class})"
+  :failed
+end
+
+# -----------------------------------------------------------------------------
+abort("registry not found: #{REGISTRY}") unless File.exist?(REGISTRY)
+
+registry = YAML.load_file(REGISTRY)
+defaults = registry['defaults'] || {}
+current  = options[:version] || theme_version
+consumers = registry['consumers'] || []
+
+results = consumers.map do |consumer|
+  repo   = consumer['repo']
+  branch = consumer['branch'] || defaults['branch'] || 'main'
+
+  pins = (consumer['pins'] || []).map do |pin|
+    kind = pin['kind']
+    content = PIN_PATTERNS[kind].nil? ? nil : fetch_file(repo, branch, pin['file'])
+    info = extract_pin(kind, content)
+    status = if !info[:versioned] then :not_versioned
+             elsif info[:missing] then :unreachable
+             else compare(info[:version], current)
+             end
+    { 'file' => pin['file'], 'kind' => kind, 'pinned' => info[:version], 'status' => status.to_s }
+  end
+
+  versioned = pins.reject { |p| %w[not_versioned unreachable].include?(p['status']) }
+  overall = if versioned.any? { |p| p['status'] == 'behind' } then :behind
+            elsif versioned.any? { |p| p['status'] == 'floating' } then :floating
+            elsif versioned.empty? then :unknown
+            elsif versioned.all? { |p| p['status'] == 'current' } then :current
+            else :mixed
+            end
+
+  {
+    'repo' => repo, 'mode' => consumer['mode'], 'dispatch' => consumer['dispatch'] == true,
+    'status' => overall.to_s, 'pins' => pins
+  }
+end
+
+behind = results.select { |r| r['status'] == 'behind' || r['status'] == 'mixed' }
+
+# -----------------------------------------------------------------------------
+if options[:dispatch]
+  event = defaults['dispatch_event'] || 'theme-release'
+  puts "Dispatching #{event} v#{current} to #{results.count { |r| r['dispatch'] }} consumer(s)"
+  results.each do |r|
+    unless r['dispatch']
+      puts "  – #{r['repo']}: skipped (dispatch: false — #{r['mode']})"
+      next
+    end
+    outcome = dispatch(r['repo'], event, current, options[:dry_run])
+    puts "  ✓ #{r['repo']}: #{outcome}" if %i[dispatched dry_run].include?(outcome)
+  end
+  exit 0
+end
+
+case options[:format]
+when 'json'
+  puts JSON.pretty_generate({ 'theme_version' => current, 'consumers' => results })
+when 'github'
+  results.each do |r|
+    next unless %w[behind mixed].include?(r['status'])
+
+    stale = r['pins'].select { |p| p['status'] == 'behind' }
+                     .map { |p| "#{p['file']} (#{p['pinned']})" }.join(', ')
+    puts "::warning::#{r['repo']} is behind v#{current} — #{stale}"
+  end
+  puts "::notice::#{behind.size}/#{results.size} consumers behind v#{current}"
+else
+  puts "Theme version: #{current}"
+  puts
+  results.each do |r|
+    marker = { 'current' => '✓', 'behind' => '✗', 'floating' => '~', 'mixed' => '✗' }[r['status']] || '?'
+    puts format('%s %-38s %-22s %s', marker, r['repo'], r['mode'], r['status'])
+    r['pins'].each do |p|
+      detail = case p['status']
+               when 'not_versioned' then 'no version (tracked only)'
+               when 'unreachable' then 'unreachable — check repo/branch/path'
+               when 'floating' then 'floating on main'
+               else p['pinned']
+               end
+      puts format('    %-24s %-16s %s', p['file'], p['kind'], detail)
+    end
+    puts
+  end
+  puts "#{behind.size}/#{results.size} consumer(s) behind v#{current}"
+end
+
+exit 1 if options[:strict] && !behind.empty?

data/scripts/test/lib/run_tests.sh

@@ -131,7 +131,8 @@ main() {
     source "$TEST_DIR/test_migrate.sh"
     source "$TEST_DIR/test_pixelate_images.sh"
     source "$TEST_DIR/test_content_review.sh"
-    
+    source "$TEST_DIR/test_agent_review_result.sh"
+
     # Summary
     echo -e "\n${BLUE}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${NC}"
     echo -e "${BLUE}Test Summary${NC}"

data/scripts/test/lib/test_agent_review_result.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+# Bridge for scripts/ci/test_agent_review_result.py (issue #418).
+#
+# The guard that decides whether the Claude content review actually ran lives in
+# scripts/ci/agent_review_result.py, next to the other CI helper
+# (classify_changes.py), and its tests are written in Python beside it. This
+# wrapper is what puts them on the CI path: run_tests.sh sources this file, and
+# ./scripts/bin/test runs run_tests.sh on every PR.
+#
+# scripts/issues/test_verify_close.py is the cautionary example — a real test
+# suite that no runner ever invoked. Do not let this one drift the same way: if
+# the Python tests move, move this line with them.
+
+ARR_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../../.." && pwd)"
+
+print_suite_header "Claude review guard (scripts/ci/agent_review_result.py)"
+
+if command -v python3 >/dev/null 2>&1; then
+    arr_output="$(python3 "$ARR_ROOT/scripts/ci/test_agent_review_result.py" 2>&1)"
+    arr_status=$?
+    echo "$arr_output"
+    assert_equals "0" "$arr_status" \
+        "scripts/ci/test_agent_review_result.py passes (the #418 401-swallow guard)"
+else
+    echo "python3 not available — skipping the Claude review guard tests"
+fi

data/scripts/translate.rb

@@ -90,6 +90,14 @@ module Zer0Translate
     permalink redirect_from redirect_to aliases lang
     translation_of translation_source_url machine_translated translated_from_sha
   ].freeze
+  # Layouts that only work for a document INSIDE a Jekyll collection. The
+  # translated tree is deliberately flat — fr/** are plain pages, not collection
+  # documents — so Jekyll never sets `page.collection` there and these layouts
+  # have nothing to enumerate. `collection` is worse than useless: it sorts
+  # site[page.collection], which is nil for a plain page, and a nil sort aborts
+  # the whole Jekyll build. Drop the key so the `path: <lang>` front-matter
+  # default in _config.yml (layout: default) applies instead.
+  COLLECTION_ONLY_LAYOUTS = %w[collection].freeze
 
   DEFAULT_CONFIG = {
     "enabled" => false,
@@ -367,6 +375,42 @@ module Zer0Translate
     end
   end
 
+  # Test-only variant of StubProvider that soft-wraps its output, reproducing
+  # the one thing a real provider does that no prompt can reliably prevent.
+  # Exists so the prose-normalisation pass has something to actually fix —
+  # asserting "output is unwrapped" against the plain stub would pass whether
+  # or not normalisation ran.
+  class WrappingStubProvider
+    WRAP_AT = 40
+
+    def name = "stub-wrap"
+
+    def translate(segments, target_lang, _context)
+      segments.to_h { |key, text| [key, wrap("#{text} [#{target_lang}]")] }
+    end
+
+    private
+
+    # Greedy wrap on spaces. Never splits a line that has no space past the
+    # column (a long URL or placeholder token stays intact).
+    def wrap(text)
+      out = []
+      line = +""
+      text.split(" ").each do |word|
+        if line.empty?
+          line << word
+        elsif line.length + 1 + word.length > WRAP_AT
+          out << line
+          line = +word
+        else
+          line << " " << word
+        end
+      end
+      out << line unless line.empty?
+      out.join("\n")
+    end
+  end
+
   class ClaudeProvider
     ENDPOINT = URI("https://api.anthropic.com/v1/messages")
     API_VERSION = "2023-06-01"
@@ -380,16 +424,26 @@ module Zer0Translate
     def initialize(model:, max_tokens:)
       @model = model
       @max_tokens = max_tokens
-      @auth = resolve_auth
+      @candidates = resolve_auth_candidates
       raise "No Anthropic credential found. Set CLAUDE_CODE_OAUTH_TOKEN " \
-            "(from `claude setup-token`), ANTHROPIC_AUTH_TOKEN, or ANTHROPIC_API_KEY." unless @auth
+            "(from `claude setup-token`), ANTHROPIC_AUTH_TOKEN, or ANTHROPIC_API_KEY." if @candidates.empty?
+
+      @auth = @candidates.first
     end
 
     def name = "claude (#{@model})"
 
     def translate(segments, target_lang, context)
-      payload = build_payload(segments, target_lang, context)
-      body = request_with_retries(payload)
+      body = begin
+        # Rebuilt on retry, not hoisted: the payload's first system block
+        # depends on @auth[:mode], so falling back to a different credential
+        # has to re-derive it.
+        request_with_retries(build_payload(segments, target_lang, context))
+      rescue AuthError => e
+        raise ProviderError, e.message unless advance_credential!(e)
+
+        retry
+      end
       text = (body["content"] || []).select { |b| b["type"] == "text" }
                                     .map { |b| b["text"] }.join("\n")
       parsed = extract_json(text)
@@ -400,16 +454,38 @@ module Zer0Translate
 
     class ProviderError < StandardError; end
 
+    # A credential the API refused (401/403), as opposed to any other failure.
+    # Separate so `translate` can fall through to the next configured
+    # credential rather than failing the run outright.
+    class AuthError < ProviderError; end
+
     private
 
-    def resolve_auth
-      if (token = ENV["CLAUDE_CODE_OAUTH_TOKEN"] || ENV["ANTHROPIC_AUTH_TOKEN"])
-        return { mode: :oauth, token: token } unless token.empty?
-      end
-      if (key = ENV["ANTHROPIC_API_KEY"])
-        return { mode: :api_key, token: key } unless key.empty?
-      end
-      nil
+    # Every configured credential, in precedence order.
+    #
+    # Returning the whole list rather than just the first match is the point:
+    # the old lookup skipped credentials that were UNSET but had no way to skip
+    # one the API refused, so a set-but-revoked CLAUDE_CODE_OAUTH_TOKEN shadowed
+    # a working ANTHROPIC_API_KEY and took the whole run down with it.
+    def resolve_auth_candidates
+      [
+        { mode: :oauth,   token: ENV["CLAUDE_CODE_OAUTH_TOKEN"], label: "CLAUDE_CODE_OAUTH_TOKEN" },
+        { mode: :oauth,   token: ENV["ANTHROPIC_AUTH_TOKEN"],    label: "ANTHROPIC_AUTH_TOKEN" },
+        { mode: :api_key, token: ENV["ANTHROPIC_API_KEY"],       label: "ANTHROPIC_API_KEY" },
+      ].reject { |c| c[:token].nil? || c[:token].empty? }
+    end
+
+    # Switch to the next configured credential after this one was refused.
+    # Sticky by design — @auth stays switched for the rest of the run, so a
+    # dead credential costs one rejection in total rather than one per chunk.
+    def advance_credential!(error)
+      current = @candidates.index { |c| c.equal?(@auth) }
+      nxt = @candidates[current + 1]
+      return false unless nxt
+
+      Log.warn "#{@auth[:label]} rejected (#{error.message}); retrying with #{nxt[:label]}"
+      @auth = nxt
+      true
     end
 
     def system_blocks(target_lang)
@@ -470,7 +546,10 @@ module Zer0Translate
         body = JSON.parse(response.body)
         unless code == 200
           message = body.dig("error", "message") || response.body[0, 300]
-          raise ProviderError, "Anthropic API #{code}: #{message}"
+          # 401/403 is the credential, not the request — surface it as an
+          # AuthError so the caller can try the next configured one.
+          klass = [401, 403].include?(code) ? AuthError : ProviderError
+          raise klass, "Anthropic API #{code}: #{message}"
         end
         body
       rescue RetryableError
@@ -648,13 +727,34 @@ module Zer0Translate
       pages[url] ||= {}
     end
 
+    # Writes the manifest only when the mapping itself changed.
+    #
+    # `updated_at` used to be stamped on every save, which meant a run that
+    # translated NOTHING still rewrote the file. That is not hypothetical: with
+    # the API credential rejected, every page failed and the run still produced
+    # a one-line `updated_at` diff — enough for translate.yml to open a PR that
+    # reads like a routine translation refresh and contains no translations.
+    # Serializing with the PREVIOUS timestamp first and comparing against disk
+    # keeps that run a no-op, while any real change (a translated page, a prune)
+    # still stamps and writes.
     def save(source_lang, languages)
+      previous = @data["updated_at"]
       @data["version"] = 1
       @data["source_lang"] = source_lang
       @data["languages"] = languages
-      @data["updated_at"] = Time.now.utc.iso8601
       @data["pages"] = pages.sort.to_h
+
+      @data["updated_at"] = previous
+      return if File.file?(@path) && File.read(@path, encoding: "bom|utf-8") == render
+
+      @data["updated_at"] = Time.now.utc.iso8601
       FileUtils.mkdir_p(File.dirname(@path))
+      File.write(@path, render)
+    end
+
+    private
+
+    def render
       header = <<~HEADER
         # ================================================================
         # GENERATED FILE — do not edit by hand.
@@ -663,7 +763,7 @@ module Zer0Translate
         # _includes/components/language-toggle.html and _includes/core/hreflang.html.
         # ================================================================
       HEADER
-      File.write(@path, header + @data.to_yaml.sub(/\A---\n/, ""))
+      header + @data.to_yaml.sub(/\A---\n/, "")
     end
   end
 
@@ -762,6 +862,9 @@ module Zer0Translate
       @url_builder = UrlBuilder.new(@site_config)
       @manifest = Manifest.new(@root)
       @stats = Hash.new(0)
+      # Absolute paths of every markdown file this run wrote, for the
+      # prose-normalisation pass in `run`.
+      @written_pages = []
     end
 
     def run
@@ -790,6 +893,7 @@ module Zer0Translate
 
       translator = build_translator
       execute(plan, translator)
+      normalize_prose(@written_pages)
       prune(sources, languages)
       @manifest.save(source_lang, languages)
       summary
@@ -922,6 +1026,7 @@ module Zer0Translate
       provider =
         case provider_name
         when "stub" then StubProvider.new
+        when "stub-wrap" then WrappingStubProvider.new
         when "claude"
           ClaudeProvider.new(
             model: @options[:model] || ENV["TRANSLATE_MODEL"] || @config["model"],
@@ -949,6 +1054,45 @@ module Zer0Translate
       end
     end
 
+    # Generated pages must satisfy the repo's one-paragraph-per-line rule, which
+    # CI enforces via .github/workflows/markdown-oneline.yml. The provider is
+    # free to soft-wrap a translated paragraph across several lines — nothing in
+    # the prompt can guarantee otherwise — so normalise deterministically after
+    # the fact rather than hoping the model complies.
+    #
+    # tools/unwrap-prose.py is the single source of truth for the rule (it is
+    # what CI runs), so shell out to it instead of reimplementing the classifier
+    # here and letting the two drift.
+    #
+    # Best-effort by design: a missing python3 should not fail an otherwise good
+    # translation run. The Translate workflow runs the same tool as a guaranteed
+    # backstop before committing, so the only cost of skipping here is a local
+    # run leaving wrapped prose for that step to fix.
+    def normalize_prose(paths)
+      paths = paths.select { |p| File.file?(p) }
+      return if paths.empty?
+
+      # Resolve the tool relative to THIS script, not to --root. translate.rb
+      # and tools/ ship together; --root points at the content tree being
+      # translated, which is a different thing (and is a throwaway sandbox
+      # under test).
+      tool = File.expand_path("../tools/unwrap-prose.py", __dir__)
+      tool = File.join(@root, "tools", "unwrap-prose.py") unless File.file?(tool)
+      unless File.file?(tool)
+        Log.warn "tools/unwrap-prose.py not found — skipping prose normalisation"
+        return
+      end
+
+      ok = system("python3", tool, "--write", *paths,
+                  out: File::NULL, err: File::NULL)
+      if ok
+        Log.info "Normalised prose in #{paths.size} generated page(s)"
+      else
+        Log.warn "prose normalisation skipped (python3 unavailable or tool failed); " \
+                 "run: python3 tools/unwrap-prose.py --write"
+      end
+    end
+
     def translate_page(job, translator)
       file = job.source
       segmenter = Segmenter.new(file.body)
@@ -993,6 +1137,7 @@ module Zer0Translate
         key = "fm:#{field}"
         fm[field] = fm_masker.unmask(translated[key]) if translated.key?(key)
       end
+      fm.delete("layout") if COLLECTION_ONLY_LAYOUTS.include?(fm["layout"].to_s)
       fm["lang"] = job.lang
       fm["permalink"] = "/#{job.lang}#{job.url}"
       fm["translation_of"] = file.rel_path
@@ -1007,6 +1152,7 @@ module Zer0Translate
       abs = File.join(@root, out_rel)
       FileUtils.mkdir_p(File.dirname(abs))
       File.write(abs, "#{fm.to_yaml}---\n\n#{body_out.sub(/\A\n+/, '')}")
+      @written_pages << abs
     end
 
     def translate_ui_text(job, translator)