From 3a546a0898afe2c9acb0aa58a449d765b6c2e897 Mon Sep 17 00:00:00 2001
From: Martin Hinshelwood <martin@nkdagility.com>
Date: Fri, 18 Sep 2026 16:50:48 +0100
Subject: [PATCH 1/2] feat: centralize guide catalogue capabilities

+semver: minor
---
 docs/architecture/current-system.md           |  91 +++++++++
 docs/architecture/hugo-guide-catalogue.md     |  73 +++++++
 docs/platform-development.md                  |   4 +-
 readme.md                                     |   1 +
 .../components/guide/render-guide.html        |  18 +-
 .../translations/official-version.html        |   2 +-
 .../components/versions/version-card.html     |  12 +-
 .../_partials/functions/get-all-versions.html |  62 +-----
 .../get-guide-translations-catalogue.html     | 106 ++--------
 .../get-guide-translations-for-version.html   | 166 +--------------
 .../get-guide-translations-list.html          | 102 +---------
 .../functions/get-history-chain.html          | 113 +----------
 .../functions/get-latest-version.html         |  38 +---
 .../editions/discover-guide-editions.html     |  16 ++
 .../editions/get-edition-version.html         |   9 +
 .../editions/get-guide-version-options.html   |  13 ++
 .../editions/select-latest-guide-edition.html |  23 +++
 .../openguide/guides/discover-guides.html     |  14 ++
 .../openguide/guides/get-guide-catalogue.html |  13 ++
 .../history/get-guide-history-chain.html      | 112 +++++++++++
 .../openguide/pdfs/discover-edition-pdfs.html |  11 +
 .../pdfs/select-first-edition-pdf.html        |   6 +
 .../pdfs/select-translation-pdfs.html         |   7 +
 .../discover-edition-translations.html        |  30 +++
 .../project-legacy-translation.html           |  32 +++
 .../resolve-translation-fallback.html         |   3 +
 .../select-preferred-guide-translations.html  |  82 ++++++++
 .../Contracts/README.md                       |  12 +-
 tests/Core/HugoCatalogue.Tests.ps1            | 189 ++++++++++++++++++
 29 files changed, 769 insertions(+), 591 deletions(-)
 create mode 100644 docs/architecture/current-system.md
 create mode 100644 docs/architecture/hugo-guide-catalogue.md
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/discover-guide-editions.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-edition-version.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-guide-version-options.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/select-latest-guide-edition.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/discover-guides.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/get-guide-catalogue.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/history/get-guide-history-chain.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/discover-edition-pdfs.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-first-edition-pdf.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-translation-pdfs.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/discover-edition-translations.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/project-legacy-translation.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/resolve-translation-fallback.html
 create mode 100644 system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html
 create mode 100644 tests/Core/HugoCatalogue.Tests.ps1

diff --git a/docs/architecture/current-system.md b/docs/architecture/current-system.md
new file mode 100644
index 00000000..ac5d341f
--- /dev/null
+++ b/docs/architecture/current-system.md
@@ -0,0 +1,91 @@
+# OpenGuidePlatform current system
+
+This describes the implementation inspected from repository commit `2a178e6618c2b55c4ff55913e4e7965454ea19c1`, including the subsequently approved Hugo catalogue changes in this working tree (18 September 2026). Each section links to the implementation or schema that supports its claims. The [execution plan](open-guide-platform-execution-plan.md) records acceptance status; this page describes behavior in source, not a completed consumer rollout.
+
+## Components and ownership
+
+| Component | Current responsibility |
+|---|---|
+| [`OpenGuidePlatform.Hugo.Guides`](../../system/OpenGuidePlatform.Hugo.Guides/layouts/guide/single.html) | Hugo guide templates and reusable presentation partials. Consumer wrappers may have their own layouts and overrides; see the [architecture proposal](open-guide-platform-proposal.md#5-hugo-architecture-and-extension-compatibility) for the ownership boundary. |
+| [`OpenGuidePlatform.PowerShell.Core`](../../system/OpenGuidePlatform.PowerShell.Core/OpenGuidePlatform.PowerShell.Core.psm1) | Policy import, guide assessment, publishing operations and PDF operations. |
+| [`OpenGuidePlatform.PowerShell.GuideSiteBuild`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Invoke-GuideSiteBuild.ps1) | Source discovery and the guide-site Prepare, Build, Validate, Deploy and Verify operations. |
+| [`OpenGuidePlatform.PowerShell.GuideSiteAdoption`](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/OpenGuidePlatform.PowerShell.GuideSiteAdoption.psm1) | Installation, update and selected-package restoration. |
+| [`OpenGuidePlatform.PowerShell.PlatformBuild`](../../system/OpenGuidePlatform.PowerShell.PlatformBuild/OpenGuidePlatform.PowerShell.PlatformBuild.psm1) | Platform testing, packaging, candidate sample acceptance and release operations. The [distribution package](../../system/OpenGuidePlatform.PowerShell.PlatformBuild/Packaging/Package-OpenGuidePlatform.ps1) keeps this separate from GuideSite. |
+| [`OpenGuidePlatform.Agents.Integration`](../../system/OpenGuidePlatform.Agents.Integration/README.md) and [`OpenGuidePlatform.PowerShell.AgentControls`](../../system/OpenGuidePlatform.PowerShell.AgentControls/README.md) | Contributor skills/instructions and a repository governance evaluator. The [AgentControls README](../../system/OpenGuidePlatform.PowerShell.AgentControls/README.md) distinguishes repository code from independently installed enforcement. |
+
+The root [`build.ps1`](../../build.ps1) selects the platform or guide-site operation. The [installed launcher](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/build.ps1) resolves its installed package and calls [`Invoke-GuideSiteBuild`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Invoke-GuideSiteBuild.ps1). PlatformBuild packages and tests the candidate GuideSite distribution. The [build instructions](../platform-development.md) define the supported acceptance commands.
+
+## Source and discovery
+
+The [settings reader](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/Resolve-OpenGuidePlatform.ps1) reads `site.source` from `.OpenGuidePlatform/settings.yaml`. [`Build-GuideSite.ps1`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Build-GuideSite.ps1) imports a supplied `-PolicyPath`, or calls `New-GuideSiteDiscovery` and saves its result as `discovered-site.json` under that run's `.processing/` directory. The generated file is passed to the same subsequent policy import and assessment code. Installed sites do not have to maintain a separate guide inventory. [Implementation: build entry point](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Build-GuideSite.ps1).
+
+### How the source list is populated
+
+The **PowerShell filesystem walk**, not `hugo list all`, creates the `guides`, `editions`, `translations` and `downloads` entries. [`New-GuideSiteDiscovery`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Discovery/New-GuideSiteDiscovery.ps1) obtains the effective default language and content directory, then applies these rules:
+
+| Entry | Exact current recognition rule |
+|---|---|
+| Guide | Recursively find `_index.md` under the configured content directory; keep a directory when that file's front matter has `type: guide` and `layout: root` and at least one accepted edition. Guide `id` is its path relative to the content directory. |
+| Edition/version | Inspect immediate child directories of the guide. Keep one when it contains `index.md`, its layout is not `translations`, `history`, `root` or `details`, and its front matter has either `type: guide` or a `version` field. Use the `version` field as edition `id` when present; otherwise use the directory name. |
+| Language | Collect languages from edition-root `index*.md` filenames and from recognised PDF suffixes. `index.md` means the configured default language; `index.<tag>.md` supplies `<tag>`. |
+| PDF/download | Find `*.pdf` recursively inside the edition. A filename ending `.<language>.pdf` is assigned to that language; a PDF without a recognised suffix is assigned to the configured default language. Store its path relative to the edition and mark its inferred handling `supplied`. |
+
+For each collected language, the code reads the corresponding `index.md` or `index.<language>.md` body and infers `web` when populated, `pdf-only` when the body is empty but a matching PDF exists, `web` for the empty default-language source, or `fallback` to the default language otherwise. It also records required guide-root, history and translations wrapper files for active guide languages. These are the rules in the [source walk and entry construction](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Discovery/New-GuideSiteDiscovery.ps1); they describe what the code currently recognises, not a proposed content format.
+
+### What the Hugo source listing contributes
+
+Separately, [`Get-GuideSourcePages`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Discovery/Get-GuideSourcePages.ps1) runs `hugo list all` with the selected configuration and environment. It filters pages according to the effective draft, future and expiry settings and returns page paths and permalinks. Discovery uses those observations to derive page routes, PDF `publicationRoots`, and evidence for environment exclusions; it derives some additional required routes from aliases and output configuration. It does **not** use that listing to enumerate guide directories, edition directories, translation files or PDF files. [Use of `$pages` and route construction in discovery](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Discovery/New-GuideSiteDiscovery.ps1).
+
+An explicit policy is the other supported input. Its [v1 schema](../../system/OpenGuidePlatform.PowerShell.Core/Contracts/site-policy.schema.json) permits reviewed publication intent, protected paths, download handling and wrapper obligations. Discovery returns the same top-level shape but infers values from files; an inferred `web` or `pdf-only` state is not an editorial judgement about translation quality. [Discovery output](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Discovery/New-GuideSiteDiscovery.ps1), [Core inventory](../../system/OpenGuidePlatform.PowerShell.Core/GuideInventory/Get-GuideInventory.ps1).
+
+## Site-policy-shaped inventory format
+
+The [v1 site-policy schema](../../system/OpenGuidePlatform.PowerShell.Core/Contracts/site-policy.schema.json) requires `schemaVersion`, `siteId`, `wrapper`, `guides`, `publication` and `protectedPaths`, and rejects additional properties. It defines repository-relative paths, with edition and download paths relative to their parent entries. Core's path resolver also checks filesystem containment; see [path handling](../../system/OpenGuidePlatform.PowerShell.Core/Internal/Paths.ps1).
+
+| Field | Meaning |
+|---|---|
+| `wrapper.sourcePath` | Hugo site directory. Wrapper requirements can include `requiredFiles`, `requiredRoutes`, `requiredI18nKeys`, `integrationPoints`, `requiredPageContent`, `runtimeAnchors`, JSON index expectations and recorded legacy aliases. `wrapper.discovery: source` marks generated discovery evidence. |
+| `guides[]` | Any number of guides, each with `id`, `contentRoot`, `relationship`, `protectSource` and one or more `editions`. Optional `artifactPrefixes` identify known public paths for exclusions. |
+| `editions[]` | Edition `id`, directory `path`, `sourceLanguage` and `translations`. |
+| `translations[]` | Language, `intent`, optional `fallbackLanguage` and `downloads`. Intents are `web`, `pdf-only`, `fallback`, `scaffold` and `excluded`. Intent is a declaration or inference, not proof of translation quality. |
+| `downloads[]` | PDF path relative to the edition and `handling`: `supplied`, `generated` or `protected`. Explicit policies can record `publishedPaths` and generated-PDF `generationReceipt`; discovery can retain `publicationRoots` for later artifact observation. Source and public paths are distinct. |
+| `publication` | Target environments with excluded languages/guides and permanent exclusions for language, guide or edition. |
+| `protectedPaths` | Repository paths that publishing operations must preserve. |
+
+The [schema](../../system/OpenGuidePlatform.PowerShell.Core/Contracts/site-policy.schema.json) checks structure. [Core assessment](../../system/OpenGuidePlatform.PowerShell.Core/Assessment/Get-GuideAssessment.ps1) checks declared relationships and source readiness; [Build](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Build-GuideSite.ps1) separately observes effective Hugo configuration and validates the artifact. The [trusted-policy decision](decisions/004-trusted-policy-authority.md) explains why a candidate-controlled repository file cannot approve its own changes.
+
+## Prepare, assessment and build evidence
+
+The [Prepare branch](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Build-GuideSite.ps1) resolves the Hugo module, generates or loads the site-policy-shaped input and records source/tool evidence. [`Prepare-GuideSite.ps1`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Prepare-GuideSite.ps1) reads effective Hugo configuration and calls [`Get-GuideAssessment`](../../system/OpenGuidePlatform.PowerShell.Core/Assessment/Get-GuideAssessment.ps1). Core [inventory](../../system/OpenGuidePlatform.PowerShell.Core/GuideInventory/Get-GuideInventory.ps1) observes each declared edition/translation body as `populated`, `empty` or `missing`; [translation readiness](../../system/OpenGuidePlatform.PowerShell.Core/TranslationReadiness/Get-GuideTranslationState.ps1) returns `web`, `pdf-only`, `fallback`, `scaffold`, `excluded` or `unknown`. The inventory follows declared fallback chains to populated web content and does not require a web body for PDF-only intent. None of these source checks establishes translation quality.
+
+[`Prepare-GuideSite.ps1`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Prepare-GuideSite.ps1) checks downloads, declared generated-PDF receipts, legacy/latest aliases and source translation catalogues, then writes `prepare/assessment.json` and a Markdown report. The [assessment v1 schema](../../system/OpenGuidePlatform.PowerShell.Core/Contracts/assessment.schema.json) defines `sourceCommit`, `platformVersion`, `policyDigest`, `target`, `stage`, `outcome`, `findings` and observed `inventory`. Findings include a code, severity, scope, subject, message, remediation and evidence. The schema permits `pass`, `fail` and `blocked`; Prepare throws unless the assessment passes.
+
+The [build-stage script](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Build-GuideSite.ps1) saves prepared inputs and tool evidence. Both Build and Validate recheck the prepared inputs, commit, target and policy digest; Build additionally checks the tool hash before invoking Hugo and writing an artifact identity. Validate checks routes/resources, PDF publication, links, JSON indexes and runtime anchors against the built artifact. [`Invoke-GuideSiteBuild`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Invoke-GuideSiteBuild.ps1) calls Deploy and Verify when explicitly requested; an ordinary `All` run stops after Validate.
+
+## PDF evidence and preservation
+
+[`Get-GuidePdfPlan` and `New-GuidePdf`](../../system/OpenGuidePlatform.PowerShell.Core/PdfPublishing/Get-GuidePdfPlan.ps1) select only a download declared `generated`, read `index.md` or `index.<language>.md`, and pass language to Pandoc as metadata. They check tools/fonts, render in staging and check the PDF header before publishing. Replacement requires the existing output's expected SHA256. Supplied and protected downloads cannot be selected for generation. [`Get-GuideAssessment`](../../system/OpenGuidePlatform.PowerShell.Core/Assessment/Get-GuideAssessment.ps1) flags `lang` in Hugo front matter as deprecated.
+
+[`New-GuidePdf`](../../system/OpenGuidePlatform.PowerShell.Core/PdfPublishing/Get-GuidePdfPlan.ps1) returns a v1 receipt with guide, edition, language, input/output hashes, configuration hash, toolchain, environment digest and optional cache key. [`Save-GuidePdfReceipt` and `Get-GuidePdfReceipts`](../../system/OpenGuidePlatform.PowerShell.Core/PdfPublishing/Get-GuidePdfReceipts.ps1) save and validate declared receipts; Prepare calls the latter without rerunning Pandoc. [`Test-GuidePdfCache`](../../system/OpenGuidePlatform.PowerShell.Core/PdfPublishing/Test-GuidePdfCache.ps1) uses content/recipe/tool/environment evidence rather than timestamps. The returned PDF result says visual review is required; neither receipt validation nor source discovery assesses translation quality.
+
+At Validate, [`Get-GuideDownloadRequirements`](../../system/OpenGuidePlatform.PowerShell.Core/PublicationPolicy/Get-GuideDownloadRequirements.ps1) uses explicit `publishedPaths` when present. For inferred discovery it considers recorded `publicationRoots` and published JSON `PathPdf` entries, accepts matching artifact paths only when their SHA256 equals the source PDF, and checks excluded PDFs by path, hash and filename across the artifact. [`Get-GuidePublishedDownloads`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/ArtifactValidation/Get-GuidePublishedDownloads.ps1) reads the JSON entries.
+
+## Settings, installation and release files
+
+| File | Owner and current role |
+|---|---|
+| `.OpenGuidePlatform/settings.yaml` | The [settings reader](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/Resolve-OpenGuidePlatform.ps1) accepts `platform.version`, `platform.ring`, `site.source` and `delivery`; version selection can be exact or a major/minor family. See the [user README](../../readme.md#platform-settings-and-updates) for an example. |
+| `.OpenGuidePlatform/installation.json` | The [adoption module](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/OpenGuidePlatform.PowerShell.GuideSiteAdoption.psm1) writes the v1 installation record, including release, native dependency and managed-file hashes. The [installed launcher](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/build.ps1) reads it. |
+| `release-manifest.json` | The [packager](../../system/OpenGuidePlatform.PowerShell.PlatformBuild/Packaging/Package-OpenGuidePlatform.ps1) writes schema version 2 with package ZIP names, hashes, component versions, one source commit and PlatformBuild's exact GuideSite dependency. |
+| `platform.json` | The same [packager](../../system/OpenGuidePlatform.PowerShell.PlatformBuild/Packaging/Package-OpenGuidePlatform.ps1) writes version, source commit, channel, native Hugo module, workflow and tool requirements into the GuideSite package. |
+| `.processing/...` | [`Build-GuideSite.ps1`](../../system/OpenGuidePlatform.PowerShell.GuideSiteBuild/GuideSiteBuild/Build-GuideSite.ps1) writes per-run discovery, prepared inputs, tool evidence and validation results there. |
+
+The [adoption resolver](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/Resolve-OpenGuidePlatform.ps1) validates selected release/package identity; the [adoption module](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdoption/OpenGuidePlatform.PowerShell.GuideSiteAdoption.psm1) handles installation conflicts and the coordinated native Hugo dependency. A run records its selected package for subsequent stages. The generated release manifest and the [platform-lock v1 schema](../../system/OpenGuidePlatform.PowerShell.Core/Contracts/platform-lock.schema.json) are distinct formats.
+
+## Presentation and current limits
+
+Hugo dynamically discovers guides, editions, translations and PDF resources through [capability partials and their contracts](hugo-guide-catalogue.md). The [shared catalogue](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/get-guide-catalogue.html) retains Hugo Page and Resource objects; the [compatibility adapter](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-catalogue.html) projects the existing public JSON fields. Neither reads `discovered-site.json` or `assessment.json`.
+
+The [guide rendering template](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/guide/render-guide.html) uses capability functions for PDF lookup and same-path translation fallback. It retains presentation and its existing content-availability rules. The original [execution plan](open-guide-platform-execution-plan.md#16a-e14--refactor-hugo-module-contents-last) defers broader Hugo refactoring until consumer adoption; the subsequently approved catalogue work does not establish that those wider gates have passed.
+
+The [execution plan](open-guide-platform-execution-plan.md#current-acceptance-status) records the remaining consumer adoption, independently administered enforcement, named-release verification and later Hugo work. The presence of a schema or test fixture is not evidence that one of those gates passed.
diff --git a/docs/architecture/hugo-guide-catalogue.md b/docs/architecture/hugo-guide-catalogue.md
new file mode 100644
index 00000000..4a429428
--- /dev/null
+++ b/docs/architecture/hugo-guide-catalogue.md
@@ -0,0 +1,73 @@
+# Hugo guide catalogue contract
+
+The Hugo catalogue is derived from the current Hugo site, its pages and page resources. It is not loaded from the PowerShell discovery or assessment files. PowerShell's source assessment remains a separate build responsibility; see [current system](current-system.md).
+
+## Ownership and naming
+
+Capability partials live directly below `layouts/_partials/openguide/{guides,editions,translations,pdfs,history}/`. The folder names describe guide publishing capabilities. There is no nested `functions/` folder. HTML presentation stays under `components/`; the existing `functions/get-...` entry points remain compatibility adapters.
+
+The paths in the following table are relative to [`openguide/`](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/). Inputs are Hugo template values, not JSON.
+
+| Partial | Input | Result and responsibility |
+|---|---|---|
+| `guides/discover-guides.html` | Page | Current site's sections of type `guide`, deduplicated by relative permalink and ordered by weight. |
+| `guides/get-guide-catalogue.html` | Page | `SiteLanguage`, `Guides[]`; aggregates editions, translations and PDF resources. |
+| `editions/discover-guide-editions.html` | Dict: `Page`, `Scope`, optional `Order` | `Version`, `Page` records in descending date order, or original page order with `Order: source`. `children` uses the page's children; `section` uses the site's regular pages in the page's section. Both filter type `guide` and require a version in the URL. |
+| `editions/get-edition-version.html` | Page | First permalink segment matching `YYYY.number`, or an empty string. |
+| `editions/select-latest-guide-edition.html` | Page | `Version`, `Page`; date-first selection with the existing lexical URL fallback. |
+| `editions/get-guide-version-options.html` | Page | Existing `version`, `url`, `title`, `date`, `page`, `isLatest` records. Latest links to the section root. |
+| `translations/discover-edition-translations.html` | Edition Page | Union of `AllTranslations` languages and language suffixes found in edition PDFs. Each record retains pages and resources. |
+| `translations/select-preferred-guide-translations.html` | Guide section Page | Public translation rows with `Version`. Orders editions numerically by year/month; an older readable translation takes precedence over a newer PDF-only translation. Preserves the legacy per-edition override hook. |
+| `translations/project-legacy-translation.html` | Discovered translation record | The existing public translation fields, including availability and status. This operation reads `.Plain`. |
+| `translations/resolve-translation-fallback.html` | Page | Same-path page in the first Hugo language site, preserving the existing fallback lookup. |
+| `pdfs/discover-edition-pdfs.html` | Dict: `Page`, optional `Pattern` | All matching `Name`, `Language`, `Resource` records. Default pattern: `pdf/*.*.pdf`. Language is the penultimate dot-separated filename component. |
+| `pdfs/select-translation-pdfs.html` | Dict: `PDFs`, `Language` | Case-insensitive language filter over discovered records, preserving order. |
+| `pdfs/select-first-edition-pdf.html` | Dict: `Page`, `Pattern` | First matching resource, or `false`; preserves the rendering templates' previous `GetMatch` selection. |
+| `history/get-guide-history-chain.html` | Page | Existing `current`, `history`, `forkSource`, `forkHistory` structure containing Hugo pages; preserves explicit fork edition and fallback behavior. |
+
+## Internal structure
+
+`get-guide-catalogue` returns this **in-memory shape**. The names below illustrate a Kanban guide; they are not configuration or a maintained inventory. All entries are discovered.
+
+```text
+SiteLanguage: "en"
+Guides:
+  - Id: "the-kanban-guide"            # Hugo section identifier
+    Page: <Hugo section Page>
+    Title: "The Kanban Guide"
+    LatestVersion: "2025.5"
+    Versions:
+      - Version: "2025.5"
+        Page: <Hugo edition Page>
+        Translations:
+          - Language: "en"
+            Page: <Hugo translated Page, or false if absent>
+            EditionPage: <calling edition Page>
+            PDFs:
+              - Name: "pdf/kanban-guide.en.pdf"
+                Language: "en"
+                Resource: <Hugo Resource>
+            LegacyPDF: <selected Resource, or false>
+```
+
+An empty translated page remains a page. A PDF-only language without a page has `Page: false`; no translated page or URL is invented. Multiple matching PDFs remain in `PDFs`. `LegacyPDF` preserves the old single-download choice: last matching edition resource, or first matching translated-page resource when the edition has no match. Resource enumeration follows Hugo's `Resources.Match` order.
+
+Raw discovery and catalogue aggregation do not read `.Content` or `.Plain`. They can be used from rendering without eagerly rendering every translation. Availability projection and preferred-translation selection do read `.Plain` and should not be invoked recursively from a shortcode that is itself being evaluated for that projection. No global cache is introduced; each call retains its language-site context.
+
+## Public compatibility
+
+[`functions/get-guide-translations-catalogue.html`](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-catalogue.html) explicitly projects the internal catalogue into the existing JSON-compatible shape. Hugo Page and Resource objects must not be passed directly to `jsonify`. `index.translations.json` continues to use this adapter.
+
+Public guide records retain `Title`, `Path`, `RelPermalink`, `Section`, `Type`, `Weight`, `Description`, `Versions`, `LatestVersion`. Edition records retain `Version`, `Title`, `Date`, `RelPermalink`, `Path`, `Description`, `Latest`, `Translations`.
+
+Translation records retain exactly `Date`, `Language`, `LanguageName`, `Path`, `PathPdf`, `ReadOnline`, `ReadOnlineStub`, `ReadPDF`, `RelPermalink`, `Status`, `Title`, `VersionPath`, `Weight`. The preferred-language list additionally includes `Version`. `ReadOnlineStub` means a page exists, not that it has readable content. `ReadOnline` preserves the existing greater-than-ten-space-separated-words rule. Status remains `published`, `online-only`, `pdf-only` or `site-only`.
+
+The rendering components retain their separate greater-than-500-character content rule and production draft checks. Their PDF patterns and first-match policy remain unchanged. Consolidating these differing availability rules would change behavior and is outside this refactor.
+
+The six existing entry points for catalogue, edition translations, preferred translations, version options, latest version and history remain callable. The catalogue adapter and preferred selection continue calling the legacy per-edition translation hook. Catalogue projection and version options retain the legacy latest-version hook; history retains the legacy version-options hook. Their default implementations delegate to capability partials without recursion. These deliberate extension points preserve existing consumer overrides; raw catalogue discovery still describes the Hugo objects themselves. Consumer adoption must check any additional site-specific overrides.
+
+## Verification
+
+[`HugoCatalogue.Tests.ps1`](../../tests/Core/HugoCatalogue.Tests.ps1) builds multilingual fixtures with several guides, dated editions, empty translations, PDF-only languages, regional language tags, multiple PDFs, fork ancestry, equal-date ordering, consumer overrides and production language exclusion. Existing rendering and SEO tests cover their public output. Acceptance also requires the root platform build and both reference-site targets described in [platform development](../platform-development.md).
+
+These checks establish local platform behavior. They do not establish consumer adoption or deployment approval.
diff --git a/docs/platform-development.md b/docs/platform-development.md
index d7b75f90..4a86ff37 100644
--- a/docs/platform-development.md
+++ b/docs/platform-development.md
@@ -12,7 +12,7 @@ Install the tools listed in the README and Node.js 20 or newer and npm (for real
 ./build.ps1 -Version 0.0.0-local
 ```
 
-Without a version override, the platform calculates GitVersion using the same module operation as Actions. The repository currently uses GitVersion 5 configuration, so Dependencies installs a compatible 5.x tool beneath `.processing/tools/` without changing a global GitVersion installation. `-Version` remains an explicit override.
+Without a version override, the platform calculates GitVersion using the same module operation as Actions. The repository uses GitVersion 6 configuration; Dependencies installs a compatible 6.x tool beneath `.processing/tools/` without changing a global GitVersion installation. `-Version` remains an explicit override.
 
 The platform build runs preparation, tests, packaging and package verification. It writes to a fresh directory under `.processing/platform/`, then builds and validates the sample in preview and production from the exact package ZIP it produced. It does not publish a release or deploy the sample by default; the opt-in commands below add those operations. Pester is a platform-development dependency, not an everyday guide-site requirement.
 
@@ -34,6 +34,8 @@ The built-in hosting adapter follows the [Azure Static Web Apps CLI deployment c
 
 ## Build module ownership
 
+For the current component boundaries, source/discovery behavior, file formats and build evidence, see [Current system](architecture/current-system.md).
+
 `OpenGuidePlatform.PowerShell.PlatformBuild` owns platform engineering. `OpenGuidePlatform.PowerShell.GuideSiteBuild` owns guide-site stages and remains independently importable. They ship as separate GuideSite and PlatformBuild ZIP assets in one coordinated release. Root scripts dispatch to the selected module; existing `.build/` build/test/package entry points forward to PlatformBuild.
 
 Both root build entry points accept `-PlatformSource Local|Preview|Production|Path`, `-PlatformRelease <tag>` and `-PlatformPath <directory-or-zip>`. Platform checkouts default to their local module. Installed consumers default to their installation lock. An explicit override does not change that lock. Preview/Production without a tag select the latest eligible release once at startup; Production means a non-prerelease platform package, independently of the site's `-Target`.
diff --git a/readme.md b/readme.md
index a1c1d121..7342d06f 100644
--- a/readme.md
+++ b/readme.md
@@ -177,6 +177,7 @@ If you need help, include the command, finding and relevant report in a [GitHub
 - [First-time site setup](docs/using/first-adoption.md) — policy, existing files and deployment setup.
 - [SEO metadata](docs/using/seo-metadata.md) — homepage titles, social images, publisher logos, authors and publication licences.
 - [Platform development](docs/platform-development.md) — build this repository, run the sample locally and understand releases.
+- [Current system](docs/architecture/current-system.md) — component ownership, guide discovery, contracts, file formats and build evidence.
 - [Workflow dependency locking](docs/platform-development.md#workflow-dependency-lockfile) — regenerate, verify and review Actions dependency locks when changing platform workflows.
 - [Execution plan and current progress](docs/architecture/open-guide-platform-execution-plan.md).
 
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/guide/render-guide.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/guide/render-guide.html
index 276bca92..c0f115f7 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/guide/render-guide.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/guide/render-guide.html
@@ -57,8 +57,7 @@ <h4 class="h6 text-muted mb-3 flex-shrink-0 d-none d-md-block">{{ i18n "guide_ta
             {{ .Page.TableOfContents }}
           {{ else }}
             {{- /* Get the default guide content as fallback */ -}}
-            {{ $defaultSite := index hugo.Sites 0 }}
-            {{ $thisPageDefault := $defaultSite.GetPage .Path }}
+            {{ $thisPageDefault := partial "openguide/translations/resolve-translation-fallback.html" . }}
 
             {{- if not $thisPageDefault }}
               {{- fmt.Errorf "thisPageDefault page not found" }}
@@ -105,7 +104,7 @@ <h1 class="content-title mb-0">{{ .Title }}</h1>
                   {{- if eq .Site.Language.Lang "en" }}
                     {{- /* Show both EN and EN-US buttons for English */ -}}
                     {{- $pdfPatternEN := "pdf/*.en.pdf" }}
-                    {{- $pdfResourceEN := .Resources.GetMatch $pdfPatternEN }}
+                    {{- $pdfResourceEN := partial "openguide/pdfs/select-first-edition-pdf.html" (dict "Page" . "Pattern" $pdfPatternEN) }}
                     {{- if $pdfResourceEN }}
                       <a
                         href="{{ $pdfResourceEN.RelPermalink }}"
@@ -128,7 +127,7 @@ <h1 class="content-title mb-0">{{ .Title }}</h1>
                     {{- end }}
 
                     {{- $pdfPatternENUS := "pdf/*.en-us.pdf" }}
-                    {{- $pdfResourceENUS := .Resources.GetMatch $pdfPatternENUS }}
+                    {{- $pdfResourceENUS := partial "openguide/pdfs/select-first-edition-pdf.html" (dict "Page" . "Pattern" $pdfPatternENUS) }}
                     {{- if $pdfResourceENUS }}
                       <a
                         href="{{ $pdfResourceENUS.RelPermalink }}"
@@ -152,7 +151,7 @@ <h1 class="content-title mb-0">{{ .Title }}</h1>
                   {{- else }}
                     {{- /* Single PDF button for other languages */ -}}
                     {{- $pdfPattern := printf "pdf/*.%s.pdf" .Site.Language.Lang }}
-                    {{- $pdfResource := .Resources.GetMatch $pdfPattern }}
+                    {{- $pdfResource := partial "openguide/pdfs/select-first-edition-pdf.html" (dict "Page" . "Pattern" $pdfPattern) }}
                     {{- if $pdfResource }}
                       <a
                         href="{{ $pdfResource.RelPermalink }}"
@@ -201,9 +200,9 @@ <h1 class="content-title mb-0">{{ .Title }}</h1>
             {{- /* PDF intro text with Google Analytics tracking */ -}}
             {{- if eq .Site.Language.Lang "en" }}
               {{- $pdfPatternEN := "pdf/*.en.pdf" }}
-              {{- $pdfResourceEN := .Resources.GetMatch $pdfPatternEN }}
+              {{- $pdfResourceEN := partial "openguide/pdfs/select-first-edition-pdf.html" (dict "Page" . "Pattern" $pdfPatternEN) }}
               {{- $pdfPatternENUS := "pdf/*.en-us.pdf" }}
-              {{- $pdfResourceENUS := .Resources.GetMatch $pdfPatternENUS }}
+              {{- $pdfResourceENUS := partial "openguide/pdfs/select-first-edition-pdf.html" (dict "Page" . "Pattern" $pdfPatternENUS) }}
               {{- if or $pdfResourceEN $pdfResourceENUS }}
                 <div class="alert alert-info mb-4" role="alert">
                   <i class="fa-solid fa-info-circle me-2"></i>
@@ -219,7 +218,7 @@ <h1 class="content-title mb-0">{{ .Title }}</h1>
               {{- end }}
             {{- else }}
               {{- $pdfPattern := printf "*.%s.pdf" .Site.Language.Lang }}
-              {{- $pdfResource := .Resources.GetMatch $pdfPattern }}
+              {{- $pdfResource := partial "openguide/pdfs/select-first-edition-pdf.html" (dict "Page" . "Pattern" $pdfPattern) }}
               {{- if $pdfResource }}
                 <div class="alert alert-info mb-4" role="alert">
                   <i class="fa-solid fa-info-circle me-2"></i>
@@ -249,8 +248,7 @@ <h1 class="content-title mb-0">{{ .Title }}</h1>
               {{ .Content }}
             {{- else }}
               {{- /* Get the default guide content as fallback */ -}}
-              {{ $defaultSite := index hugo.Sites 0 }}
-              {{ $thisPageDefault := $defaultSite.GetPage .Path }}
+              {{ $thisPageDefault := partial "openguide/translations/resolve-translation-fallback.html" . }}
 
               {{- if not $thisPageDefault }}
                 {{- fmt.Errorf "thisPageDefault page not found" }}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/translations/official-version.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/translations/official-version.html
index 642092bb..6ee916f4 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/translations/official-version.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/translations/official-version.html
@@ -73,7 +73,7 @@
 {{- $foundingContributors = where $foundingContributors "role" "in" (slice "contributor" "creator") -}}
 
 {{ $pdfPattern := printf "pdf/*.%s*.pdf" $defaultSite.Language }}
-{{ $pdfMatches := $guidePage.Resources.Match $pdfPattern }}
+{{ $pdfMatches := slice }}{{ range partial "openguide/pdfs/discover-edition-pdfs.html" (dict "Page" $guidePage "Pattern" $pdfPattern) }}{{ $pdfMatches = $pdfMatches | append .Resource }}{{ end }}
 
 
 <h2 class="mb-3">{{ i18n "download_official_version" . }}</h2>
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/versions/version-card.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/versions/version-card.html
index b36cff7e..39d53879 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/versions/version-card.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/versions/version-card.html
@@ -146,7 +146,7 @@ <h5 class="card-title mb-0 {{ if $isLatest }}text-primary{{ else if $isFork }}te
           </div>
         {{ end }}
         {{- $pdfPattern := "pdf/*.*.pdf" }}
-        {{- $pdfResources := .Resources.Match $pdfPattern }}
+        {{- $pdfResources := partial "openguide/pdfs/discover-edition-pdfs.html" (dict "Page" . "Pattern" $pdfPattern) }}
         {{ if gt (len $pdfResources) 0 }}
           <div class="mb-3">
             <div class="text-muted small mb-2">
@@ -156,20 +156,14 @@ <h5 class="card-title mb-0 {{ if $isLatest }}text-primary{{ else if $isFork }}te
             <div class="d-flex flex-wrap gap-1">
               {{/* PDF language buttons */}}
               {{ range $pdfResources }}
-                {{- $filename := .Name }}
-                {{- $langCode := "" }}
+                {{- $langCode := .Language }}
                 {{- $displayName := "" }}
-                {{/* Extract language code from filename like "guide.ja.pdf" */}}
-                {{- $parts := split $filename "." }}
-                {{- if ge (len $parts) 3 }}
-                  {{- $langCode = index $parts (sub (len $parts) 2) }}
-                {{ end }}
                 {{/* Skip if no language code found */}}
                 {{- if eq $langCode "" }}
                   {{- continue }}
                 {{ end }}
                 {{ $displayName = partial "functions/get-language-display-name.html" $langCode }}
-                <a href="{{ .Permalink }}" class="btn btn-outline-secondary btn-sm" title="Download {{ $displayName }} PDF">
+                <a href="{{ .Resource.Permalink }}" class="btn btn-outline-secondary btn-sm" title="Download {{ $displayName }} PDF">
                   <i class="fas fa-file-pdf me-1"></i>
                   {{ $displayName }}
                 </a>
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-all-versions.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-all-versions.html
index 6e0d6e5b..ce54be8d 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-all-versions.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-all-versions.html
@@ -1,61 +1 @@
-{{/* Function: get-all-versions
-  Purpose: Get all available versions for a guide section, sorted by date (newest first)
-  Input: A guide page
-  Output: A slice of version objects with version string, URL, and title
-*/}}
-
-{{- $section := .Section -}}
-{{- $versions := slice -}}
-
-{{- /* Get all pages in the current section */ -}}
-{{- $sectionPages := where .Site.RegularPages "Section" $section -}}
-
-{{- /* Filter for guide pages */ -}}
-{{- $guidePages := where $sectionPages "Type" "guide" -}}
-
-{{- /* Get the latest version to determine section root URL */ -}}
-{{- $latestVersion := partial "functions/get-latest-version" . -}}
-
-{{- /* Get the section page URL for the latest version */ -}}
-{{- $sectionPage := .Site.GetPage $section -}}
-{{- $sectionUrl := "/" -}}
-{{- if $sectionPage -}}
-  {{- $sectionUrl = $sectionPage.RelPermalink -}}
-{{- else -}}
-  {{- $sectionUrl = printf "/%s/" $section -}}
-{{- end -}}
-
-{{- /* Extract versions from all guide pages */ -}}
-{{- range $guidePages -}}
-  {{- $pathParts := split .RelPermalink "/" -}}
-  {{- $pageVersion := "" -}}
-  {{- range $pathParts -}}
-    {{- if and (ne . "") (findRE `^\d{4}\.\d+$` .) -}}
-      {{- $pageVersion = . -}}
-      {{- break -}}
-    {{- end -}}
-  {{- end -}}
-
-  {{- if $pageVersion -}}
-    {{- /* Use section root URL for latest version, specific version URL for others */ -}}
-    {{- $versionUrl := .RelPermalink -}}
-    {{- if eq $pageVersion $latestVersion -}}
-      {{- $versionUrl = $sectionUrl -}}
-    {{- end -}}
-
-    {{- $versionObj := dict
-      "version" $pageVersion
-      "url" $versionUrl
-      "title" .Title
-      "date" .Date
-      "page" .
-      "isLatest" (eq $pageVersion $latestVersion)
-    -}}
-    {{- $versions = $versions | append $versionObj -}}
-  {{- end -}}
-{{- end -}}
-
-{{- /* Sort versions by date (newest first) */ -}}
-{{- $sortedVersions := sort $versions "date" "desc" -}}
-
-{{- return $sortedVersions -}}
+{{- return (partial "openguide/editions/get-guide-version-options.html" .) -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-catalogue.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-catalogue.html
index 5ab09f9e..cf719fe1 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-catalogue.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-catalogue.html
@@ -1,93 +1,13 @@
-{{/* Initialize slice with current language guide sections */}}
-{{ $sections := where .Site.Sections "Type" "guide" }}
-
-{{/* Flatten the slice if needed and remove duplicates */}}
-{{ $finalSections := slice }}
-{{ range $sections }}
-  {{ if reflect.IsSlice . }}
-    {{ range . }}
-      {{ $finalSections = $finalSections | append . }}
-    {{ end }}
-  {{ else }}
-    {{ $finalSections = $finalSections | append . }}
-  {{ end }}
-{{ end }}
-
-{{/* Remove duplicates by checking RelPermalink */}}
-{{ $uniqueSections := slice }}
-{{ $seen := slice }}
-{{ range $finalSections }}
-  {{ if not (in $seen .RelPermalink) }}
-    {{ $uniqueSections = $uniqueSections | append . }}
-    {{ $seen = $seen | append .RelPermalink }}
-  {{ end }}
-{{ end }}
-
-{{/* Sort sections by weight */}}
-{{ $sortedSections := sort $uniqueSections "Weight" }}
-
-{{/* Transform to simplified structure with only useful information */}}
-{{ $guideInfo := slice }}
-{{ range $sortedSections }}
-  {{/* Get all guide versions for this section */}}
-  {{ $guidePages := where .Pages "Type" "guide" }}
-
-  {{/* Get the latest version for this section using the dedicated function */}}
-  {{ $latestVersionNumber := partial "functions/get-latest-version" . }}
-
-  {{/* Extract versions and create version info */}}
-  {{ $versions := slice }}
-  {{ range $guidePages.ByDate.Reverse }}
-    {{/* Extract version from URL path */}}
-    {{ $pathParts := split .RelPermalink "/" }}
-    {{ $version := "" }}
-    {{ range $pathParts }}
-      {{ if and (ne . "") (findRE `^\d{4}\.\d+$` .) }}
-        {{ $version = . }}
-        {{ break }}
-      {{ end }}
-    {{ end }}
-
-    {{ if $version }}
-      {{/* Get available translations for this version using the dedicated function */}}
-      {{ $versionTranslations := partial "functions/get-guide-translations-for-version" . }}
-
-      {{/* Construct the bundle path based on section and version */}}
-      {{ $bundlePath := "" }}
-      {{ if .Path }}
-        {{ $bundlePath = .Path }}
-      {{ else }}
-        {{/* Construct path from section and version if .Path is empty */}}
-        {{ $bundlePath = printf "content/%s/%s/" .Section $version }}
-      {{ end }}
-
-      {{ $versionInfo := dict
-        "Version" $version
-        "Title" .Title
-        "Date" .Date
-        "RelPermalink" .RelPermalink
-        "Path" $bundlePath
-        "Description" .Description
-        "Latest" (eq $version $latestVersionNumber)
-        "Translations" $versionTranslations
-      }}
-      {{ $versions = $versions | append $versionInfo }}
-    {{ end }}
-  {{ end }}
-
-  {{ $info := dict
-    "Title" .Title
-    "Path" .Path
-    "RelPermalink" .RelPermalink
-    "Section" .Section
-    "Type" .Type
-    "Weight" .Weight
-    "Description" .Description
-    "Versions" $versions
-    "LatestVersion" $latestVersionNumber
-  }}
-  {{ $guideInfo = $guideInfo | append $info }}
-{{ end }}
-
-{{/* Return the simplified guide information */}}
-{{ return $guideInfo }}
+{{/* Compatibility: explicitly project the original JSON shape, never Hugo objects. */}}
+{{- $guides := slice -}}
+{{- range (partial "openguide/guides/get-guide-catalogue.html" .).Guides -}}
+  {{- $latest := partial "functions/get-latest-version.html" .Page -}}
+  {{- $versions := slice -}}
+  {{- range .Versions -}}
+    {{- $translations := partial "functions/get-guide-translations-for-version.html" .Page -}}
+    {{- $path := .Page.Path | default (printf "content/%s/%s/" .Page.Section .Version) -}}
+    {{- $versions = $versions | append (dict "Version" .Version "Title" .Page.Title "Date" .Page.Date "RelPermalink" .Page.RelPermalink "Path" $path "Description" .Page.Description "Latest" (eq .Version $latest) "Translations" $translations) -}}
+  {{- end -}}
+  {{- $guides = $guides | append (dict "Title" .Page.Title "Path" .Page.Path "RelPermalink" .Page.RelPermalink "Section" .Page.Section "Type" .Page.Type "Weight" .Page.Weight "Description" .Page.Description "Versions" $versions "LatestVersion" $latest) -}}
+{{- end -}}
+{{- return $guides -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-for-version.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-for-version.html
index d568c88a..6aeb676a 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-for-version.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-for-version.html
@@ -1,160 +1,6 @@
-{{- $guideVersionPage := . }}
-
-{{/* Extract version from the page object */}}
-{{ $guideVersion := "" }}
-{{ if $guideVersionPage.File }}
-  {{ $guideVersion = $guideVersionPage.File.Dir | strings.TrimSuffix "/" | path.Base }}
-{{ else }}
-  {{/* Fallback: extract from RelPermalink */}}
-  {{ $pathParts := split (strings.TrimSuffix $guideVersionPage.RelPermalink "/") "/" }}
-  {{ $guideVersion = index $pathParts (sub (len $pathParts) 1) }}
-{{ end }}
-
-{{/* Get all translations for this guide version page */}}
-{{ $allTranslations := $guideVersionPage.AllTranslations }}
-{{ $currentLang := $guideVersionPage.Language.Lang }}
-
-{{/* Collect all unique languages from both translations and PDFs */}}
-{{ $allLanguages := slice }}
-
-{{/* Add languages from online translations */}}
-{{ range $allTranslations }}
-  {{ $lang := .Language.Lang }}
-  {{ if not (in $allLanguages $lang) }}
-    {{ $allLanguages = $allLanguages | append $lang }}
-  {{ end }}
-{{ end }}
-
-{{/* Add languages from PDF resources */}}
-{{ $pdfPattern := "pdf/*.*.pdf" }}
-{{ $pdfResources := $guideVersionPage.Resources.Match $pdfPattern }}
-{{ range $pdfResources }}
-  {{/* Extract language from PDF filename - same logic as version-card.html */}}
-  {{ $pdfName := .Name }}
-  {{ $parts := split $pdfName "." }}
-  {{ if ge (len $parts) 3 }}
-    {{ $langFromPDF := index $parts (sub (len $parts) 2) }}
-    {{ if not (in $allLanguages $langFromPDF) }}
-      {{ $allLanguages = $allLanguages | append $langFromPDF }}
-    {{ end }}
-  {{ end }}
-{{ end }}
-
-{{/* Create lookup maps for efficiency */}}
-{{ $translationsByLang := dict }}
-{{ range $allTranslations }}
-  {{ $lang := .Language.Lang }}
-  {{ $translationsByLang = merge $translationsByLang (dict $lang .) }}
-{{ end }}
-
-{{ $pdfsByLang := dict }}
-{{ range $pdfResources }}
-  {{ $pdfName := .Name }}
-  {{ $parts := split $pdfName "." }}
-  {{ if ge (len $parts) 3 }}
-    {{ $langFromPDF := index $parts (sub (len $parts) 2) }}
-    {{ $pdfsByLang = merge $pdfsByLang (dict (lower $langFromPDF) .) }}
-  {{ end }}
-{{ end }}
-
-{{/* Build final translations list */}}
-{{ $translations := slice }}
-{{ range $allLanguages }}
-  {{ $lang := . }}
-  {{ $langConfig := $guideVersionPage.Site.Language }}
-  {{ $langConfigFound := false }}
-  {{ range hugo.Sites }}
-    {{ if eq .Language.Lang $lang }}
-      {{ $langConfig = .Language }}
-      {{ $langConfigFound = true }}
-    {{ end }}
-  {{ end }}
-  {{ $page := index $translationsByLang $lang }}
-
-  // Look up PDF by normalized lang
-  {{ $langKey := lower $lang }}
-  {{ $pdfResource := index $pdfsByLang $langKey }}
-
-  // Fallback: check the translation page’s own resources
-  {{ if (and (not $pdfResource) $page) }}
-    {{/* Untagged resources are shared across languages. Select only this
-         language's PDF, never the first PDF in the translation's resources. */}}
-    {{ $langPdfResources := $page.Resources.Match (printf "pdf/*.%s.pdf" $lang) }}
-    {{ if eq (len $langPdfResources) 0 }}
-      {{ $langPdfResources = $page.Resources.Match (printf "pdf/*.%s.pdf" (lower $lang)) }}
-    {{ end }}
-    {{ if gt (len $langPdfResources) 0 }}
-      {{ $pdfResource = index $langPdfResources 0 }}
-    {{ end }}
-  {{ end }}
-
-  {{/* Check if content is available for reading online */}}
-  {{ $hasContent := false }}
-  {{ $hasPage := false }}
-  {{ if $page }}
-    {{ $hasPage = true }}
-    {{/* Check if page has actual body content (not just frontmatter) */}}
-    {{/* Plain contains the rendered content body without frontmatter */}}
-    {{/* Count words in Plain to ensure actual content exists, not just translated frontmatter */}}
-    {{ $plainContent := trim $page.Plain " \n\r\t" }}
-    {{ $plainWords := split $plainContent " " | len }}
-    {{ $hasContent = gt $plainWords 10 }}
-  {{ end }}
-
-  {{/* Check if PDF is available and get PDF path */}}
-  {{ $hasPDF := ne $pdfResource nil }}
-  {{ $pdfPath := "" }}
-  {{ if $pdfResource }}
-    {{ $pdfPath = $pdfResource.RelPermalink }}
-  {{ end }}
-
-  {{/* Get language display name - use site config if available, otherwise use lookup function */}}
-  {{ $languageName := "" }}
-  {{ if $langConfigFound }}
-    {{ $languageName = $langConfig.LanguageName | default $lang }}
-  {{ else }}
-    {{ $languageName = partial "functions/get-language-display-name.html" $lang }}
-  {{ end }}
-
-  {{/* Use page data if available, otherwise create fallback */}}
-  {{ $title := printf "Guide %s" $guideVersion }}
-  {{ $relPermalink := "" }}
-  {{ $path := "" }}
-  {{ $date := now }}
-  {{ $description := printf "Guide available in %s" $languageName }}
-
-  {{ if $page }}
-    {{ $title = $page.Title }}
-    {{ $relPermalink = $page.RelPermalink }}
-    {{ $path = $page.Path }}
-    {{ $date = $page.Date }}
-    {{ $description = $page.Description | default $page.Summary }}
-  {{ else }}
-    {{ $title = $guideVersionPage.Title }}
-    {{ $relPermalink = $guideVersionPage.RelPermalink }}
-    {{ $path = $guideVersionPage.Path }}
-    {{ $date = $guideVersionPage.Date }}
-    {{ $description = $guideVersionPage.Description | default $guideVersionPage.Summary }}
-  {{ end }}
-
-  {{ $translationInfo := dict
-    "Language" $lang
-    "LanguageName" $languageName
-    "Weight" ($langConfig.Weight | default 999)
-    "Title" $title
-    "RelPermalink" $relPermalink
-    "Path" $path
-    "VersionPath" $guideVersionPage.Path
-    "Date" $date
-    "Status" (cond (and $hasContent $hasPDF) "published" (cond $hasContent "online-only" (cond $hasPDF "pdf-only" "site-only")))
-    "ReadOnline" (cond $hasContent true false)
-    "ReadOnlineStub" (cond $hasPage true false)
-    "ReadPDF" (cond $hasPDF true false)
-    "PathPdf" $pdfPath
-  }}
-  {{ $translations = $translations | append $translationInfo }}
-{{ end }}
-
-{{ $translations = sort $translations "Version" }}
-{{/* Return just the translations array */}}
-{{ return $translations }}
+{{/* Compatibility: preserve the public translation fields and ordering. */}}
+{{- $translations := slice -}}
+{{- range partial "openguide/translations/discover-edition-translations.html" . -}}
+  {{- $translations = $translations | append (partial "openguide/translations/project-legacy-translation.html" .) -}}
+{{- end -}}
+{{- return (sort $translations "Version") -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-list.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-list.html
index d02f5323..822387ab 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-list.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-list.html
@@ -1,101 +1 @@
-{{/* Function: get-guide-translations-list
-  Purpose: Get a flat list of the latest version available for each language across all versions of a single guide
-  Input: A single guide page (section)
-  Output: A slice of language objects with the latest version info for each language
-*/}}
-
-{{/* Get all versions for this guide */}}
-{{ $guidePages := where .Pages "Type" "guide" }}
-
-{{/* Create a slice with version info for sorting */}}
-{{ $versionsWithInfo := slice }}
-{{ range $guidePages }}
-  {{/* Extract version from URL path */}}
-  {{ $pathParts := split .RelPermalink "/" }}
-  {{ $version := "" }}
-  {{ range $pathParts }}
-    {{ if and (ne . "") (findRE `^\d{4}\.\d+$` .) }}
-      {{ $version = . }}
-      {{ break }}
-    {{ end }}
-  {{ end }}
-  
-  {{ if $version }}
-    {{/* Parse version for sorting (YYYY.M format) */}}
-    {{ $versionParts := split $version "." }}
-    {{ $year := int (index $versionParts 0) }}
-    {{ $month := int (index $versionParts 1) }}
-    {{ $sortKey := add (mul $year 100) $month }}
-    {{ $versionsWithInfo = $versionsWithInfo | append (dict "page" . "version" $version "sortKey" $sortKey) }}
-  {{ end }}
-{{ end }}
-
-{{/* Sort versions in DESCENDING order (newest first) */}}
-{{ $versionsWithInfo = sort $versionsWithInfo "sortKey" "desc" }}
-
-{{/* Map to track best version for each language */}}
-{{ $languageMap := dict }}
-
-{{/* Process all versions (newest to oldest) to find best available for each language */}}
-{{ range $versionsWithInfo }}
-  {{ $guidePage := .page }}
-  {{ $version := .version }}
-  
-  {{/* Get available translations for this version using the dedicated function */}}
-  {{ $versionTranslations := partial "functions/get-guide-translations-for-version" $guidePage }}
-
-  {{/* Process each translation to find the best version for each language */}}
-  {{ range $versionTranslations }}
-    {{ $langCode := .Language }}
-
-    {{/* Check if this translation is usable (has content or PDF) */}}
-    {{ $isUsable := or (eq .ReadOnline true) (eq .ReadPDF true) }}
-
-    {{/* Only process usable translations */}}
-    {{ if $isUsable }}
-      {{/* Check if we already have this language */}}
-      {{ $existing := index $languageMap $langCode }}
-      {{ if not $existing }}
-        {{/* First time seeing this language, add it */}}
-        {{ $translationWithVersion := merge . (dict "Version" $version) }}
-        {{ $languageMap = merge $languageMap (dict $langCode $translationWithVersion) }}
-      {{ else }}
-        {{/* We already have this language from a newer version */}}
-        {{/* Only replace if current (older) version has ReadOnline content and existing doesn't */}}
-        {{ if and (eq .ReadOnline true) (ne $existing.ReadOnline true) }}
-          {{/* This older version has actual content, while newer version doesn't - use this one */}}
-          {{ $updatedTranslation := merge . (dict "Version" $version) }}
-          {{ $languageMap = merge $languageMap (dict $langCode $updatedTranslation) }}
-        {{ end }}
-      {{ end }}
-    {{ end }}
-  {{ end }}
-{{ end }}
-
-{{/* Convert map to sorted slice */}}
-{{ $translationsList := slice }}
-{{ range $langCode, $translation := $languageMap }}
-  {{/* Ensure all required fields are present */}}
-  {{ if not $translation.Version }}
-    {{/* Try to extract version from the translation's path */}}
-    {{ $pathParts := split $translation.RelPermalink "/" }}
-    {{ $extractedVersion := "" }}
-    {{ range $pathParts }}
-      {{ if and (ne . "") (findRE `^\d{4}\.\d+$` .) }}
-        {{ $extractedVersion = . }}
-        {{ break }}
-      {{ end }}
-    {{ end }}
-    {{ if $extractedVersion }}
-      {{ $translation = merge $translation (dict "Version" $extractedVersion) }}
-    {{ end }}
-  {{ end }}
-
-  {{ $translationsList = $translationsList | append $translation }}
-{{ end }}
-
-{{/* Sort by weight then by language name for consistent output */}}
-{{ $translationsList = sort $translationsList "Weight" "asc" }}
-
-{{/* Return the flat list of latest translations */}}
-{{ return $translationsList }}
+{{- return (partial "openguide/translations/select-preferred-guide-translations.html" .) -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-history-chain.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-history-chain.html
index 56034781..9793da66 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-history-chain.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-history-chain.html
@@ -1,112 +1 @@
-{{/* Get complete history chain for the current section
-  Returns a dict with:
-  - current: latest version of current guide
-  - history: historical versions of current guide
-  - forkSource: latest version of source guide (if forked)
-  - forkHistory: historical versions of source guide (if forked)
-*/}}
-
-{{- $result := dict "current" nil "history" slice "forkSource" nil "forkHistory" slice }}
-
-{{/* Get current section's latest version using get-all-versions */}}
-{{- $currentSection := .Section }}
-{{- $allVersions := partial "functions/get-all-versions" . }}
-
-{{/* Find current latest version */}}
-{{- if $allVersions }}
-  {{- $latestVersionObj := index $allVersions 0 }}
-  {{- $result = merge $result (dict "current" $latestVersionObj.page) }}
-
-  {{/* Get historical versions (exclude the latest) */}}
-  {{- if gt (len $allVersions) 1 }}
-    {{- $historyPages := slice }}
-    {{- range after 1 $allVersions }}
-      {{- $historyPages = $historyPages | append .page }}
-    {{- end }}
-    {{- $result = merge $result (dict "history" $historyPages) }}
-  {{- end }}
-{{- end }}
-
-{{/* Check for fork relationship - use 'forked_from' instead of 'fork_source' */}}
-{{- $current := $result.current }}
-{{- if and $current $current.Params.forked_from }}
-  {{- $forkFromPath := $current.Params.forked_from }}
-
-  {{/* Parse the fork path - could be "guide/2025.5" or just "guide" */}}
-  {{- $forkPathParts := split $forkFromPath "/" }}
-  {{- $forkSection := index $forkPathParts 0 }}
-  {{- $forkVersion := "" }}
-  {{- if gt (len $forkPathParts) 1 }}
-    {{- $forkVersion = index $forkPathParts 1 }}
-  {{- end }}
-
-  {{/* Get fork source versions using get-all-versions */}}
-  {{- $forkSectionPage := .Site.GetPage $forkSection }}
-  {{- if $forkSectionPage }}
-    {{- $forkAllVersions := partial "functions/get-all-versions" $forkSectionPage }}
-
-    {{- if $forkAllVersions }}
-      {{/* If specific version is mentioned, try to find that version first */}}
-      {{- if $forkVersion }}
-        {{- range $forkAllVersions }}
-          {{- if eq .version $forkVersion }}
-            {{- $result = merge $result (dict "forkSource" .page) }}
-            {{- break }}
-          {{- end }}
-        {{- end }}
-      {{- end }}
-
-      {{/* Fallback to latest if specific version not found */}}
-      {{- if not $result.forkSource }}
-        {{- $latestForkVersionObj := index $forkAllVersions 0 }}
-        {{- $result = merge $result (dict "forkSource" $latestForkVersionObj.page) }}
-      {{- end }}
-
-      {{/* Get fork source history (exclude the fork source) */}}
-      {{- if gt (len $forkAllVersions) 1 }}
-        {{- $forkHistoryPages := slice }}
-        {{- range $forkAllVersions }}
-          {{- if ne .page $result.forkSource }}
-            {{- $forkHistoryPages = $forkHistoryPages | append .page }}
-          {{- end }}
-        {{- end }}
-        {{- $result = merge $result (dict "forkHistory" $forkHistoryPages) }}
-      {{- end }}
-    {{- end }}
-  {{- end }}
-{{- end }}
-
-{{/* Fallback: try to find by version number in URL path if no date-sorted results */}}
-{{- if not $result.current }}
-  {{- $sectionPages := where .Site.RegularPages "Section" $currentSection }}
-  {{- $latestVersion := "" }}
-  {{- $latestPage := "" }}
-
-  {{- range $page := $sectionPages }}
-    {{/* Extract version from URL path (e.g., /guide1/2025.7/) */}}
-    {{- $pathParts := split $page.RelPermalink "/" }}
-    {{- range $pathParts }}
-      {{- if and (ne . "") (findRE `^\d{4}\.\d+$` .) }}
-        {{- if or (not $latestVersion) (gt . $latestVersion) }}
-          {{- $latestVersion = . }}
-          {{- $latestPage = $page }}
-        {{- end }}
-      {{- end }}
-    {{- end }}
-  {{- end }}
-
-  {{- if $latestPage }}
-    {{- $result = merge $result (dict "current" $latestPage) }}
-  {{- end }}
-{{- end }}
-
-{{/* Final fallback: get the section page itself */}}
-{{- if not $result.current }}
-  {{- $sectionPage := .Site.GetPage $currentSection }}
-  {{- if $sectionPage }}
-    {{- $result = merge $result (dict "current" $sectionPage) }}
-  {{- end }}
-{{- end }}
-
-{{/* Return the complete history chain */}}
-{{- return $result }}
+{{- return (partial "openguide/history/get-guide-history-chain.html" .) -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-latest-version.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-latest-version.html
index a66d750b..bfa696ff 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-latest-version.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-latest-version.html
@@ -1,37 +1 @@
-{{- $section := .Section -}}
-{{- $latestVersion := "" -}}
-
-{{- /* Get all pages in the current section */ -}}
-{{- $sectionPages := where .Site.RegularPages "Section" $section -}}
-
-{{- /* Filter for guide pages and sort by date (newest first) */ -}}
-{{- $guidePages := where $sectionPages "Type" "guide" -}}
-{{- if $guidePages -}}
-  {{- $sortedPages := $guidePages.ByDate.Reverse -}}
-  {{- $guidePage := index $sortedPages 0 -}}
-  {{- /* Extract version from the latest guide page URL */ -}}
-  {{- $pathParts := split $guidePage.RelPermalink "/" -}}
-  {{- range $pathParts -}}
-    {{- if and (ne . "") (findRE `^\d{4}\.\d+$` .) -}}
-      {{- $latestVersion = . -}}
-      {{- break -}}
-    {{- end -}}
-  {{- end -}}
-{{- end -}}
-
-{{- /* Fallback: scan all section pages for highest version number */ -}}
-{{- if not $latestVersion -}}
-  {{- range $sectionPages -}}
-    {{- /* Extract version from URL path (e.g., /guide1/2025.7/) */ -}}
-    {{- $pathParts := split .RelPermalink "/" -}}
-    {{- range $pathParts -}}
-      {{- if and (ne . "") (findRE `^\d{4}\.\d+$` .) -}}
-        {{- if or (not $latestVersion) (gt . $latestVersion) -}}
-          {{- $latestVersion = . -}}
-        {{- end -}}
-      {{- end -}}
-    {{- end -}}
-  {{- end -}}
-{{- end -}}
-
-{{- return $latestVersion -}}
+{{- return (partial "openguide/editions/select-latest-guide-edition.html" .).Version -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/discover-guide-editions.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/discover-guide-editions.html
new file mode 100644
index 00000000..167d0e76
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/discover-guide-editions.html
@@ -0,0 +1,16 @@
+{{/* Input: dict Page, Scope (children or section), optional Order (source).
+     Output: Version/Page records; date descending unless source order requested.
+     Scope preserves the distinct existing child-page and whole-section callers.
+     Enumeration does not render Content or Plain. */}}
+{{- $pages := .Page.Pages -}}
+{{- if eq .Scope "section" }}{{ $pages = where .Page.Site.RegularPages "Section" .Page.Section }}{{ end -}}
+{{- $editions := slice -}}
+{{- $pages = where $pages "Type" "guide" -}}
+{{- if ne .Order "source" }}{{ $pages = $pages.ByDate.Reverse }}{{ end -}}
+{{- range $pages -}}
+  {{- $version := partial "openguide/editions/get-edition-version.html" . -}}
+  {{- if $version -}}
+    {{- $editions = $editions | append (dict "Version" $version "Page" .) -}}
+  {{- end -}}
+{{- end -}}
+{{- return $editions -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-edition-version.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-edition-version.html
new file mode 100644
index 00000000..0cf9761e
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-edition-version.html
@@ -0,0 +1,9 @@
+{{/* Input: Hugo page. Preserve the existing version convention in its permalink. */}}
+{{- $version := "" -}}
+{{- range split .RelPermalink "/" -}}
+  {{- if and (ne . "") (findRE `^\d{4}\.\d+$` .) -}}
+    {{- $version = . -}}
+    {{- break -}}
+  {{- end -}}
+{{- end -}}
+{{- return $version -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-guide-version-options.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-guide-version-options.html
new file mode 100644
index 00000000..d54f46dd
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/get-guide-version-options.html
@@ -0,0 +1,13 @@
+{{/* Input: Hugo page. Existing version-selector/history shape and URL behavior. */}}
+{{/* Keep the consumer override hook; its default delegates to the capability. */}}
+{{- $latest := partial "functions/get-latest-version.html" . -}}
+{{- $sectionPage := .Site.GetPage .Section -}}
+{{- $sectionURL := printf "/%s/" .Section -}}
+{{- if $sectionPage }}{{ $sectionURL = $sectionPage.RelPermalink }}{{ end -}}
+{{- $versions := slice -}}
+{{- range partial "openguide/editions/discover-guide-editions.html" (dict "Page" . "Scope" "section" "Order" "source") -}}
+  {{- $url := .Page.RelPermalink -}}
+  {{- if eq .Version $latest }}{{ $url = $sectionURL }}{{ end -}}
+  {{- $versions = $versions | append (dict "version" .Version "url" $url "title" .Page.Title "date" .Page.Date "page" .Page "isLatest" (eq .Version $latest)) -}}
+{{- end -}}
+{{- return (sort $versions "date" "desc") -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/select-latest-guide-edition.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/select-latest-guide-edition.html
new file mode 100644
index 00000000..e84eb601
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/editions/select-latest-guide-edition.html
@@ -0,0 +1,23 @@
+{{/* Input: Hugo page. Output: Version/Page. Preserve date-first, then lexical
+     section fallback, including the old empty-version result. */}}
+{{- $pages := where .Site.RegularPages "Section" .Section -}}
+{{- $guides := where $pages "Type" "guide" -}}
+{{- $version := "" -}}
+{{- $page := false -}}
+{{- if $guides -}}
+  {{- $page = index $guides.ByDate.Reverse 0 -}}
+  {{- $version = partial "openguide/editions/get-edition-version.html" $page -}}
+{{- end -}}
+{{- if not $version -}}
+  {{- range $candidate := $pages -}}
+    {{- range split .RelPermalink "/" -}}
+      {{- if and (ne . "") (findRE `^\d{4}\.\d+$` .) -}}
+        {{- if or (not $version) (gt . $version) -}}
+          {{- $version = . -}}
+          {{- $page = $candidate -}}
+        {{- end -}}
+      {{- end -}}
+    {{- end -}}
+  {{- end -}}
+{{- end -}}
+{{- return (dict "Version" $version "Page" $page) -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/discover-guides.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/discover-guides.html
new file mode 100644
index 00000000..552a87ba
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/discover-guides.html
@@ -0,0 +1,14 @@
+{{/* Input: Hugo page. Output: guide section pages in existing weight order. */}}
+{{- $guides := slice -}}
+{{- $seen := slice -}}
+{{- range where .Site.Sections "Type" "guide" -}}
+  {{- $sections := slice . -}}
+  {{- if reflect.IsSlice . }}{{ $sections = . }}{{ end -}}
+  {{- range $sections -}}
+    {{- if not (in $seen .RelPermalink) -}}
+      {{- $seen = $seen | append .RelPermalink -}}
+      {{- $guides = $guides | append . -}}
+    {{- end -}}
+  {{- end -}}
+{{- end -}}
+{{- return (sort $guides "Weight") -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/get-guide-catalogue.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/get-guide-catalogue.html
new file mode 100644
index 00000000..f4ae878f
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/get-guide-catalogue.html
@@ -0,0 +1,13 @@
+{{/* Input: Hugo page. Output: SiteLanguage/Guides; retains Hugo objects and
+     multiple PDFs. JSON callers must explicitly project their public fields. */}}
+{{- $guides := slice -}}
+{{- range partial "openguide/guides/discover-guides.html" . -}}
+  {{- $versions := slice -}}
+  {{- range partial "openguide/editions/discover-guide-editions.html" (dict "Page" . "Scope" "children") -}}
+    {{- $translations := partial "openguide/translations/discover-edition-translations.html" .Page -}}
+    {{- $versions = $versions | append (dict "Version" .Version "Page" .Page "Translations" $translations) -}}
+  {{- end -}}
+  {{- $latest := partial "openguide/editions/select-latest-guide-edition.html" . -}}
+  {{- $guides = $guides | append (dict "Id" .Section "Page" . "Title" .Title "Versions" $versions "LatestVersion" $latest.Version) -}}
+{{- end -}}
+{{- return (dict "SiteLanguage" .Site.Language.Lang "Guides" $guides) -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/history/get-guide-history-chain.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/history/get-guide-history-chain.html
new file mode 100644
index 00000000..56034781
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/history/get-guide-history-chain.html
@@ -0,0 +1,112 @@
+{{/* Get complete history chain for the current section
+  Returns a dict with:
+  - current: latest version of current guide
+  - history: historical versions of current guide
+  - forkSource: latest version of source guide (if forked)
+  - forkHistory: historical versions of source guide (if forked)
+*/}}
+
+{{- $result := dict "current" nil "history" slice "forkSource" nil "forkHistory" slice }}
+
+{{/* Get current section's latest version using get-all-versions */}}
+{{- $currentSection := .Section }}
+{{- $allVersions := partial "functions/get-all-versions" . }}
+
+{{/* Find current latest version */}}
+{{- if $allVersions }}
+  {{- $latestVersionObj := index $allVersions 0 }}
+  {{- $result = merge $result (dict "current" $latestVersionObj.page) }}
+
+  {{/* Get historical versions (exclude the latest) */}}
+  {{- if gt (len $allVersions) 1 }}
+    {{- $historyPages := slice }}
+    {{- range after 1 $allVersions }}
+      {{- $historyPages = $historyPages | append .page }}
+    {{- end }}
+    {{- $result = merge $result (dict "history" $historyPages) }}
+  {{- end }}
+{{- end }}
+
+{{/* Check for fork relationship - use 'forked_from' instead of 'fork_source' */}}
+{{- $current := $result.current }}
+{{- if and $current $current.Params.forked_from }}
+  {{- $forkFromPath := $current.Params.forked_from }}
+
+  {{/* Parse the fork path - could be "guide/2025.5" or just "guide" */}}
+  {{- $forkPathParts := split $forkFromPath "/" }}
+  {{- $forkSection := index $forkPathParts 0 }}
+  {{- $forkVersion := "" }}
+  {{- if gt (len $forkPathParts) 1 }}
+    {{- $forkVersion = index $forkPathParts 1 }}
+  {{- end }}
+
+  {{/* Get fork source versions using get-all-versions */}}
+  {{- $forkSectionPage := .Site.GetPage $forkSection }}
+  {{- if $forkSectionPage }}
+    {{- $forkAllVersions := partial "functions/get-all-versions" $forkSectionPage }}
+
+    {{- if $forkAllVersions }}
+      {{/* If specific version is mentioned, try to find that version first */}}
+      {{- if $forkVersion }}
+        {{- range $forkAllVersions }}
+          {{- if eq .version $forkVersion }}
+            {{- $result = merge $result (dict "forkSource" .page) }}
+            {{- break }}
+          {{- end }}
+        {{- end }}
+      {{- end }}
+
+      {{/* Fallback to latest if specific version not found */}}
+      {{- if not $result.forkSource }}
+        {{- $latestForkVersionObj := index $forkAllVersions 0 }}
+        {{- $result = merge $result (dict "forkSource" $latestForkVersionObj.page) }}
+      {{- end }}
+
+      {{/* Get fork source history (exclude the fork source) */}}
+      {{- if gt (len $forkAllVersions) 1 }}
+        {{- $forkHistoryPages := slice }}
+        {{- range $forkAllVersions }}
+          {{- if ne .page $result.forkSource }}
+            {{- $forkHistoryPages = $forkHistoryPages | append .page }}
+          {{- end }}
+        {{- end }}
+        {{- $result = merge $result (dict "forkHistory" $forkHistoryPages) }}
+      {{- end }}
+    {{- end }}
+  {{- end }}
+{{- end }}
+
+{{/* Fallback: try to find by version number in URL path if no date-sorted results */}}
+{{- if not $result.current }}
+  {{- $sectionPages := where .Site.RegularPages "Section" $currentSection }}
+  {{- $latestVersion := "" }}
+  {{- $latestPage := "" }}
+
+  {{- range $page := $sectionPages }}
+    {{/* Extract version from URL path (e.g., /guide1/2025.7/) */}}
+    {{- $pathParts := split $page.RelPermalink "/" }}
+    {{- range $pathParts }}
+      {{- if and (ne . "") (findRE `^\d{4}\.\d+$` .) }}
+        {{- if or (not $latestVersion) (gt . $latestVersion) }}
+          {{- $latestVersion = . }}
+          {{- $latestPage = $page }}
+        {{- end }}
+      {{- end }}
+    {{- end }}
+  {{- end }}
+
+  {{- if $latestPage }}
+    {{- $result = merge $result (dict "current" $latestPage) }}
+  {{- end }}
+{{- end }}
+
+{{/* Final fallback: get the section page itself */}}
+{{- if not $result.current }}
+  {{- $sectionPage := .Site.GetPage $currentSection }}
+  {{- if $sectionPage }}
+    {{- $result = merge $result (dict "current" $sectionPage) }}
+  {{- end }}
+{{- end }}
+
+{{/* Return the complete history chain */}}
+{{- return $result }}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/discover-edition-pdfs.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/discover-edition-pdfs.html
new file mode 100644
index 00000000..33df5e3a
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/discover-edition-pdfs.html
@@ -0,0 +1,11 @@
+{{/* Input: dict Page, optional Pattern. Output: Name/Language/Resource records.
+     Retain every matching resource, including multiple files for one language. */}}
+{{- $pdfs := slice -}}
+{{- $pattern := .Pattern | default "pdf/*.*.pdf" -}}
+{{- range .Page.Resources.Match $pattern -}}
+  {{- $language := "" -}}
+  {{- $parts := split .Name "." -}}
+  {{- if ge (len $parts) 3 }}{{ $language = index $parts (sub (len $parts) 2) }}{{ end -}}
+  {{- $pdfs = $pdfs | append (dict "Name" .Name "Language" $language "Resource" .) -}}
+{{- end -}}
+{{- return $pdfs -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-first-edition-pdf.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-first-edition-pdf.html
new file mode 100644
index 00000000..49bbe9ea
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-first-edition-pdf.html
@@ -0,0 +1,6 @@
+{{/* Input: Page and Pattern. Preserve Resources.GetMatch's first-match policy.
+     Return the Hugo resource or false. Enumeration belongs to PDF discovery. */}}
+{{- $pdfs := partial "openguide/pdfs/discover-edition-pdfs.html" . -}}
+{{- $resource := false -}}
+{{- with $pdfs }}{{ $resource = (index . 0).Resource }}{{ end -}}
+{{- return $resource -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-translation-pdfs.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-translation-pdfs.html
new file mode 100644
index 00000000..dbe5797c
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/pdfs/select-translation-pdfs.html
@@ -0,0 +1,7 @@
+{{/* Input: dict PDFs, Language. Select from discovered records; no resource scan. */}}
+{{- $language := lower .Language -}}
+{{- $pdfs := slice -}}
+{{- range .PDFs -}}
+  {{- if eq (lower .Language) $language }}{{ $pdfs = $pdfs | append . }}{{ end -}}
+{{- end -}}
+{{- return $pdfs -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/discover-edition-translations.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/discover-edition-translations.html
new file mode 100644
index 00000000..2346a9cb
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/discover-edition-translations.html
@@ -0,0 +1,30 @@
+{{/* Input: edition Hugo page. Output: Language/Page/EditionPage/PDFs records.
+     Page is false for a PDF-only language. LegacyPDF preserves the old single
+     download selection without discarding other resources. No body rendering. */}}
+{{- $editionPage := . -}}
+{{- $pages := .AllTranslations -}}
+{{- $pdfs := partial "openguide/pdfs/discover-edition-pdfs.html" (dict "Page" .) -}}
+{{- $languages := slice -}}
+{{- range $pages -}}
+  {{- if not (in $languages .Language.Lang) }}{{ $languages = $languages | append .Language.Lang }}{{ end -}}
+{{- end -}}
+{{- range $pdfs -}}
+  {{- if and .Language (not (in $languages .Language)) }}{{ $languages = $languages | append .Language }}{{ end -}}
+{{- end -}}
+{{- $translations := slice -}}
+{{- range $language := $languages -}}
+  {{- $page := false -}}
+  {{- range $pages }}{{ if eq .Language.Lang $language }}{{ $page = . }}{{ end }}{{ end -}}
+  {{- $matches := partial "openguide/pdfs/select-translation-pdfs.html" (dict "PDFs" $pdfs "Language" $language) -}}
+  {{- $selected := false -}}
+  {{- range $matches }}{{ $selected = .Resource }}{{ end -}}
+  {{- if and (not $selected) $page -}}
+    {{- $matches = partial "openguide/pdfs/discover-edition-pdfs.html" (dict "Page" $page "Pattern" (printf "pdf/*.%s.pdf" $language)) -}}
+    {{- if not $matches -}}
+      {{- $matches = partial "openguide/pdfs/discover-edition-pdfs.html" (dict "Page" $page "Pattern" (printf "pdf/*.%s.pdf" (lower $language))) -}}
+    {{- end -}}
+    {{- if $matches }}{{ $selected = (index $matches 0).Resource }}{{ end -}}
+  {{- end -}}
+  {{- $translations = $translations | append (dict "Language" $language "Page" $page "EditionPage" $editionPage "PDFs" $matches "LegacyPDF" $selected) -}}
+{{- end -}}
+{{- return $translations -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/project-legacy-translation.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/project-legacy-translation.html
new file mode 100644
index 00000000..ab4ed744
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/project-legacy-translation.html
@@ -0,0 +1,32 @@
+{{/* Input: discovered translation. Output: existing public translation fields.
+     Preserve the catalogue's >10-word rule and contextual language defaults. */}}
+{{- $language := .Language -}}
+{{- $page := .Page -}}
+{{- $editionPage := .EditionPage -}}
+{{- $configuration := $editionPage.Site.Language -}}
+{{- $configured := false -}}
+{{- range hugo.Sites -}}
+  {{- if eq .Language.Lang $language }}{{ $configuration = .Language }}{{ $configured = true }}{{ end -}}
+{{- end -}}
+{{- $languageName := "" -}}
+{{- if $configured -}}
+  {{- $languageName = $configuration.LanguageName | default $language -}}
+{{- else -}}
+  {{- $languageName = partial "functions/get-language-display-name.html" $language -}}
+{{- end -}}
+{{- $hasContent := false -}}
+{{- $metadata := $editionPage -}}
+{{- if $page -}}
+  {{- $metadata = $page -}}
+  {{- $hasContent = gt (len (split (trim $page.Plain " \n\r\t") " ")) 10 -}}
+{{- end -}}
+{{- $pdfPath := "" -}}
+{{- if .LegacyPDF }}{{ $pdfPath = .LegacyPDF.RelPermalink }}{{ end -}}
+{{- return (dict
+  "Language" $language "LanguageName" $languageName
+  "Weight" ($configuration.Weight | default 999)
+  "Title" $metadata.Title "RelPermalink" $metadata.RelPermalink
+  "Path" $metadata.Path "VersionPath" $editionPage.Path "Date" $metadata.Date
+  "Status" (cond (and $hasContent .LegacyPDF) "published" (cond $hasContent "online-only" (cond .LegacyPDF "pdf-only" "site-only")))
+  "ReadOnline" $hasContent "ReadOnlineStub" (cond $page true false)
+  "ReadPDF" (cond .LegacyPDF true false) "PathPdf" $pdfPath) -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/resolve-translation-fallback.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/resolve-translation-fallback.html
new file mode 100644
index 00000000..4942fad0
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/resolve-translation-fallback.html
@@ -0,0 +1,3 @@
+{{/* Input: Hugo page. Preserve the rendering fallback to the first Hugo site. */}}
+{{- $defaultSite := index hugo.Sites 0 -}}
+{{- return ($defaultSite.GetPage .Path) -}}
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html
new file mode 100644
index 00000000..54afbde2
--- /dev/null
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html
@@ -0,0 +1,82 @@
+{{/* Capability: select-preferred-guide-translations
+  Purpose: Get a flat list of the latest version available for each language across all versions of a single guide
+  Input: A single guide page (section)
+  Output: A slice of language objects with the latest version info for each language
+*/}}
+
+{{/* Preserve source enumeration before the numeric sort, including ties. */}}
+{{ $versionsWithInfo := slice }}
+{{ range partial "openguide/editions/discover-guide-editions.html" (dict "Page" . "Scope" "children" "Order" "source") }}
+  {{ $versionParts := split .Version "." }}
+  {{ $sortKey := add (mul (int (index $versionParts 0)) 100) (int (index $versionParts 1)) }}
+  {{ $versionsWithInfo = $versionsWithInfo | append (dict "page" .Page "version" .Version "sortKey" $sortKey) }}
+{{ end }}
+{{/* Sort versions in DESCENDING order (newest first) */}}
+{{ $versionsWithInfo = sort $versionsWithInfo "sortKey" "desc" }}
+
+{{/* Map to track best version for each language */}}
+{{ $languageMap := dict }}
+
+{{/* Process all versions (newest to oldest) to find best available for each language */}}
+{{ range $versionsWithInfo }}
+  {{ $guidePage := .page }}
+  {{ $version := .version }}
+  
+  {{/* Get available translations for this version using the dedicated function */}}
+  {{ $versionTranslations := partial "functions/get-guide-translations-for-version" $guidePage }}
+
+  {{/* Process each translation to find the best version for each language */}}
+  {{ range $versionTranslations }}
+    {{ $langCode := .Language }}
+
+    {{/* Check if this translation is usable (has content or PDF) */}}
+    {{ $isUsable := or (eq .ReadOnline true) (eq .ReadPDF true) }}
+
+    {{/* Only process usable translations */}}
+    {{ if $isUsable }}
+      {{/* Check if we already have this language */}}
+      {{ $existing := index $languageMap $langCode }}
+      {{ if not $existing }}
+        {{/* First time seeing this language, add it */}}
+        {{ $translationWithVersion := merge . (dict "Version" $version) }}
+        {{ $languageMap = merge $languageMap (dict $langCode $translationWithVersion) }}
+      {{ else }}
+        {{/* We already have this language from a newer version */}}
+        {{/* Only replace if current (older) version has ReadOnline content and existing doesn't */}}
+        {{ if and (eq .ReadOnline true) (ne $existing.ReadOnline true) }}
+          {{/* This older version has actual content, while newer version doesn't - use this one */}}
+          {{ $updatedTranslation := merge . (dict "Version" $version) }}
+          {{ $languageMap = merge $languageMap (dict $langCode $updatedTranslation) }}
+        {{ end }}
+      {{ end }}
+    {{ end }}
+  {{ end }}
+{{ end }}
+
+{{/* Convert map to sorted slice */}}
+{{ $translationsList := slice }}
+{{ range $langCode, $translation := $languageMap }}
+  {{/* Ensure all required fields are present */}}
+  {{ if not $translation.Version }}
+    {{/* Try to extract version from the translation's path */}}
+    {{ $pathParts := split $translation.RelPermalink "/" }}
+    {{ $extractedVersion := "" }}
+    {{ range $pathParts }}
+      {{ if and (ne . "") (findRE `^\d{4}\.\d+$` .) }}
+        {{ $extractedVersion = . }}
+        {{ break }}
+      {{ end }}
+    {{ end }}
+    {{ if $extractedVersion }}
+      {{ $translation = merge $translation (dict "Version" $extractedVersion) }}
+    {{ end }}
+  {{ end }}
+
+  {{ $translationsList = $translationsList | append $translation }}
+{{ end }}
+
+{{/* Sort by weight then by language name for consistent output */}}
+{{ $translationsList = sort $translationsList "Weight" "asc" }}
+
+{{/* Return the flat list of latest translations */}}
+{{ return $translationsList }}
diff --git a/system/OpenGuidePlatform.PowerShell.Core/Contracts/README.md b/system/OpenGuidePlatform.PowerShell.Core/Contracts/README.md
index 1eb4a06f..834e187f 100644
--- a/system/OpenGuidePlatform.PowerShell.Core/Contracts/README.md
+++ b/system/OpenGuidePlatform.PowerShell.Core/Contracts/README.md
@@ -1,4 +1,4 @@
-# Platform contracts — version 1 candidate
+# Platform contracts — version 1
 
 These contracts belong to Core because they describe publishing intent and observations. They do not introduce new Hugo rendering inputs. Build, GitHub reporting, filesystem discovery, PDF generation and agent integrations adapt to these contracts.
 
@@ -8,7 +8,7 @@ These contracts belong to Core because they describe publishing intent and obser
 | assessment.schema.json | Observed wrapper/guide readiness, findings, evidence, remediation and stage outcome |
 | platform-lock.schema.json | Exact coordinated package, module, workflow, component and toolchain identities |
 
-The version-1 JSON Schemas are draft-07 and self-contained. Unknown fields and unsupported schema versions fail validation. A future incompatible contract gets a new schemaVersion and an explicit migration; tools must never silently reinterpret it. Version 1 is a candidate until E03/E04 operations and E07 distribution exercise it end to end.
+The version-1 JSON Schemas are draft-07 and self-contained. Unknown fields and unsupported schema versions fail validation. A future incompatible contract needs a new schemaVersion and an explicit migration; tools must never silently reinterpret it. See the [current-system reference](../../../docs/architecture/current-system.md) for how these formats are produced and consumed today.
 
 `tests/Contracts/fixtures` contains representative shapes, not installable consumer policies. The one-, two- and fifteen-guide examples use discovered guide names and editions, but their wrapper requirements and translation selections are deliberately incomplete. They must not be injected into deployed sites. The lock has synthetic hashes and an example.invalid package URL, not a release reservation.
 
@@ -25,14 +25,14 @@ Run `pwsh -File .build/Test-PlatformContracts.ps1` locally. The thin Platform co
 - Findings carry a stable code, affected scope/subject, explanation, remediation and evidence. A pass with a blocker is structurally invalid. Missing/dependent checks yield blocked, not pass.
 - Source-language fallback and extension relationships name their targets explicitly. Schema validation checks shape; it cannot establish whether those targets exist.
 
-## Semantic validation still to implement
+## Current semantic checks and separate acceptance boundaries
 
-E03 validates unique guide/edition/language keys, extension and fallback references/cycles, intent/download consistency, actual filesystem containment, protected hashes and effective publication rules. E04 computes report outcomes from checks and diagnoses missing reports; a caller-supplied outcome is not trusted. E07 validates package digests, module tag/source provenance, workflow/source coherence and supported toolchain combinations. E06 evaluates authoritative policy independently of PR-modifiable tests and schemas.
+Core checks guide/edition/language relationships, translation fallback and download intent, protected writes and source paths. Build checks effective Hugo configuration, source/assessment freshness, published resources, routes and artifact identity. Adoption and packaging validate release/package checksums and coordinated component identity. These checks have different inputs and should not be described as schema validation alone. The [execution plan](../../../docs/architecture/open-guide-platform-execution-plan.md) records which consumer, release and independent enforcement acceptance gates remain open.
 
-Passing these structural tests is not evidence that those enforcement features already exist. No schema or fixture is loaded by Hugo or by a consumer build at this stage.
+Passing structural or local tests is not evidence that independent enforcement or a consumer deployment has been accepted. Hugo does not load these schemas or fixtures; the GuideSite build loads or generates a policy-shaped inventory and records a separate assessment.
 
 ## Download publication paths
 
 A download's `path` locates the source relative to its edition. `publishedPaths` records one or more existing file paths relative to the built site, without a leading slash. Source paths and public paths are deliberately separate because Hugo mounts, language behaviour and wrapper routes vary by consumer. Explicit policies require reviewed public mappings. Inferred source inventories retain owning edition resource roots and defer public-path and byte checks until Validate receives the actual artifact. Prepare still requires the supplied source file; consumers do not maintain public PDF mappings.
 
-Artifact validation requires each eligible mapped file with the same source bytes. PDF-only and declared fallback resources remain valid. Excluded downloads are checked at their declared paths and by source hash/filename throughout the artifact, including outside language prefixes. Shared fallback bytes are allowed only at an explicitly eligible mapped path. Validate passes forbidden public paths to post-deployment verification.
\ No newline at end of file
+Artifact validation requires each eligible mapped file with the same source bytes. PDF-only and declared fallback resources remain valid. Excluded downloads are checked at their declared paths and by source hash/filename throughout the artifact, including outside language prefixes. Shared fallback bytes are allowed only at an explicitly eligible mapped path. Validate passes forbidden public paths to post-deployment verification.
diff --git a/tests/Core/HugoCatalogue.Tests.ps1 b/tests/Core/HugoCatalogue.Tests.ps1
new file mode 100644
index 00000000..6edcfaa1
--- /dev/null
+++ b/tests/Core/HugoCatalogue.Tests.ps1
@@ -0,0 +1,189 @@
+BeforeAll {
+    $root=Split-Path (Split-Path $PSScriptRoot -Parent) -Parent
+    $fixture=Join-Path $TestDrive 'catalogue'
+    $module=Join-Path $root 'system/OpenGuidePlatform.Hugo.Guides'
+    [IO.Directory]::CreateDirectory("$fixture/themes/guides/layouts/_partials")|Out-Null
+    Copy-Item "$module/layouts/_partials/*" "$fixture/themes/guides/layouts/_partials" -Recurse
+    [IO.Directory]::CreateDirectory("$fixture/layouts/guide")|Out-Null
+    [IO.Directory]::CreateDirectory("$fixture/layouts/shortcodes")|Out-Null
+    [IO.File]::WriteAllText("$fixture/layouts/shortcodes/catalogue-count.html",'{{ len (partial "openguide/guides/get-guide-catalogue.html" .Page).Guides }}')
+    [IO.File]::WriteAllText("$fixture/hugo.yaml",@'
+baseURL: https://catalogue.example/
+theme: guides
+defaultContentLanguage: en
+disableKinds: [taxonomy, term, RSS, sitemap]
+languages:
+  en: {languageName: English, weight: 1}
+  fr: {languageName: French, weight: 2}
+  es-419: {languageName: Latin American Spanish, weight: 3}
+  min: {languageName: Minionese, weight: 4}
+'@)
+    [IO.File]::WriteAllText("$fixture/hugo.production.yaml","languages:`n  min:`n    disabled: true`n")
+    $homeTemplate='{{ partial "functions/get-guide-translations-catalogue.html" . | jsonify }}'
+    $section='{{ partial "functions/get-guide-translations-list.html" . | jsonify }}'
+    $single='{{ partial "functions/get-guide-translations-for-version.html" . | jsonify }}'
+    [IO.File]::WriteAllText("$fixture/layouts/index.html",$homeTemplate)
+    [IO.File]::WriteAllText("$fixture/layouts/guide/list.html",$section)
+    [IO.File]::WriteAllText("$fixture/layouts/guide/single.html",$single)
+    # Rendering a body can itself query raw metadata. Eager body reads in raw
+    # discovery would introduce recursion when the public projection reads Plain.
+    $body=('A complete translated guide with enough words and characters for every existing reading availability rule. '*12)+'{{< catalogue-count >}}'
+    foreach($guide in @('kanban','open-kanban','third-guide')) {
+        [IO.Directory]::CreateDirectory("$fixture/content/$guide")|Out-Null
+        foreach($language in @('en','fr','es-419','min')) {
+            [IO.File]::WriteAllText("$fixture/content/$guide/_index.$language.md","---`ntitle: $guide`ntype: guide`nweight: 1`n---`n")
+        }
+    }
+    foreach($version in @('2020.12','2025.5')) {
+        [IO.Directory]::CreateDirectory("$fixture/content/kanban/$version/pdf")|Out-Null
+        foreach($language in @('en','fr','es-419','min')) {
+            $content=if($version -eq '2025.5' -and $language -eq 'fr'){''}else{$body}
+            [IO.File]::WriteAllText("$fixture/content/kanban/$version/index.$language.md","---`ntitle: Kanban $version $language`ntype: guide`ndate: $(if($version -eq '2025.5'){'2025-05-01'}else{'2020-12-01'})`n---`n$content")
+        }
+        foreach($language in @('en','fr','de','en-us','es-419')) {
+            [IO.File]::WriteAllText("$fixture/content/kanban/$version/pdf/kanban.$language.pdf","%PDF fixture $version $language")
+        }
+    }
+    foreach($guide in @('open-kanban','third-guide')) {
+        [IO.Directory]::CreateDirectory("$fixture/content/$guide/2025.7/pdf")|Out-Null
+        $fork=if($guide -eq 'open-kanban'){"forked_from: kanban/2020.12`n"}else{''}
+        [IO.File]::WriteAllText("$fixture/content/$guide/2025.7/index.en.md","---`ntitle: $guide 2025.7`ntype: guide`ndate: 2025-07-01`n${fork}---`n$body")
+        [IO.File]::WriteAllText("$fixture/content/$guide/2025.7/pdf/$guide.en.pdf",'%PDF fixture')
+    }
+    [IO.File]::WriteAllText("$fixture/content/open-kanban/2025.7/pdf/open-kanban.en-us.pdf",'%PDF US variant')
+    [IO.File]::WriteAllText("$fixture/content/open-kanban/2025.7/pdf/open-kanban-print.en.pdf",'%PDF print variant')
+    [IO.Directory]::CreateDirectory("$fixture/content/third-guide/2025.07")|Out-Null
+    [IO.File]::WriteAllText("$fixture/content/third-guide/2025.07/index.en.md","---`ntitle: Early tie`ntype: guide`nweight: 1`ndate: 2025-07-01`n---`n$body")
+    [IO.File]::WriteAllText("$fixture/content/third-guide/2025.7/index.en.md","---`ntitle: Later tie`ntype: guide`nweight: 20`ndate: 2025-07-01`n---`n$body")
+    function Invoke-CatalogueFixture([string]$target) {
+        $config=if($target -eq 'production'){'hugo.yaml,hugo.production.yaml'}else{'hugo.yaml'}
+        $log=@(& hugo --source $fixture --config $config --destination "$fixture/$target" --environment $target 2>&1)
+        if($LASTEXITCODE -ne 0 -or @($log|Where-Object {$_ -match '^ERROR'}).Count){throw "Catalogue fixture failed: $($log -join [Environment]::NewLine)"}
+    }
+    Invoke-CatalogueFixture preview
+    Invoke-CatalogueFixture production
+    $catalogue=Get-Content "$fixture/preview/index.html" -Raw|ConvertFrom-Json
+    $current=Get-Content "$fixture/preview/kanban/2025.5/index.html" -Raw|ConvertFrom-Json
+    $preferred=Get-Content "$fixture/preview/kanban/index.html" -Raw|ConvertFrom-Json
+    # Exercise the internal contract without serialising Hugo Page/Resource objects.
+    [IO.File]::WriteAllText("$fixture/layouts/index.html",@'
+{{- $catalogue := partial "openguide/guides/get-guide-catalogue.html" . -}}
+{{- $rows := slice -}}
+{{- range $catalogue.Guides -}}
+  {{- $id := .Id -}}
+  {{- range .Versions -}}
+    {{- $version := .Version -}}
+    {{- range .Translations -}}
+      {{- $pdfs := slice -}}
+      {{- range .PDFs -}}
+        {{- $pdfs = $pdfs | append (dict "Name" .Name "URL" .Resource.RelPermalink "MediaType" .Resource.MediaType.Type) -}}
+      {{- end -}}
+      {{- $rows = $rows | append (dict "Guide" $id "Version" $version "Language" .Language "HasPage" (not (not .Page)) "EditionKind" .EditionPage.Kind "PDFs" $pdfs) -}}
+    {{- end -}}
+  {{- end -}}
+{{- end -}}
+{{- $guide := .Site.GetPage "open-kanban" -}}
+{{- $chain := partial "openguide/history/get-guide-history-chain.html" $guide -}}
+{{- $forkURL := "" -}}{{- with $chain.forkSource }}{{ $forkURL = .RelPermalink }}{{ end -}}
+{{- $options := slice -}}
+{{- range partial "openguide/editions/get-guide-version-options.html" (.Site.GetPage "kanban") -}}
+  {{- $options = $options | append (dict "Version" .version "URL" .url "Latest" .isLatest) -}}
+{{- end -}}
+{{- $ties := slice -}}
+{{- range partial "functions/get-all-versions.html" (.Site.GetPage "third-guide") }}{{ $ties = $ties | append .version }}{{ end -}}
+{{- $preferredTie := partial "functions/get-guide-translations-list.html" (.Site.GetPage "third-guide") -}}
+{{- dict "Language" $catalogue.SiteLanguage "Rows" $rows "ForkURL" $forkURL "Options" $options "Ties" $ties "PreferredTie" $preferredTie | jsonify -}}
+'@)
+    Invoke-CatalogueFixture probe
+    $probe=Get-Content "$fixture/probe/index.html" -Raw|ConvertFrom-Json
+    # A consumer can override these old entry points. Dependent callers must
+    # continue observing those overrides, not just leave the entry points callable.
+    [IO.Directory]::CreateDirectory("$fixture/layouts/_partials/functions")|Out-Null
+    [IO.File]::WriteAllText("$fixture/layouts/_partials/functions/get-guide-translations-for-version.html",'{{ return (slice (dict "Language" "custom" "ReadOnline" true "ReadPDF" false "Weight" 1 "Title" "Consumer override")) }}')
+    [IO.File]::WriteAllText("$fixture/layouts/_partials/functions/get-latest-version.html",'{{ return "2020.12" }}')
+    [IO.File]::WriteAllText("$fixture/layouts/index.html",@'
+{{ $options := slice }}
+{{ range partial "functions/get-all-versions.html" (.Site.GetPage "kanban") }}
+  {{ $options = $options | append (dict "Version" .version "Latest" .isLatest "URL" .url) }}
+{{ end }}
+{{ dict "Catalogue" (partial "functions/get-guide-translations-catalogue.html" .) "Options" $options | jsonify }}
+'@)
+    Invoke-CatalogueFixture overrides
+    $overrides=Get-Content "$fixture/overrides/index.html" -Raw|ConvertFrom-Json
+    $overridePreferred=Get-Content "$fixture/overrides/kanban/index.html" -Raw|ConvertFrom-Json
+    [IO.File]::WriteAllText("$fixture/layouts/_partials/functions/get-all-versions.html",'{{ return (slice (dict "version" "2020.12" "page" (.Site.GetPage "kanban/2020.12"))) }}')
+    [IO.File]::WriteAllText("$fixture/layouts/index.html",'{{ $chain := partial "functions/get-history-chain.html" (.Site.GetPage "kanban") }}{{ dict "Current" $chain.current.RelPermalink | jsonify }}')
+    Invoke-CatalogueFixture historyOverride
+    $overrideHistory=Get-Content "$fixture/historyOverride/index.html" -Raw|ConvertFrom-Json
+}
+
+Describe 'Hugo capability catalogue' {
+    It 'preserves consumer overrides through catalogue, preferred translations, version options and history' {
+        $guide=$overrides.Catalogue|Where-Object Section -EQ kanban
+        $guide.LatestVersion | Should -Be '2020.12'
+        ($guide.Versions|Where-Object Version -EQ '2020.12').Latest | Should -BeTrue
+        $guide.Versions[0].Translations[0].Title | Should -Be 'Consumer override'
+        $overridePreferred[0].Language | Should -Be 'custom'
+        $overridePreferred[0].Version | Should -Be '2025.5'
+        ($overrides.Options|Where-Object Latest).Version | Should -Be '2020.12'
+        ($overrides.Options|Where-Object Latest).URL | Should -Be '/kanban/'
+        $overrideHistory.Current | Should -Be '/kanban/2020.12/'
+    }
+    It 'preserves original page ordering for equal dates and equal numeric edition keys' {
+        @($probe.Ties) | Should -Be @('2025.07','2025.7')
+        ($probe.PreferredTie|Where-Object Language -EQ en).Version | Should -Be '2025.07'
+    }
+    It 'retains multiple PDFs and usable Hugo objects without inventing a translated page' {
+        $english=$probe.Rows|Where-Object { $_.Guide -eq 'open-kanban' -and $_.Language -eq 'en' }
+        @($english.PDFs).Count | Should -Be 2
+        $english.EditionKind | Should -Be 'page'
+        @($english.PDFs|Where-Object MediaType -NE 'application/pdf').Count | Should -Be 0
+        @($english.PDFs|Where-Object { -not $_.URL }).Count | Should -Be 0
+        ($probe.Rows|Where-Object { $_.Guide -eq 'kanban' -and $_.Version -eq '2025.5' -and $_.Language -eq 'de' }).HasPage | Should -BeFalse
+    }
+    It 'preserves latest root URLs and explicit fork ancestry' {
+        ($probe.Options|Where-Object Latest).URL | Should -Be '/kanban/'
+        ($probe.Options|Where-Object Version -EQ '2020.12').URL | Should -Be '/kanban/2020.12/'
+        $probe.ForkURL | Should -Be '/kanban/2020.12/'
+    }
+    It 'scopes the catalogue to the calling Hugo language site' {
+        $french=Get-Content "$fixture/probe/fr/index.html" -Raw|ConvertFrom-Json
+        $probe.Language | Should -Be 'en'
+        $french.Language | Should -Be 'fr'
+    }
+}
+
+Describe 'Existing catalogue contracts' {
+    It 'discovers any number of guides and retains dated editions' {
+        @($catalogue).Count | Should -Be 3
+        $guide=$catalogue|Where-Object Section -EQ kanban
+        @($guide.Versions.Version) | Should -Be @('2025.5','2020.12')
+        $guide.LatestVersion | Should -Be '2025.5'
+    }
+    It 'retains the exact public translation field set' {
+        @($current[0].PSObject.Properties.Name|Sort-Object) | Should -Be @('Date','Language','LanguageName','Path','PathPdf','ReadOnline','ReadOnlineStub','ReadPDF','RelPermalink','Status','Title','VersionPath','Weight'|Sort-Object)
+    }
+    It 'distinguishes an empty translated page from a PDF-only language with no page' {
+        $french=$current|Where-Object Language -EQ fr
+        $french.ReadOnline | Should -BeFalse
+        $french.ReadOnlineStub | Should -BeTrue
+        $french.ReadPDF | Should -BeTrue
+        $german=$current|Where-Object Language -EQ de
+        $german.ReadOnlineStub | Should -BeFalse
+        $german.ReadPDF | Should -BeTrue
+    }
+    It 'preserves the preference for an older readable translation over a newer PDF-only edition' {
+        ($preferred|Where-Object Language -EQ fr).Version | Should -Be '2020.12'
+        ($preferred|Where-Object Language -EQ de).Version | Should -Be '2025.5'
+    }
+    It 'preserves numeric-region languages and unconfigured English PDF variants' {
+        ($current|Where-Object Language -EQ 'es-419').PathPdf | Should -Match 'kanban.es-419.pdf$'
+        ($current|Where-Object Language -EQ 'en-us').PathPdf | Should -Match 'kanban.en-us.pdf$'
+    }
+    It 'keeps site language context isolated between preview and production' {
+        Test-Path "$fixture/preview/min/kanban/2025.5/index.html" | Should -BeTrue
+        Test-Path "$fixture/production/min/kanban/2025.5/index.html" | Should -BeFalse
+        $production=Get-Content "$fixture/production/kanban/2025.5/index.html" -Raw|ConvertFrom-Json
+        @($production|Where-Object Language -EQ min).Count | Should -Be 0
+    }
+}

From 1f7f16084727a8221762b2ce847ddd4391ff6c18 Mon Sep 17 00:00:00 2001
From: Martin Hinshelwood <martin@nkdagility.com>
Date: Fri, 18 Sep 2026 17:11:47 +0100
Subject: [PATCH 2/2] fix: register PSGallery on fresh deployment runners

Preserve existing repository configuration, test setup failure paths, clarify PR status, and protect legacy translation ordering.
---
 docs/architecture/current-system.md           |  4 +-
 .../select-preferred-guide-translations.html  |  3 +-
 .../Install-GuideBuildDependencies.ps1        |  6 ++-
 tests/Core/BuildDependencies.Tests.ps1        | 43 +++++++++++++++++++
 tests/Core/HugoCatalogue.Tests.ps1            |  3 ++
 5 files changed, 55 insertions(+), 4 deletions(-)
 create mode 100644 tests/Core/BuildDependencies.Tests.ps1

diff --git a/docs/architecture/current-system.md b/docs/architecture/current-system.md
index ac5d341f..2997b0c8 100644
--- a/docs/architecture/current-system.md
+++ b/docs/architecture/current-system.md
@@ -1,6 +1,6 @@
 # OpenGuidePlatform current system
 
-This describes the implementation inspected from repository commit `2a178e6618c2b55c4ff55913e4e7965454ea19c1`, including the subsequently approved Hugo catalogue changes in this working tree (18 September 2026). Each section links to the implementation or schema that supports its claims. The [execution plan](open-guide-platform-execution-plan.md) records acceptance status; this page describes behavior in source, not a completed consumer rollout.
+This describes the implementation based on repository commit `2a178e6618c2b55c4ff55913e4e7965454ea19c1`, including the Hugo catalogue changes proposed in PR #52 as of 18 September 2026. Each section links to the implementation or schema that supports its claims. The [execution plan](open-guide-platform-execution-plan.md) records acceptance status; this page describes behavior in source, not PR approval, merge status or a completed consumer rollout.
 
 ## Components and ownership
 
@@ -86,6 +86,6 @@ The [adoption resolver](../../system/OpenGuidePlatform.PowerShell.GuideSiteAdopt
 
 Hugo dynamically discovers guides, editions, translations and PDF resources through [capability partials and their contracts](hugo-guide-catalogue.md). The [shared catalogue](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/guides/get-guide-catalogue.html) retains Hugo Page and Resource objects; the [compatibility adapter](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/functions/get-guide-translations-catalogue.html) projects the existing public JSON fields. Neither reads `discovered-site.json` or `assessment.json`.
 
-The [guide rendering template](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/guide/render-guide.html) uses capability functions for PDF lookup and same-path translation fallback. It retains presentation and its existing content-availability rules. The original [execution plan](open-guide-platform-execution-plan.md#16a-e14--refactor-hugo-module-contents-last) defers broader Hugo refactoring until consumer adoption; the subsequently approved catalogue work does not establish that those wider gates have passed.
+The [guide rendering template](../../system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/components/guide/render-guide.html) uses capability functions for PDF lookup and same-path translation fallback. It retains presentation and its existing content-availability rules. The original [execution plan](open-guide-platform-execution-plan.md#16a-e14--refactor-hugo-module-contents-last) defers broader Hugo refactoring until consumer adoption; the catalogue work in PR #52 does not establish that those wider gates have passed.
 
 The [execution plan](open-guide-platform-execution-plan.md#current-acceptance-status) records the remaining consumer adoption, independently administered enforcement, named-release verification and later Hugo work. The presence of a schema or test fixture is not evidence that one of those gates passed.
diff --git a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html
index 54afbde2..f0027ad6 100644
--- a/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html
+++ b/system/OpenGuidePlatform.Hugo.Guides/layouts/_partials/openguide/translations/select-preferred-guide-translations.html
@@ -75,7 +75,8 @@
   {{ $translationsList = $translationsList | append $translation }}
 {{ end }}
 
-{{/* Sort by weight then by language name for consistent output */}}
+{{/* Preserve the existing weight sort. Template range above visits string map
+     keys in language-code order; do not introduce a language-name ordering. */}}
 {{ $translationsList = sort $translationsList "Weight" "asc" }}
 
 {{/* Return the flat list of latest translations */}}
diff --git a/system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Toolchain/Install-GuideBuildDependencies.ps1 b/system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Toolchain/Install-GuideBuildDependencies.ps1
index 38449392..0545f84c 100644
--- a/system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Toolchain/Install-GuideBuildDependencies.ps1
+++ b/system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Toolchain/Install-GuideBuildDependencies.ps1
@@ -1,7 +1,11 @@
 function Install-GuideBuildDependencies {
     [CmdletBinding()]
     param([Parameter(Mandatory)][string]$WorkspaceRoot,[switch]$Deployment)
-    Install-Module powershell-yaml -MinimumVersion 0.4.12 -Scope CurrentUser -Force -Repository PSGallery
+    # Fresh runners may have PowerShellGet without its default repository registration.
+    if(-not (Get-PSRepository -Name PSGallery -ErrorAction SilentlyContinue)){
+        Register-PSRepository -Default -ErrorAction Stop
+    }
+    Install-Module powershell-yaml -MinimumVersion 0.4.12 -Scope CurrentUser -Force -Repository PSGallery -ErrorAction Stop
     if(Test-Path (Join-Path $WorkspaceRoot '.github/GitVersion.yml')){
         Install-GuideGitVersion -WorkspaceRoot $WorkspaceRoot
     }
diff --git a/tests/Core/BuildDependencies.Tests.ps1 b/tests/Core/BuildDependencies.Tests.ps1
new file mode 100644
index 00000000..85427f48
--- /dev/null
+++ b/tests/Core/BuildDependencies.Tests.ps1
@@ -0,0 +1,43 @@
+BeforeAll {
+    $root=Split-Path (Split-Path $PSScriptRoot -Parent) -Parent
+    . "$root/system/OpenGuidePlatform.PowerShell.GuideSiteBuild/Toolchain/Install-GuideBuildDependencies.ps1"
+    # Avoid PowerShellGet's dynamic parameter discovery (and real user-profile
+    # changes) while testing the installer's repository orchestration.
+    function Register-PSRepository {
+        [CmdletBinding()]
+        param([switch]$Default)
+        throw 'Repository registration must be mocked in this test'
+    }
+}
+Describe 'Guide build dependency repository setup' {
+    BeforeEach {
+        Mock Get-PSRepository { [pscustomobject]@{Name='PSGallery'} }
+        Mock Register-PSRepository {}
+        Mock Install-Module {}
+    }
+    It 'preserves an existing repository registration' {
+        Install-GuideBuildDependencies -WorkspaceRoot $TestDrive
+        Should -Invoke Register-PSRepository -Times 0 -Exactly
+        Should -Invoke Install-Module -Times 1 -Exactly -ParameterFilter {
+            $Name -eq 'powershell-yaml' -and $Repository -eq 'PSGallery' -and $MinimumVersion -eq '0.4.12'
+        }
+    }
+    It 'registers the default repository before installing on a fresh runner' {
+        Mock Get-PSRepository { $null }
+        Mock Install-Module {
+            Should -Invoke Register-PSRepository -Times 1 -Exactly -ParameterFilter { $Default }
+        }
+        Install-GuideBuildDependencies -WorkspaceRoot $TestDrive
+        Should -Invoke Install-Module -Times 1 -Exactly
+    }
+    It 'stops before installation when registration fails' {
+        Mock Get-PSRepository { $null }
+        Mock Register-PSRepository { throw 'Repository registration failed' }
+        { Install-GuideBuildDependencies -WorkspaceRoot $TestDrive } | Should -Throw '*Repository registration failed*'
+        Should -Invoke Install-Module -Times 0 -Exactly
+    }
+    It 'propagates a module installation failure' {
+        Mock Install-Module { Write-Error 'Module installation failed' }
+        { Install-GuideBuildDependencies -WorkspaceRoot $TestDrive } | Should -Throw '*Module installation failed*'
+    }
+}
diff --git a/tests/Core/HugoCatalogue.Tests.ps1 b/tests/Core/HugoCatalogue.Tests.ps1
index 6edcfaa1..b6e416fa 100644
--- a/tests/Core/HugoCatalogue.Tests.ps1
+++ b/tests/Core/HugoCatalogue.Tests.ps1
@@ -154,6 +154,9 @@ Describe 'Hugo capability catalogue' {
 }
 
 Describe 'Existing catalogue contracts' {
+    It 'preserves language-code ordering when preferred translations share a weight' {
+        @($preferred|Where-Object Weight -EQ 1|ForEach-Object Language) | Should -Be @('de','en','en-us')
+    }
     It 'discovers any number of guides and retains dated editions' {
         @($catalogue).Count | Should -Be 3
         $guide=$catalogue|Where-Object Section -EQ kanban