@analitikisler/ai-tag-debugger 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.22.0 (2026-11-04)
+
+- Runs can report findings 0.21.0 did not on the same site (`container_duplicate`, `container_environment`, `datalayer_split`, `container_send_to_only`). A baseline written with 0.21.0 can then list new entries; `--update-baseline` rewrites it.
+- New **Google containers** card in the Inventory section and a table in `report.md`: every GTM container and Google tag the pages loaded, with how it got there (a script tag in the HTML, the inline snippet, another script such as a consent platform, a Custom HTML tag or a Google tag in another container, a Zone or template, a `gtag('config')` command, an event's `send_to`, or a destination of the Google tag), the dataLayer it reads, whether it was served by Google or from the site's own domain, and the GTM environment when one is named. The source is read from the page as each script is added, not guessed from network requests. `capture.json` keeps them under `containerLoads`.
+- MCP: the new `get_containers` tool lists the Google containers an open audit's pages loaded so far, with their sources. Step results and `get_step` list the containers each step loaded, `finish_audit` and `run_audit` end with them, the JSON timeline carries them per step, and `get_report` returns them with `part: "containers"`.
+- Pushes to a dataLayer of another name that a container reads (`l=myDataLayer`) are recorded, marked with that name.
+- New checks: `container_duplicate` (warning) for a container loaded more than once into one page, `container_environment` (warning) for a GTM environment loaded instead of Live, `datalayer_split` (info) for containers on one page reading different dataLayers, and `container_send_to_only` (info) for a destination only an event's `send_to` loaded.
+- Development: the guide for coding agents is `AGENTS.md`, the name agents of any vendor read, instead of `CLAUDE.md`, and CONTRIBUTING.md points to it.
+- Development: ESLint's `minimatch` is held at 11 through `overrides` in package.json, for the globparts denial-of-service advisory (GHSA-g3hv-75wg-m249) that no 3.x or 10.x release fixes; ESLint itself still ships an older one. The tool as installed from npm was never affected: `minimatch` is only a development dependency. `npm audit` reports none.
+
 ## 0.21.0 (2026-11-03)
 
 - Runs can report findings 0.20.1 did not on the same site (hits with `ad_user_data` or `ad_personalization` granted before consent or after a reject, `gclid_not_stored`, `client_id_changed`, `consent_default_not_applied`, `page_blocked`, `page_crashed`, and tags sent with cookies when the visitor made no choice), and no longer reports `consent_default_missing` where a consent platform sets the default inside GTM. A baseline written with 0.20.1 can then list stale or new entries; `--update-baseline` rewrites it.

package/README.md

@@ -309,6 +309,26 @@ When the plan is not the site's first, the header compares it with the version s
 
 Every report also has a **tag inventory**: each vendor the site sent requests to, marked first party when its requests went to the site's own domain, third party when they went to the vendor, or both. It shows how many pages the vendor was seen on and the cookies tied to it. Cookies that no vendor owns are listed apart, as first or third party. Only cookie names are recorded, never their values, with two exceptions that are derived rather than copied: the GA4 client id that `_ga` holds (GA4 hits carry it anyway), and whether `_gcl_aw` and `_fbc` hold the click ids the landing page was opened with. Each step also notes which cookies it added, changed or removed, by name, in its **Cookies** tab under **Journeys**. It is the **Inventory** section of `report.html` and a table in `report.md`.
 
+### Google containers
+
+Under the inventory, **Google containers** lists every GTM container (`gtm.js`) and Google tag (`gtag/js`) the pages loaded, and how each one got there. The browser notes every container script as it is added and, when a script added it, which scripts were running at that moment, so the source is read from the page itself rather than guessed from network requests:
+
+| Source | Meaning |
+|---|---|
+| A script tag in the page's HTML | The `gtag.js` snippet, or `gtm.js` referenced directly |
+| Inline code in the page | The GTM snippet, or a hand-written loader |
+| Another script on the page | A consent platform, the site's bundle or another tag manager; its address is given |
+| A Custom HTML tag in GTM-… | A Custom HTML tag in that container inserted it |
+| A Google tag in GTM-… | A Google tag or template in that container, through GTM's `load_google_tags` |
+| GTM-… itself | One GTM container loaded another: a Zone or a tag template |
+| A `gtag('config')` command | The Google tag loaded the destination because the page configured it |
+| An event's `send_to` with no config | The Google tag loaded the destination only because an event was sent to it |
+| A destination of the Google tag | The Google tag loaded it with no command in the page, such as a linked destination |
+
+Each row also gives the dataLayer the container reads (`l=`), whether it came from Google or from the site's own domain (the Google tag gateway or a server container), the GTM environment when the snippet names one, and the pages it loaded on. A container reading a dataLayer of another name has its pushes recorded too, marked with that name. `report.md` has the same table. Over MCP, step results and `get_step` list the containers each step loaded, `get_containers` lists them all while the audit is open, `finish_audit` and `run_audit` end with them, `get_report` returns them with `part: "containers"` and the JSON timeline carries them per step. `capture.json` keeps the loads under `containerLoads`. The environment token (`gtm_auth`) and the page's query string are never kept.
+
+Four checks read it: `container_duplicate` (warning) for a container loaded more than once into one page, `container_environment` (warning) for a GTM environment (`gtm_preview`, `gtm_auth`) loaded instead of Live, `datalayer_split` (info) for containers on one page reading different dataLayers, and `container_send_to_only` (info) for a destination that only an event's `send_to` loaded, with no `gtag('config')` for it.
+
 ### Folder layout and plan IDs
 
 Plans and runs are kept in `aitd/` in the folder you run the tool from:
@@ -604,12 +624,12 @@ Output:
   - **Journeys**: one journey and viewport at a time. The steps on the left, named after the pages ("Open Home", "Add to cart") and grouped by page, with the hits each step produced; the selected step on the right with **Hits**, **Data Layer** and **Requests** tabs. Each hit shows its event, key parameters and consent state, and opens into the decoded parameters, item cards and the raw request. A batched GA4 request shows each of its events. It opens on the first step with a problem.
   - **Consent**: one line per platform with what it received before a choice, after accept and after reject, the Consent Mode default and updates with their timing, and the [consent scenarios](#consent-scenarios) table.
   - **Coverage**: whether each planned event was sent on each journey, with the parameters it still needs, conversion integrity, and, with `--against`, the [Plan vs. site](#plan-vs-site) buckets.
-  - **Inventory**: the [tag inventory](#tag-inventory), one line per platform, opening into its hosts, pages and cookies.
+  - **Inventory**: the [tag inventory](#tag-inventory), one line per platform, opening into its hosts, pages and cookies, and the [Google containers](#google-containers) with how each reached the page.
   - **Run**: the facts of the run (site, version, AI provider and model, plan, journeys, viewports, platforms, timing, files) and, when the site has earlier runs, the **Trend**.
 
   Every card starts collapsed except the Summary; each section has Expand all and Collapse all. The page carries one small script, allowed by its hash in the page's Content Security Policy, for the rail, the filters, the tabs and the deep links; without JavaScript the sections stack into one document, which is also the print layout. Keyboard: `[` folds the rail, `1`–`7` jump to a section. The logos are embedded, so nothing is loaded from the internet. `--no-branding` leaves out the Analitik İşler logo and credit line.
 - `timeline.csv`: the same timeline as one row per hit, dataLayer push and network call, ready for Excel or Google Sheets.
-- `report.md`: the report in Markdown for a pull request comment, a Slack message or a mail, around 100 lines and under 8 KB for a four-journey run. Its title is the verdict (`# shop.example: purchase tracking is broken on mobile`), then one meta line, the status with the data quality score, and the counts. Then, in this order: **Changed since last run** and **Trend** (when the site has earlier runs), **Plan vs. site** (with `--against`), **Priorities** (the to-do list per owner: Developer, Tag Manager, Marketing), **Findings** (up to five full blocks with Where, Impact, Cause, Evidence, Also fine on, Owner, Fix, How to verify and a link into `report.html`; the rest one line each under *Also*), **Consent** (the Consent Mode timing sentence and the scenario table with a reason in every cell), **What passed**, **Journeys** (one row per run, then only the steps that carry a problem), **Not checked** (what the run could not judge, with the config key that enables it) and the **Tag inventory**. The per-hit timeline is not in the file; `timeline.csv` has it.
+- `report.md`: the report in Markdown for a pull request comment, a Slack message or a mail, around 100 lines and under 8 KB for a four-journey run. Its title is the verdict (`# shop.example: purchase tracking is broken on mobile`), then one meta line, the status with the data quality score, and the counts. Then, in this order: **Changed since last run** and **Trend** (when the site has earlier runs), **Plan vs. site** (with `--against`), **Priorities** (the to-do list per owner: Developer, Tag Manager, Marketing), **Findings** (up to five full blocks with Where, Impact, Cause, Evidence, Also fine on, Owner, Fix, How to verify and a link into `report.html`; the rest one line each under *Also*), **Consent** (the Consent Mode timing sentence and the scenario table with a reason in every cell), **What passed**, **Journeys** (one row per run, then only the steps that carry a problem), **Not checked** (what the run could not judge, with the config key that enables it), the **Tag inventory** and **Google containers**. The per-hit timeline is not in the file; `timeline.csv` has it.
 - `capture.json`: everything captured, for your own analysis, including the tool `version`, the `ai` provider and the computed `metrics` (verdict, score, plan coverage, funnel, platform parity, consent compliance, conversion integrity, timing, priorities).
 - `plan-check.json`: with `--against`, one entry per planned event with its bucket.
 - `junit.xml`: the findings as JUnit test results, one suite per journey and viewport, for CI systems to show as test failures (see above).
@@ -637,7 +657,8 @@ Tools the server offers:
 | `get_step` | Shows what an earlier `step` captured again, as `browser_action` showed it, including a page_view that came late and was added to it. |
 | `finish_audit` | Checks everything against your measurement plan (JSON), a saved one given as `against` (`latest`, `first`, a plan ID, or on a local server a path), or the ready-made journey's events, optionally only the `events` you name, and writes the full HTML report with the timeline. The site comes from the audit. The result ends with a compact JSON timeline, one entry per step: the hits with their consent, consent commands, other tracking calls, the Google tag's consent when it changed, and the cookies and ids that changed. |
 | `consent_matrix` | Opens a site's start page like an ad click once per consent choice (no choice and on to the next page, accept all, reject all, analytics only), each in a fresh browser, and returns which tags sent after each choice and the [consent matrix](#consent-scenarios). `campaign` takes the campaign parameters to check (as in `start_audit`), `concurrency` how many choices run at once (default 2, at most 4). About half a minute. |
-| `get_report` | Reads a report this server wrote, by the name `finish_audit` or `run_audit` gave: `part` `markdown` (default, `report.md`), `summary` (`summary.json`) or `timeline` (the JSON timeline of every journey). Only this server's own reports, over HTTP too. |
+| `get_containers` | Lists every GTM container and Google tag the open audit's pages loaded so far, with how each reached the page (see [Google containers](#google-containers)), its dataLayer, host, GTM environment and the step it loaded at, as text and JSON. |
+| `get_report` | Reads a report this server wrote, by the name `finish_audit` or `run_audit` gave: `part` `markdown` (default, `report.md`), `summary` (`summary.json`), `timeline` (the JSON timeline of every journey, with the containers each step loaded) or `containers` (every Google container with how it reached the page, as JSON). Only this server's own reports, over HTTP too. |
 | `run_audit` | Runs a config file end to end. With `against`, it checks the run against a saved plan and, when the config has no journeys, walks the journeys derived from that plan. `concurrency` runs that many journeys at once, each in its own browser (default 1), and `baseline` names a file of accepted findings written with `--update-baseline` (default: the config's `baseline`; see [Accept known findings](#accept-known-findings)). Local only for file paths. |
 
 `against` takes the same values as the CLI's `--against`. Over HTTP it takes only `latest`, `first` or a plan ID, never a path. Plans are the ones saved by `aitd plan --site <url>` or by `make_plan`. Ask for a plan when you want to know what to track, and for an audit when you want to know what the site sends.

package/README.tr.md

@@ -309,6 +309,26 @@ Kontrol edilen plan sitenin ilk planı değilse, rapor başlığı onu bir önce
 
 Her raporda ayrıca bir **etiket envanteri** bulunur: sitenin istek gönderdiği her sağlayıcı; istekleri sitenin kendi alan adına gittiyse birinci taraf, sağlayıcıya gittiyse üçüncü taraf, ikisine de gittiyse ikisi olarak işaretlenir. Sağlayıcının görüldüğü sayfa sayısını ve ona bağlı çerezleri gösterir. Hiçbir sağlayıcıya ait olmayan çerezler ayrıca birinci ya da üçüncü taraf olarak listelenir. Yalnızca çerez adları kaydedilir, değerleri asla; kopyalanmayıp türetilen iki istisna dışında: `_ga`'nın tuttuğu GA4 istemci kimliği (GA4 istekleri onu zaten taşır) ve `_gcl_aw` ile `_fbc`'nin açılış sayfasının açıldığı tıklama kimliklerini tutup tutmadığı. Her adım ayrıca eklediği, değiştirdiği ya da sildiği çerezleri adlarıyla, **Yolculuklar** altındaki **Çerezler** sekmesinde not eder. Envanter `report.html` içindeki **Envanter** bölümünde, `report.md` içinde ise bir tablo olarak yer alır.
 
+### Google container'ları
+
+Envanterin altında **Google container'ları**, sayfaların yüklediği her GTM container'ını (`gtm.js`) ve Google etiketini (`gtag/js`) ve her birinin sayfaya nasıl geldiğini listeler. Tarayıcı her container betiğini eklendiği anda not eder ve onu bir betik eklediyse o anda hangi betiklerin çalıştığını kaydeder; böylece kaynak ağ isteklerinden tahmin edilmez, sayfanın kendisinden okunur:
+
+| Kaynak | Anlamı |
+|---|---|
+| Sayfanın HTML'indeki bir script etiketi | `gtag.js` snippet'i ya da doğrudan eklenmiş `gtm.js` |
+| Sayfadaki satır içi kod | GTM snippet'i ya da elle yazılmış bir yükleyici |
+| Sayfadaki başka bir betik | Bir onay platformu, sitenin paketi ya da başka bir etiket yöneticisi; adresi verilir |
+| GTM-… içindeki bir Özel HTML etiketi | O container'daki bir Özel HTML etiketi ekledi |
+| GTM-… içindeki bir Google etiketi | O container'daki bir Google etiketi ya da şablonu, GTM'in `load_google_tags` API'siyle |
+| GTM-… kendisi | Bir GTM container'ı başka birini yükledi: bir Zone ya da etiket şablonu |
+| Bir `gtag('config')` komutu | Sayfa hedefi yapılandırdığı için Google etiketi onu yükledi |
+| config olmadan bir olayın `send_to` değeri | Google etiketi hedefi yalnızca ona bir olay gönderildiği için yükledi |
+| Google etiketinin bir hedefi | Google etiketi onu sayfada bir komut olmadan yükledi, örneğin bağlı bir hedef |
+
+Her satır ayrıca container'ın okuduğu dataLayer'ı (`l=`), Google'dan mı yoksa sitenin kendi alan adından mı (Google etiket ağ geçidi ya da bir sunucu container'ı) geldiğini, snippet bir GTM ortamı adlandırıyorsa onu ve yüklendiği sayfaları verir. Başka adlı bir dataLayer okuyan container'ın push'ları da o adla işaretlenerek kaydedilir. `report.md` aynı tabloyu içerir. MCP'de adım sonuçları ve `get_step` her adımın yüklediği container'ları listeler, `get_containers` denetim açıkken hepsini listeler, `finish_audit` ve `run_audit` sonuçları onlarla biter, `get_report` onları `part: "containers"` ile döndürür ve JSON zaman akışı onları adım adım taşır. `capture.json` yüklemeleri `containerLoads` altında saklar. Ortam belirteci (`gtm_auth`) ve sayfanın sorgu dizesi asla saklanmaz.
+
+Dört kontrol bunu okur: aynı sayfaya birden fazla kez yüklenen bir container için `container_duplicate` (uyarı), Live yerine yüklenen bir GTM ortamı (`gtm_preview`, `gtm_auth`) için `container_environment` (uyarı), aynı sayfada farklı dataLayer'ları okuyan container'lar için `datalayer_split` (bilgi) ve kendisi için `gtag('config')` olmadan yalnızca bir olayın `send_to` değeriyle yüklenen bir hedef için `container_send_to_only` (bilgi).
+
 ### Klasör yapısı ve plan kimlikleri
 
 Planlar ve çalıştırmalar, aracı çalıştırdığınız klasördeki `aitd/` içinde tutulur:
@@ -604,7 +624,7 @@ jq -r '.verdict.status + " " + (.score | tostring)' aitd/example.com/runs/*/summ
   - **Yolculuklar**: her seferinde bir yolculuk ve ekran. Solda sayfalara göre adlandırılmış ("Ana sayfayı aç", "Sepete ekle") ve sayfaya göre gruplanmış adımlar, her adımın ürettiği isteklerle; sağda seçili adım, **İstekler**, **Data Layer** ve **Ağ** sekmeleriyle. Her istek event'ini, temel parametrelerini ve çerez onayı durumunu gösterir; çözülmüş parametrelere, ürün kartlarına ve ham isteğe açılır. Toplu bir GA4 isteği içindeki her event'i gösterir. Sorunlu ilk adımda açılır.
   - **Onay**: her platform için bir satır: seçimden önce, kabulden sonra ve retten sonra ne aldığı; Consent Mode varsayılanı ve güncellemeleri zamanlamalarıyla; ve [onay senaryoları](#onay-senaryoları) tablosu.
   - **Kapsam**: planlanan her event'in her yolculukta gönderilip gönderilmediği, hâlâ ihtiyaç duyduğu parametrelerle; dönüşüm bütünlüğü; ve `--against` ile [Plan ve site](#plan-ve-site) kovaları.
-  - **Envanter**: [etiket envanteri](#etiket-envanteri), platform başına bir satır; sunucularına, sayfalarına ve çerezlerine açılır.
+  - **Envanter**: [etiket envanteri](#etiket-envanteri), platform başına bir satır; sunucularına, sayfalarına ve çerezlerine açılır; ayrıca her birinin sayfaya nasıl geldiğiyle [Google container'ları](#google-containerları).
   - **Çalıştırma**: çalıştırmanın künyesi (site, sürüm, yapay zekâ sağlayıcısı ve modeli, plan, yolculuklar, ekranlar, platformlar, süreler, dosyalar) ve sitenin önceki çalıştırmaları varsa **Eğilim**.
 
   Özet dışında her kart kapalı başlar; her bölümde Tümünü aç ve Tümünü kapat düğmeleri vardır. Sayfada şerit, filtreler, sekmeler ve derin bağlantılar için, sayfanın Content Security Policy'sinde özetiyle izin verilmiş küçük bir betik bulunur; JavaScript olmadan bölümler tek bir belge olarak alt alta dizilir, yazdırma düzeni de budur. Klavye: `[` şeridi katlar, `1`–`7` bir bölüme atlar. Logolar gömülüdür, bu yüzden internetten hiçbir şey yüklenmez. `--no-branding`, Analitik İşler logosunu ve kredi satırını çıkarır.
@@ -637,7 +657,8 @@ Sunucunun sunduğu araçlar:
 | `get_step` | Önceki bir adımın (`step`) yakaladıklarını `browser_action`'ın gösterdiği gibi yeniden gösterir; geç gelip o adıma eklenen page_view da dahil. |
 | `finish_audit` | Her şeyi ölçümleme planınıza (JSON) ya da `against` olarak verilen kayıtlı bir plana (`latest`, `first`, bir plan kimliği ya da yerel bir sunucuda bir yol) ya da hazır yolculuğun event'lerine karşı kontrol eder; isterseniz yalnızca adını verdiğiniz `events` için, ve zaman akışıyla birlikte tam HTML raporunu yazar. Site denetimden alınır. Sonuç, adım başına bir kayıt içeren kısa bir JSON zaman akışıyla biter: onay durumlarıyla istekler, onay komutları, diğer takip çağrıları, değiştiğinde Google etiketinin onay durumu, değişen çerezler ve kimlikler. |
 | `consent_matrix` | Bir sitenin başlangıç sayfasını her onay seçimi için (seçim yapmadan sonraki sayfa, tümünü kabul, tümünü reddet, yalnızca analitik) bir reklam tıklaması gibi, her seferinde yeni bir tarayıcıda açar; her seçimden sonra hangi etiketlerin gönderdiğini ve [onay matrisini](#onay-senaryoları) döndürür. `campaign` kontrol edilecek kampanya parametrelerini (`start_audit`'teki gibi), `concurrency` aynı anda kaç seçimin çalışacağını alır (varsayılan 2, en fazla 4). Yaklaşık yarım dakika sürer. |
-| `get_report` | Bu sunucunun yazdığı bir raporu, `finish_audit` ya da `run_audit`'in verdiği adla okur: `part` `markdown` (varsayılan, `report.md`), `summary` (`summary.json`) ya da `timeline` (her yolculuğun JSON zaman akışı). Yalnızca bu sunucunun kendi raporları, HTTP üzerinden de. |
+| `get_containers` | Açık denetimin sayfalarının şimdiye kadar yüklediği her GTM container'ını ve Google etiketini, her birinin sayfaya nasıl geldiğiyle ([Google container'ları](#google-containerları)), dataLayer'ı, sunucusu, GTM ortamı ve yüklendiği adımla birlikte metin ve JSON olarak listeler. |
+| `get_report` | Bu sunucunun yazdığı bir raporu, `finish_audit` ya da `run_audit`'in verdiği adla okur: `part` `markdown` (varsayılan, `report.md`), `summary` (`summary.json`), `timeline` (her yolculuğun JSON zaman akışı; her adımın yüklediği container'larla) ya da `containers` (sayfaya nasıl geldiğiyle her Google container'ı, JSON olarak). Yalnızca bu sunucunun kendi raporları, HTTP üzerinden de. |
 | `run_audit` | Bir ayar dosyasını baştan sona çalıştırır. `against` ile çalıştırmayı kayıtlı bir plana karşı kontrol eder; ayar dosyasında yolculuk yoksa, plandan türetilen yolculukları gezer. `concurrency` o kadar yolculuğu aynı anda, her birini kendi tarayıcısında çalıştırır (varsayılan 1); `baseline`, `--update-baseline` ile yazılmış kabul edilen bulgular dosyasını adlandırır (varsayılan: ayar dosyasındaki `baseline`; bkz. [Bilinen bulguları kabul edin](#bilinen-bulguları-kabul-edin)). Dosya yolları yalnızca yerelde çalışır. |
 
 `against`, CLI'deki `--against` ile aynı değerleri alır. HTTP üzerinden yalnızca `latest`, `first` ya da bir plan kimliği kabul edilir, asla bir yol değil. Planlar, `aitd plan --site <url>` ya da `make_plan` ile kaydedilmiş olanlardır. Neyin takip edileceğini öğrenmek için plan, sitenin ne gönderdiğini öğrenmek için denetim isteyin.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@analitikisler/ai-tag-debugger",
   "mcpName": "io.github.analitikisler/ai-tag-debugger",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "Open-source AI agent that QA-tests your website's analytics, ad and consent tracking (GA4, GTM, Google Ads, Meta, TikTok). Bring your own model (Claude, OpenAI, Gemini) or use it from your chat app over MCP.",
   "type": "module",
   "bin": {
@@ -67,5 +67,8 @@
     "@eslint/js": "^9.39.5",
     "eslint": "^9.39.5",
     "globals": "^17.13.0"
+  },
+  "overrides": {
+    "minimatch": "^11.0.4"
   }
 }

package/src/agent.js

@@ -237,7 +237,7 @@ export const journeyError = (err) => `The journey stopped with an error: ${err?.
 export function failedRun(journey, viewport, err, providers) {
   return {
     journeyId: journey.id, viewport, completed: false, note: journeyError(err), hits: [], steps: [], consentStep: null, rejectStep: null,
-    cookieLog: [], cookieChanges: [], dataLayerLog: [], network: [], providers, skipped: {}, bodyBudgetStep: null, startedAt: Date.now(), pageErrors: [],
+    cookieLog: [], cookieChanges: [], dataLayerLog: [], containerLoads: [], network: [], providers, skipped: {}, bodyBudgetStep: null, startedAt: Date.now(), pageErrors: [],
   };
 }
 
@@ -256,6 +256,7 @@ export function collect(session, journey, viewport) {
     // Hits let through to the real accounts (block_hits false, or a live MCP audit): the reports say so.
     ...(session.opts.blockHits === false ? { live: true } : {}),
     dataLayerLog: session.dataLayerLog,
+    containerLoads: session.containerLoads,
     network: session.network,
     providers: session.providers,
     skipped: session.skipped,

package/src/browser.js

@@ -10,6 +10,7 @@ import { hostScope, isPrivateAddress, navigationError, privateHostChecker } from
 import { startEgressProxy } from "./egress.js";
 import { campaignParamsIn } from "./campaign.js";
 import { detectCmpInPage } from "./cmp.js";
+import { callersOf, containerOf } from "./containers.js";
 
 // Consent banners of the common consent platforms (CMPs), by their container. A cover that matches
 // one of these always blocks the journey, and a reject click is checked against them afterwards.
@@ -34,7 +35,7 @@ export const CMP_BANNER_SELECTORS = `#onetrust-banner-sdk, #onetrust-consent-sdk
 // Efilli draws its banner inside the open shadow root of <efilli-layout-dynamic>, so the checks below also look inside open shadow roots.
 
 // Caps on what one audit records, so a looping page can't grow memory without limit.
-const LOG_LIMITS = { hits: 5000, dataLayerLog: 5000, network: 10000 };
+const LOG_LIMITS = { hits: 5000, dataLayerLog: 5000, network: 10000, containerLoads: 500 };
 
 // Secrets the browser process has no use for. It gets the rest of the environment
 // (PATH, HOME, DISPLAY...) so Chromium still starts normally.
@@ -60,8 +61,57 @@ const hostOf = (url) => {
   }
 };
 
+// Runs inside INIT_SCRIPT: records each Google container script (gtm.js, gtag/js) the page adds, through
+// window.__atdLoad, with how it got there. One set by a script carries that moment's call stack, whose script
+// addresses tell who asked for it (see src/containers.js); one the HTML parser inserted never passes through
+// the setters, so a MutationObserver reports it. A container reading another dataLayer gets it watched.
+const CONTAINER_HOOK = `
+  const docUrl = location.href;
+  const doc = Math.random().toString(36).slice(2, 10);
+  const isContainer = (src) => /\\/(gtm\\.js|gtag\\/js)\\?/.test(String(src)) && /[?&]id=/.test(String(src));
+  const seen = new WeakSet();
+  const report = (el, src, how) => {
+    try {
+      const abs = new URL(String(src), document.baseURI).href;
+      if (!isContainer(abs) || !window.__atdLoad) return;
+      const layer = new URL(abs).searchParams.get("l") || "dataLayer";
+      watch(layer);
+      let frames = [];
+      if (how === "script") {
+        const limit = Error.stackTraceLimit;
+        Error.stackTraceLimit = 50;
+        const stack = String(new Error().stack || "");
+        Error.stackTraceLimit = limit;
+        // The first two frames are report() and the setter, both from this script; injected inline code
+        // (a Custom HTML tag) has no address and shows as <anonymous>.
+        frames = stack.split("\\n").filter((line) => /^\\s+at /.test(line)).slice(2)
+          .map((line) => (line.match(/(https?:\\/\\/[^\\s()]+?):\\d+:\\d+/) || [])[1] || (/<anonymous>/.test(line) ? "inline" : null))
+          .filter(Boolean);
+      }
+      window.__atdLoad({ src: abs, how, frames, documentUrl: docUrl, page: location.href, doc });
+    } catch {}
+  };
+  try {
+    const desc = Object.getOwnPropertyDescriptor(HTMLScriptElement.prototype, "src");
+    Object.defineProperty(HTMLScriptElement.prototype, "src", {
+      ...desc,
+      set(v) { if (!seen.has(this)) { seen.add(this); report(this, v, "script"); } return desc.set.call(this, v); },
+    });
+    const setAttribute = Element.prototype.setAttribute;
+    Element.prototype.setAttribute = function (name, v) {
+      if (this instanceof HTMLScriptElement && String(name).toLowerCase() === "src" && !seen.has(this)) { seen.add(this); report(this, v, "script"); }
+      return setAttribute.call(this, name, v);
+    };
+    new MutationObserver((list) => {
+      for (const m of list) for (const n of m.addedNodes) {
+        if (n instanceof HTMLScriptElement && n.src && !seen.has(n)) { seen.add(n); report(n, n.src, "parser"); }
+      }
+    }).observe(document, { childList: true, subtree: true });
+  } catch {}
+`;
+
 const INIT_SCRIPT = `(() => {
-  const record = (entry) => {
+  const record = (entry, layer = "dataLayer") => {
     let value = entry;
     try {
       // gtag() pushes an arguments object; store it as a plain array.
@@ -95,22 +145,32 @@ const INIT_SCRIPT = `(() => {
       };
       value = JSON.parse(JSON.stringify(copy(value, [])));
     } catch { value = String(entry); }
-    if (window.__atdRecord) window.__atdRecord({ url: location.href, value });
+    if (window.__atdRecord) window.__atdRecord({ url: location.href, value, ...(layer === "dataLayer" ? {} : { layer }) });
   };
-  const wrap = (dl) => {
-    if (!dl || dl.__atdWrapped) return dl;
-    dl.forEach(record);
+  const wrap = (dl, layer) => {
+    if (!dl || dl.__atdWrapped || typeof dl.push !== "function") return dl;
+    dl.forEach((e) => record(e, layer));
     const push = dl.push.bind(dl);
-    dl.push = (...items) => { items.forEach(record); return push(...items); };
+    dl.push = (...items) => { items.forEach((e) => record(e, layer)); return push(...items); };
     dl.__atdWrapped = true;
     return dl;
   };
-  let current = wrap(window.dataLayer || []);
-  Object.defineProperty(window, "dataLayer", {
-    configurable: true,
-    get: () => current,
-    set: (v) => { current = wrap(v); },
-  });
+  const watched = new Set();
+  // A container can read a dataLayer of another name (gtm.js?l=myDataLayer); it is watched once one is seen.
+  const watch = (layer) => {
+    if (watched.has(layer) || !/^[A-Za-z_$][\\w$]*$/.test(layer)) return;
+    watched.add(layer);
+    try {
+      let current = layer === "dataLayer" ? wrap(window[layer] || [], layer) : wrap(window[layer], layer);
+      Object.defineProperty(window, layer, {
+        configurable: true,
+        get: () => current,
+        set: (v) => { current = wrap(v, layer); },
+      });
+    } catch { /* a property the page made unconfigurable */ }
+  };
+  watch("dataLayer");
+${CONTAINER_HOOK}
 })();`;
 
 // Labels the interactive elements of one frame with numeric refs, starting at
@@ -486,6 +546,7 @@ export class AuditSession {
     this.refusedScripts = new Map(); // step -> how many of the page's scripts were refused for coming back as HTML
     this.errors = [];
     this.dataLayerLog = [];
+    this.containerLoads = []; // each Google container script the page added, with how (see src/containers.js)
     this.network = [];
     this.providers = resolveProviders(this.opts.providers);
     this.landing = null; // the first page: { step, requested, chain, final }
@@ -530,6 +591,7 @@ export class AuditSession {
       this.lastTrackingAt = Date.now();
       this.record("dataLayerLog", { ...this.redactEntry(entry), step: this.currentStep, t: Date.now() });
     });
+    await this.context.exposeBinding("__atdLoad", (_source, entry) => this.recordLoad(entry));
     await this.context.addInitScript(INIT_SCRIPT);
     this.page = await this.context.newPage();
     this.page.on("pageerror", (err) => this.errors.push({ step: this.currentStep, message: err.message }));
@@ -756,6 +818,25 @@ export class AuditSession {
     return { postData: this.opts.keepBodies ? body : redactBody(body).text };
   }
 
+  /**
+   * A container script the page added: its ID, dataLayer and host, whether the HTML parser inserted it or a
+   * script did and, for a script, the callers on the stack. Only addresses without their query are kept, so
+   * the environment token (gtm_auth) and user data in a page's query string never reach the capture.
+   */
+  recordLoad(entry) {
+    const container = containerOf(entry?.src);
+    if (!container) return;
+    this.record("containerLoads", {
+      ...container,
+      how: entry.how === "parser" ? "parser" : "script",
+      ...(entry.how === "parser" ? {} : { callers: callersOf(entry.frames, entry.documentUrl) }),
+      page: pagePath(entry.page),
+      doc: String(entry.doc ?? "").slice(0, 16),
+      step: this.currentStep,
+      t: Date.now(),
+    });
+  }
+
   /** Adds an entry to one of the logs, up to its limit. Returns false once the limit is reached. */
   record(log, entry) {
     if (this[log].length >= LOG_LIMITS[log]) {

package/src/checks.js

@@ -5,6 +5,7 @@ import { messages } from "./i18n.js";
 import { isOwnAddress } from "./redact.js";
 import { campaignParamsIn } from "./campaign.js";
 import { CONSENT_SIGNALS } from "./parsers.js";
+import { duplicateLoads, loadSources, splitLayers } from "./containers.js";
 
 const platformName = (p) => ({ meta: "Meta", tiktok: "TikTok" })[p] ?? p;
 const NON_GOOGLE_AD_PLATFORMS = new Set(["meta", "tiktok"]);
@@ -366,6 +367,22 @@ export function checkRun(plan, run, { lang = "en" } = {}) {
     }
   }
 
+  // Google containers and how each got onto the page (src/containers.js). Runs saved by older versions have none.
+  const ui = messages(lang).ui.containers;
+  const source = (l) => ui.kinds[l.kind](l.by);
+  for (const dup of duplicateLoads(run).filter((x, i, all) => all.findIndex((y) => y.id === x.id) === i)) {
+    findings.push({ ...base, severity: "warning", check: "container_duplicate", step: stepLabel(dup.loads[1].step), detail: d.containerDuplicate(dup.id, dup.loads.map(source), stepLabel(dup.loads[1].step)), evidence: dup.loads.map((l) => `${l.id} ${l.kind}${l.by ? ` ${l.by}` : ""} ${l.page ?? ""}`).join("\n") });
+  }
+  const loads = loadSources(run);
+  for (const l of loads.filter((x, i, all) => x.environment && all.findIndex((y) => y.environment && y.id === x.id) === i)) {
+    findings.push({ ...base, severity: "warning", check: "container_environment", step: stepLabel(l.step), detail: d.containerEnvironment(l.id, l.environment) });
+  }
+  const split = splitLayers(run)[0];
+  if (split) findings.push({ ...base, severity: "info", check: "datalayer_split", step: stepLabel(split.step), detail: d.dataLayerSplit(split.layers.map((x) => `${x.id} → ${x.layer}`), stepLabel(split.step)) });
+  for (const l of loads.filter((x, i, all) => x.kind === "send_to" && !all.some((y) => y.id === x.id && y.kind !== "send_to") && all.findIndex((y) => y.kind === "send_to" && y.id === x.id) === i)) {
+    findings.push({ ...base, severity: "info", check: "container_send_to_only", platform: l.id.startsWith("G-") ? "ga4" : "google_ads", step: stepLabel(l.step), detail: d.sendToOnly(l.id, l.by) });
+  }
+
   // One event ID on two different events: the platform keeps the first and drops the other as its
   // duplicate, so a real event is lost (usually an ID set once per page instead of once per event).
   const byId = new Map();

package/src/containers.js

@@ -0,0 +1,163 @@
+// How each Google container got onto the page: GTM (gtm.js) and Google tag (gtag/js) scripts, with what
+// inserted them. The browser records every container script as it is added (see CONTAINER_HOOK in browser.js):
+// parser-inserted from the HTML, or set by a script, with the scripts on the call stack at that moment. This
+// module turns that into a load source: the snippet, a script tag in the HTML, another script on the page,
+// a tag or Zone in another container, or a gtag config or send_to command the Google tag acted on.
+
+// Container and destination IDs gtm.js and gtag/js are loaded with.
+const CONTAINER_ID = /^(GTM|G|GT|AW|DC|MC|HA)-[A-Z0-9]+$/;
+
+/**
+ * The container a script URL loads, or null: its ID, gtm or gtag, the dataLayer it reads (`l`), the host it
+ * came from (Google's, or the site's own through the Google tag gateway or a server container) and the GTM
+ * environment when one is named (`gtm_preview`). gtm_auth, the environment's token, is never kept.
+ */
+export function containerOf(url) {
+  let u;
+  try { u = new URL(url); } catch { return null; }
+  if (!/^https?:$/.test(u.protocol)) return null;
+  const id = (u.searchParams.get("id") ?? "").toUpperCase();
+  if (!CONTAINER_ID.test(id)) return null;
+  const script = /\/gtm\.js$/.test(u.pathname) ? "gtm" : /\/gtag\/js$/.test(u.pathname) ? "gtag" : null;
+  if (!script) return null;
+  const environment = u.searchParams.get("gtm_preview") || (u.searchParams.has("gtm_auth") ? "unnamed" : null);
+  return {
+    id,
+    script,
+    layer: u.searchParams.get("l") || "dataLayer",
+    host: u.hostname,
+    served: /(^|\.)googletagmanager\.com$/.test(u.hostname) ? "google" : "site",
+    ...(environment ? { environment } : {}),
+  };
+}
+
+/** origin + path, so a caller's query string (which may carry user data) is never kept. */
+export function scriptPath(url) {
+  try {
+    const u = new URL(url);
+    return /^https?:$/.test(u.protocol) ? u.origin + u.pathname : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * The call stack the browser captured, as callers from the innermost out: { inline: true } for script in the
+ * page itself (the page's address, or "inline" for code injected without one) (the snippet, or a Custom HTML tag GTM injected), { container: id } for a container script and
+ * { script: url } for any other script. Repeats in a row are folded.
+ */
+export function callersOf(frames, documentUrl) {
+  const doc = String(documentUrl ?? "").split("#")[0];
+  const out = [];
+  for (const f of frames ?? []) {
+    const url = String(f).split("#")[0];
+    const c = containerOf(url);
+    const caller = url === doc || url === "inline" ? { inline: true } : c ? { container: c.id } : scriptPath(url) ? { script: scriptPath(url) } : null;
+    if (!caller) continue;
+    const last = out.at(-1);
+    if (last && JSON.stringify(last) === JSON.stringify(caller)) continue;
+    out.push(caller);
+  }
+  return out;
+}
+
+const pathOf = (href) => scriptPath(href);
+
+/** Whether a gtag command in the dataLayer names this ID: ["config", id] or ["event", name, { send_to }]. */
+function commandFor(load, pushes) {
+  const earlier = pushes.filter((e) => Array.isArray(e.value) && (e.t ?? 0) <= (load.t ?? Infinity) && (!load.page || pathOf(e.url) === load.page));
+  if (earlier.some((e) => e.value[0] === "config" && String(e.value[1]).toUpperCase() === load.id)) return "config";
+  const sendsTo = (e) => {
+    const to = e.value[0] === "event" ? e.value[2]?.send_to : undefined;
+    const list = Array.isArray(to) ? to : String(to ?? "").split(",");
+    return list.some((s) => String(s).trim().toUpperCase().split("/")[0] === load.id);
+  };
+  return earlier.some(sendsTo) ? "send_to" : null;
+}
+
+/**
+ * Where one recorded load came from, as { kind, by? }:
+ * - html: a script tag in the page's HTML (the gtag.js snippet, or gtm.js referenced directly)
+ * - inline: code in the page itself (the GTM snippet, or a hand-written loader)
+ * - script: another script on the page; by is its address (a consent platform, the site's bundle)
+ * - custom_html: a Custom HTML tag in the GTM container `by`
+ * - google_tag: a Google tag or template in the GTM container `by`, through GTM's load_google_tags
+ * - nested: GTM container `by` loaded another GTM container itself, as a Zone or a tag template does
+ * - config / send_to: a gtag('config') or an event's send_to naming the ID, acted on by `by`
+ * - destination: the Google tag `by` loaded it as one of its destinations, with no command in the page
+ */
+export function sourceOf(load, pushes = []) {
+  if (load.how === "parser") return { kind: "html" };
+  const callers = load.callers ?? [];
+  const at = callers.findIndex((c) => c.container && c.container !== load.id);
+  if (at >= 0) {
+    const by = callers[at].container;
+    const command = commandFor(load, pushes);
+    if (command) return { kind: command, by };
+    if (by.startsWith("GTM-")) {
+      // Code in the page between the call and the container is a Custom HTML tag the container injected.
+      if (callers.slice(0, at).some((c) => c.inline)) return { kind: "custom_html", by };
+      return { kind: load.id.startsWith("GTM-") ? "nested" : "google_tag", by };
+    }
+    return { kind: "destination", by };
+  }
+  const other = callers.find((c) => c.script);
+  if (other) return { kind: "script", by: other.script };
+  return { kind: "inline" };
+}
+
+/** A run's container loads with their sources, in the order they happened. Runs saved by older versions have none. */
+export function loadSources(run) {
+  const pushes = run.dataLayerLog ?? [];
+  return (run.containerLoads ?? []).map((load) => ({ ...load, ...sourceOf(load, pushes) }));
+}
+
+/**
+ * One row per container and source across runs, in the order first seen: { id, script, layer, served, host,
+ * environment?, kind, by?, pages, journeys }.
+ */
+export function containerRows(runs) {
+  const rows = new Map();
+  for (const run of runs) {
+    for (const l of loadSources(run)) {
+      const k = [l.id, l.kind, l.by ?? "", l.host, l.layer, l.environment ?? ""].join("|");
+      const row = rows.get(k) ?? {
+        id: l.id, script: l.script, layer: l.layer, served: l.served, host: l.host,
+        ...(l.environment ? { environment: l.environment } : {}), kind: l.kind, ...(l.by ? { by: l.by } : {}),
+        pages: new Set(), journeys: new Set(),
+      };
+      if (l.page) row.pages.add(l.page);
+      row.journeys.add(`${run.journeyId} (${run.viewport})`);
+      rows.set(k, row);
+    }
+  }
+  return [...rows.values()].map((r) => ({ ...r, pages: [...r.pages].sort(), journeys: [...r.journeys] }));
+}
+
+/** The containers loaded more than once into one page, as [{ id, loads }] with the loads in order. */
+export function duplicateLoads(run) {
+  const byDoc = new Map();
+  for (const l of loadSources(run)) {
+    const k = `${l.doc ?? l.page}|${l.id}`;
+    byDoc.set(k, [...(byDoc.get(k) ?? []), l]);
+  }
+  return [...byDoc.values()].filter((list) => list.length > 1).map((loads) => ({ id: loads[0].id, loads }));
+}
+
+/** Pages where containers read different dataLayers, as [{ page, step, layers: [{ id, layer }] }]. */
+export function splitLayers(run) {
+  const byDoc = new Map();
+  for (const l of loadSources(run)) {
+    // A destination a Google tag loaded reads that tag's dataLayer, whatever its own URL says.
+    if (["config", "send_to", "destination"].includes(l.kind)) continue;
+    const k = l.doc ?? l.page;
+    byDoc.set(k, [...(byDoc.get(k) ?? []), l]);
+  }
+  const out = [];
+  for (const loads of byDoc.values()) {
+    if (new Set(loads.map((l) => l.layer)).size < 2) continue;
+    const seen = new Map(loads.map((l) => [l.id, { id: l.id, layer: l.layer }]));
+    out.push({ page: loads[0].page, step: loads[0].step, layers: [...seen.values()] });
+  }
+  return out;
+}

package/src/html/scope.js

@@ -3,6 +3,7 @@
 // handling (which runs check which platform, the funnel cells, the inventory's parties and cookies, the skipped
 // vendors, the trend) is the 0.17 renderer's, so the numbers match the Markdown report and the CLI.
 import { buildInventory } from "../inventory.js";
+import { containerRows } from "../containers.js";
 import { providerOf } from "../parsers.js";
 import { siteOf } from "../redact.js";
 import { VERSION, BUCKET_ORDER, coverageLines, pcSort, planChangeItems, routeList } from "../report-shared.js";
@@ -193,12 +194,24 @@ function inventoryLines(ctx) {
   return { lines, otherCookies: inv.otherCookies };
 }
 
+/** The Google containers card: one line per container and the way it reached the page. Null when none was recorded. */
+function containersCard(ctx) {
+  const { m, runs } = ctx;
+  const rows = containerRows(runs);
+  if (!rows.length) return null;
+  const c = m.ui.containers;
+  const items = rows.map((r) => `<li>${code(r.id)}${plain(esc(c.script[r.script]))}<span>${esc(c.kinds[r.kind](r.by))}</span>${plain(`${esc(m.ui.layerCol)} ${code(r.layer)}`)}${plain(esc(r.served === "google" ? c.served.google : `${c.served.site} (${r.host})`))}${r.environment ? badge("warning", c.environment(r.environment)) : ""}<span class="inv-n">${m.html.scope.pages(r.pages.length, bold(r.pages.length))}</span></li>`).join("");
+  const ids = uniq(rows.map((r) => r.id));
+  return `<li><details class="card inv" id="inv-containers"><summary><span class="t">${esc(m.ui.containersTitle)}</span>${plain(n(ids.length))}<span class="inv-m">${esc(ids.slice(0, 3).join(", "))}${ids.length > 3 ? " …" : ""}</span></summary><div class="body"><p class="xs muted">${esc(m.ui.containersIntro)}</p><ul class="inv-list">${items}</ul></div></details></li>`;
+}
+
 function inventorySection(ctx) {
   const { m, runs } = ctx;
   const t = m.html.scope;
   const { lines, otherCookies } = inventoryLines(ctx);
   const skipped = skippedTotals(runs);
-  if (!lines.length && !skipped.length) return sectionBlock("inventory", esc(m.html.shell.sections.inventory), `<p class="muted">${esc(m.ui.noInventory)}</p>`);
+  const containers = containersCard(ctx);
+  if (!lines.length && !skipped.length && !containers) return sectionBlock("inventory", esc(m.html.shell.sections.inventory), `<p class="muted">${esc(m.ui.noInventory)}</p>`);
   const counts = (x) => `<span class="inv-m">${t.requests(x.requests, bold(x.requests))}</span><span class="inv-m">${t.pages(x.pages.size, bold(x.pages.size))}</span><span class="inv-m${x.cookies.length ? "" : " zero"}">${t.cookies(x.cookies.length, bold(x.cookies.length))}</span>`;
   const out = lines.map((x) => {
     const id = `inv-${safeKey(x.p)}`;
@@ -214,6 +227,7 @@ function inventorySection(ctx) {
 <div role="tabpanel" id="${tid("pages")}" data-label="${esc(m.ui.pagesCol)}">${pages ? `<ul class="inv-list">${pages}</ul>` : none}</div>
 <div role="tabpanel" id="${tid("cookies")}" data-label="${esc(m.ui.cookiesCol)}">${x.cookies.length ? `<ul class="inv-list">${x.cookies.map((ck) => `<li>${code(ck)}</li>`).join("")}</ul>` : none}</div></div></div></details></li>`;
   });
+  if (containers) out.unshift(containers);
   const skippedN = skipped.reduce((a, [, k]) => a + k, 0);
   if (skipped.length) {
     out.push(`<li><details class="card inv" id="inv-out-of-scope"><summary><span class="t">${esc(m.ui.outOfScopeStatus)}</span>${plain(t.requests(skippedN, bold(skippedN)))}<span class="inv-m">${esc(skipped.slice(0, 3).map(([v]) => v).join(", "))}${skipped.length > 3 ? " …" : ""}</span></summary><div class="body"><ul class="inv-list">${skipped.map(([v, k]) => `<li><span>${esc(v)}</span>${badge("muted", m.ui.outOfScopeStatus)}<span class="inv-n">${t.requests(k, bold(k))}</span></li>`).join("")}</ul></div></details></li>`);

package/src/i18n.js

@@ -202,6 +202,29 @@ const en = {
     party: { first: "First party", third: "Third party", both: "Both" },
     otherCookies: "Other cookies",
     noInventory: "No vendor requests were recorded.",
+    containersTitle: "Google containers",
+    containersIntro: "How each GTM container and Google tag got onto the page: what inserted its script, the dataLayer it reads and where it was served from.",
+    noContainers: "No GTM container or Google tag script was loaded.",
+    containerCol: "Container",
+    sourceCol: "Loaded by",
+    layerCol: "dataLayer",
+    servedCol: "Served from",
+    containers: {
+      script: { gtm: "GTM container", gtag: "Google tag" },
+      served: { google: "Google", site: "The site's own domain" },
+      environment: (env) => (env === "unnamed" ? "GTM environment" : `GTM environment ${env}`),
+      kinds: {
+        html: () => "A script tag in the page's HTML",
+        inline: () => "Inline code in the page (the snippet)",
+        script: (by) => `Another script on the page: ${by}`,
+        custom_html: (by) => `A Custom HTML tag in ${by}`,
+        google_tag: (by) => `A Google tag in ${by} (load_google_tags)`,
+        nested: (by) => `${by} itself: a Zone or a tag template`,
+        config: (by) => `A gtag('config') command, loaded by ${by}`,
+        send_to: (by) => `An event's send_to with no config, loaded by ${by}`,
+        destination: (by) => `A destination of the Google tag ${by}`,
+      },
+    },
     provider: "Provider",
     checked: "Checked",
     outOfScopeStatus: "Out of scope",
@@ -323,6 +346,10 @@ const en = {
     campaignOk: (names) => `${names.join(", ")} survived the landing page's redirects and reached the hits.`,
     gclidNotStored: () => `The landing address carried a gclid and ad storage was granted, but the _gcl_aw cookie never held it. Google Ads cannot tie a conversion later in the visit, or on a later visit, to the ad click.`,
     clientIdChanged: (from, at) => `The GA4 client id in the _ga cookie changed between "${from}" and "${at}". GA4 counts the visit before and after as two different users.`,
+    containerDuplicate: (id, sources, step) => `${id} was loaded ${sources.length} times into one page at "${step}": ${sources.join("; ")}. Each copy can run the container's tags again, so hits can go out twice; at best one install is dead weight.`,
+    containerEnvironment: (id, env) => `${id} is loaded from a GTM environment (${env === "unnamed" ? "gtm_auth" : `gtm_preview=${env}`}) instead of the Live version, so visitors run whatever was last published to that environment, often a staging or development version.`,
+    dataLayerSplit: (list, step) => `Containers on one page at "${step}" read different dataLayers: ${list.join(", ")}. A push to one is never seen by the containers reading another, so events and consent commands may reach only some of them.`,
+    sendToOnly: (id, by) => `${id} was loaded only because an event named it in send_to; no gtag('config', '${id}') ran. ${by} sends to it with default settings, so whatever a config command would set for it does not apply.`,
     consentDefaultMissing: () => "No Google Consent Mode default command (gtag('consent', 'default', ...)) was found in the dataLayer.",
     consentDefaultLate: () => "The Consent Mode default was set after the first tracking hit was sent.",
     consentDefaultNotApplied: () => "The page pushed a Consent Mode default, but the Google tag never applied it, so its tags ran without one. Tag Assistant shows Consent Mode as not configured.",
@@ -378,6 +405,10 @@ const en = {
     page_crashed: "Visitors who get the same error see a broken page, and the tags on it may not run.",
     gclid_not_stored: "Conversions are not linked to the ad click that brought the visitor, so Google Ads under-reports them and bids on less data.",
     client_id_changed: "One visitor becomes two users in GA4: the visit is split, the journey before the change loses its conversions, and attribution starts over.",
+    container_duplicate: "A container loaded twice can fire its tags twice, inflating page views and conversions; at best one install is redundant.",
+    container_environment: "Visitors run a non-Live version of the container, so tags still under test, or an old setup, collect production data.",
+    datalayer_split: "Events and consent commands pushed to one dataLayer never reach the containers reading another, so some tags miss them.",
+    container_send_to_only: "The destination runs without its own config, so the settings a config command would give it are missing.",
     campaign_params: "Campaign parameters survived the landing redirect and reached the hits, so paid clicks are credited to their campaigns.",
     event_id_reused: "Two different events share one event ID, so the platform keeps the first and silently drops the other: a real event is lost.",
     event_id_mismatch: "The browser and server copies of this event carry different IDs, so Meta cannot pair them and counts the conversion twice.",
@@ -420,6 +451,10 @@ const en = {
     page_crashed: "Open the page in an ordinary browser. If it works there, the site's bot protection refused its scripts to the audit's network; if not, a deployment serves pages that ask for script files it no longer has.",
     gclid_not_stored: "Fire the Conversion Linker tag (or the Google tag with the Ads ID) on every page, on consent granted as well as on page load, and keep the gclid on the landing address until it has run.",
     client_id_changed: "Look for what rewrites or deletes _ga at that step: a consent platform clearing cookies, a second GA4 setup with another cookie_domain or cookie_prefix, or a cross-domain link without the _gl parameter.",
+    container_duplicate: "Keep one install: remove the extra snippet, or the tag in the other container that loads it again.",
+    container_environment: "Use the Live snippet in production: take gtm_auth and gtm_preview out of the GTM snippet, or publish what the environment holds to Live.",
+    datalayer_split: "Point every container at the same dataLayer, or push events and consent commands to each dataLayer the containers read.",
+    container_send_to_only: "Add a gtag('config', ID) for the destination before the events that send to it, or a Google tag for it in GTM.",
     campaign_params: "Nothing to fix. Check the redirects again when the landing pages change.",
     event_id_reused: "Generate a new event ID for every event, not once per page load.",
     event_id_mismatch: "Use one event ID for the pixel event and the server copy: pass the same value to both tags.",
@@ -462,6 +497,10 @@ const en = {
     page_crashed: "hygiene",
     gclid_not_stored: "money",
     client_id_changed: "money",
+    container_duplicate: "money",
+    container_environment: "hygiene",
+    datalayer_split: "hygiene",
+    container_send_to_only: "hygiene",
     campaign_params: "money",
     event_id_reused: "money",
     event_id_mismatch: "money",
@@ -980,6 +1019,29 @@ const tr = {
     party: { first: "Birinci taraf", third: "Üçüncü taraf", both: "İkisi de" },
     otherCookies: "Diğer çerezler",
     noInventory: "Sağlayıcıya giden istek kaydedilmedi.",
+    containersTitle: "Google container'ları",
+    containersIntro: "Her GTM container'ının ve Google etiketinin sayfaya nasıl geldiği: betiğini neyin eklediği, okuduğu dataLayer ve nereden sunulduğu.",
+    noContainers: "Hiçbir GTM container'ı veya Google etiketi betiği yüklenmedi.",
+    containerCol: "Container",
+    sourceCol: "Yükleyen",
+    layerCol: "dataLayer",
+    servedCol: "Sunulduğu yer",
+    containers: {
+      script: { gtm: "GTM container'ı", gtag: "Google etiketi" },
+      served: { google: "Google", site: "Sitenin kendi alan adı" },
+      environment: (env) => (env === "unnamed" ? "GTM ortamı" : `GTM ortamı ${env}`),
+      kinds: {
+        html: () => "Sayfanın HTML'indeki bir script etiketi",
+        inline: () => "Sayfadaki satır içi kod (snippet)",
+        script: (by) => `Sayfadaki başka bir betik: ${by}`,
+        custom_html: (by) => `${by} içindeki bir Özel HTML etiketi`,
+        google_tag: (by) => `${by} içindeki bir Google etiketi (load_google_tags)`,
+        nested: (by) => `${by} kendisi: bir Zone veya etiket şablonu`,
+        config: (by) => `Bir gtag('config') komutu, ${by} yükledi`,
+        send_to: (by) => `config olmadan bir olayın send_to değeri, ${by} yükledi`,
+        destination: (by) => `${by} Google etiketinin bir hedefi`,
+      },
+    },
     provider: "Sağlayıcı",
     checked: "Kontrol edildi",
     outOfScopeStatus: "Kapsam dışı",
@@ -1097,6 +1159,10 @@ const tr = {
     campaignOk: (names) => `${names.join(", ")} açılış sayfasının yönlendirmelerinden geçti ve isteklere ulaştı.`,
     gclidNotStored: () => `Açılış adresi bir gclid taşıyordu ve reklam depolamasına izin verildi, ancak _gcl_aw çerezi onu hiç tutmadı. Google Ads, ziyaretin ilerleyen adımlarındaki ya da sonraki bir ziyaretteki dönüşümü reklam tıklamasına bağlayamaz.`,
     clientIdChanged: (from, at) => `_ga çerezindeki GA4 istemci kimliği "${from}" ile "${at}" arasında değişti. GA4 değişiklikten önceki ve sonraki ziyareti iki ayrı kullanıcı sayar.`,
+    containerDuplicate: (id, sources, step) => `${id}, "${step}" adımında aynı sayfaya ${sources.length} kez yüklendi: ${sources.join("; ")}. Her kopya container'ın etiketlerini yeniden çalıştırabilir, bu yüzden istekler iki kez gidebilir; en iyi ihtimalle kurulumlardan biri boşuna yükleniyor.`,
+    containerEnvironment: (id, env) => `${id}, Live sürüm yerine bir GTM ortamından (${env === "unnamed" ? "gtm_auth" : `gtm_preview=${env}`}) yükleniyor; ziyaretçiler o ortama en son ne yayımlandıysa onu, çoğu zaman bir test veya geliştirme sürümünü çalıştırıyor.`,
+    dataLayerSplit: (list, step) => `"${step}" adımında aynı sayfadaki container'lar farklı dataLayer'ları okuyor: ${list.join(", ")}. Birine yapılan push diğerini okuyan container'lar tarafından hiç görülmez; olaylar ve onay komutları yalnızca bazılarına ulaşabilir.`,
+    sendToOnly: (id, by) => `${id} yalnızca bir olay send_to ile onu adlandırdığı için yüklendi; gtag('config', '${id}') hiç çalışmadı. ${by} ona varsayılan ayarlarla gönderiyor, bu yüzden bir config komutunun onun için ayarlayacağı hiçbir şey uygulanmıyor.`,
     consentDefaultMissing: () => "dataLayer'da Google Consent Mode varsayılan komutu (gtag('consent', 'default', ...)) bulunamadı.",
     consentDefaultLate: () => "Consent Mode varsayılanı, ilk izleme isteği gönderildikten sonra ayarlandı.",
     consentDefaultNotApplied: () => "Sayfa bir Consent Mode varsayılanı gönderdi, ancak Google etiketi onu hiç uygulamadı; etiketleri varsayılan olmadan çalıştı. Tag Assistant, Consent Mode'u yapılandırılmamış gösterir.",
@@ -1151,6 +1217,10 @@ const tr = {
     page_crashed: "Aynı hatayı alan ziyaretçiler bozuk bir sayfa görür ve sayfadaki etiketler çalışmayabilir.",
     gclid_not_stored: "Dönüşümler ziyaretçiyi getiren reklam tıklamasına bağlanmıyor; Google Ads onları eksik raporluyor ve daha az veriyle teklif veriyor.",
     client_id_changed: "Bir ziyaretçi GA4'te iki kullanıcıya dönüşüyor: ziyaret bölünüyor, değişiklikten önceki yolculuk dönüşümlerini kaybediyor ve atıf baştan başlıyor.",
+    container_duplicate: "İki kez yüklenen bir container etiketlerini iki kez çalıştırabilir; sayfa görüntülemeleri ve dönüşümler şişer, en iyi ihtimalle kurulumlardan biri gereksizdir.",
+    container_environment: "Ziyaretçiler container'ın Live olmayan bir sürümünü çalıştırıyor; hâlâ test edilen etiketler ya da eski bir kurulum canlı veri topluyor.",
+    datalayer_split: "Bir dataLayer'a gönderilen olaylar ve onay komutları diğerini okuyan container'lara hiç ulaşmaz; bazı etiketler onları kaçırır.",
+    container_send_to_only: "Hedef kendi config'i olmadan çalışıyor; bir config komutunun ona vereceği ayarlar eksik.",
     campaign_params: "Kampanya parametreleri açılış yönlendirmesinden geçip isteklere ulaştı; ücretli tıklamalar kendi kampanyalarına yazılıyor.",
     event_id_reused: "İki farklı olay tek bir olay kimliğini paylaşıyor; platform ilkini tutup diğerini sessizce atıyor, gerçek bir olay kayboluyor.",
     event_id_mismatch: "Bu olayın tarayıcı ve sunucu kopyaları farklı kimlik taşıyor; Meta ikisini eşleştiremiyor ve dönüşümü iki kez sayıyor.",
@@ -1191,6 +1261,10 @@ const tr = {
     page_crashed: "Sayfayı sıradan bir tarayıcıda açın. Orada çalışıyorsa sitenin bot koruması betiklerini denetimin ağına vermedi; çalışmıyorsa bir dağıtım artık sahip olmadığı betik dosyalarını isteyen sayfalar sunuyor.",
     gclid_not_stored: "Dönüşüm bağlayıcı etiketini (ya da Ads kimliğiyle Google etiketini) her sayfada, sayfa yüklenince olduğu kadar onay verildiğinde de çalıştırın ve gclid'i o etiket çalışana kadar açılış adresinde tutun.",
     client_id_changed: "O adımda _ga'yı yeniden yazan ya da silen şeyi arayın: çerezleri temizleyen bir onay platformu, başka bir cookie_domain ya da cookie_prefix ile ikinci bir GA4 kurulumu, ya da _gl parametresi olmayan alan adları arası bir bağlantı.",
+    container_duplicate: "Tek bir kurulum bırakın: fazladan snippet'i ya da onu diğer container'da yeniden yükleyen etiketi kaldırın.",
+    container_environment: "Canlı sitede Live snippet'ini kullanın: GTM snippet'inden gtm_auth ve gtm_preview'ı çıkarın ya da ortamdaki sürümü Live'a yayımlayın.",
+    datalayer_split: "Tüm container'ları aynı dataLayer'a yönlendirin ya da olayları ve onay komutlarını container'ların okuduğu her dataLayer'a gönderin.",
+    container_send_to_only: "Hedefe gönderen olaylardan önce onun için bir gtag('config', ID) ya da GTM'de onun için bir Google etiketi ekleyin.",
     campaign_params: "Düzeltilecek bir şey yok. Açılış sayfaları değiştiğinde yönlendirmeleri yeniden kontrol edin.",
     event_id_reused: "Her olay için yeni bir olay kimliği üretin; sayfa yüklemesi başına bir kez değil.",
     event_id_mismatch: "Piksel olayı ve sunucu kopyası için tek bir olay kimliği kullanın: aynı değeri iki etikete de verin.",
@@ -1232,6 +1306,10 @@ const tr = {
     page_crashed: "hygiene",
     gclid_not_stored: "money",
     client_id_changed: "money",
+    container_duplicate: "money",
+    container_environment: "hygiene",
+    datalayer_split: "hygiene",
+    container_send_to_only: "hygiene",
     campaign_params: "money",
     event_id_reused: "money",
     event_id_mismatch: "money",

package/src/mcp.js

@@ -33,6 +33,7 @@ import { decodeGcd, DEFAULT_PROVIDERS, googleConsent, isCollectionEndpoint, pars
 import { hitParams } from "./hit-params.js";
 import { CAMPAIGN_PARAMS, campaignParamsIn, withCampaignParams } from "./campaign.js";
 import { cmpFacts } from "./cmp.js";
+import { containerRows, loadSources } from "./containers.js";
 import { consentMatrixMarkdown, consentTable, runConsentScenarios } from "./consent.js";
 import { expectEvents, filterFindings, JOURNEY_PRESETS, onlyEvents, presetFor, withPresetEvents } from "./journeys.js";
 
@@ -102,13 +103,15 @@ function describeHit(h, steps, index) {
 
 /** A consent command in full, as key=value; any other push as JSON, cut, with its page address fields whole. */
 function describePush(p) {
+  // Pushes to a dataLayer of another name (a container's l=) say which.
+  const layer = p.layer ? `[${p.layer}] ` : "";
   if (isConsentCommand(p, "default") || isConsentCommand(p, "update")) {
     const signals = p.value[2] && typeof p.value[2] === "object" ? Object.entries(p.value[2]).map(([k, v]) => `${k}=${show(v)}`).join(" ") : show(p.value[2]);
-    return `- consent ${p.value[1]}: ${signals}`;
+    return `- ${layer}consent ${p.value[1]}: ${signals}`;
   }
   const json = JSON.stringify(p.value) ?? String(p.value);
   const whole = json.length > PUSH_LIMIT ? wholeFieldsIn(p.value) : [];
-  return `- ${cut(json, PUSH_LIMIT)}${whole.length ? ` (${whole.map(([k, v]) => `${k}=${v}`).join(", ")})` : ""}`;
+  return `- ${layer}${cut(json, PUSH_LIMIT)}${whole.length ? ` (${whole.map(([k, v]) => `${k}=${v}`).join(", ")})` : ""}`;
 }
 
 /** A call to a tracking endpoint that carries no event the tool reads, such as a Consent Mode ping, with its consent. */
@@ -150,6 +153,13 @@ function cookieLines(session, step) {
   return lines;
 }
 
+/** One container load in words: its ID, what inserted it, its dataLayer and where it came from. */
+function describeLoad(l) {
+  const c = messages("en").ui.containers;
+  const extra = [l.layer !== "dataLayer" && `dataLayer ${l.layer}`, l.served === "site" && `served from ${l.host}`, l.environment && c.environment(l.environment)].filter(Boolean);
+  return `  ${l.id} (${c.script[l.script]}): ${c.kinds[l.kind](l.by)}${extra.length ? `; ${extra.join(", ")}` : ""}`;
+}
+
 export function stepCapture(audit, step) {
   const { session } = audit;
   const hits = session.hits.filter((h) => h.step === step);
@@ -168,6 +178,8 @@ export function stepCapture(audit, step) {
   if (lateHere.length) lines.push(`Arrived during this step but belong to the step that loaded their page: ${lateHere.map((h) => `${h.platform} ${h.name} (step "${session.steps[h.step]?.label ?? h.step}")`).join(", ")}`);
   if (pings.length) lines.push("Other calls to analytics and ad endpoints, not read as events (Consent Mode pings, resends, remarketing):", ...pings.map(describeCall));
   if (pushes.length) lines.push("dataLayer pushes:", ...pushes.map(describePush));
+  const loads = loadSources({ containerLoads: (session.containerLoads ?? []).filter((l) => l.step === step), dataLayerLog: session.dataLayerLog });
+  if (loads.length) lines.push("Google containers loaded:", ...loads.map(describeLoad));
   lines.push(...cookieLines(session, step));
   const tag = session.steps[step]?.tagConsent;
   if (tag) {
@@ -214,6 +226,31 @@ export function hitDetail(audit, step, index) {
  * hits it sent with their consent, its consent commands and other tracking calls, the Google tag's consent when it
  * changed, and the cookies and ids that changed.
  */
+/** A container load or row as compact JSON: the ID, its source, and the dataLayer, host and environment when they are not the usual ones. */
+function containerJson(l) {
+  return {
+    id: l.id, source: l.kind, ...(l.by ? { by: l.by } : {}),
+    ...(l.layer !== "dataLayer" ? { data_layer: l.layer } : {}),
+    ...(l.served === "site" ? { served_from: l.host } : {}),
+    ...(l.environment ? { gtm_environment: l.environment } : {}),
+    ...(l.pages ? { pages: l.pages } : {}),
+  };
+}
+
+/** The Google containers of the runs and how each reached the page, as lines for a tool result; [] when none loaded. */
+export function containerLines(runs) {
+  const rows = containerRows(runs);
+  if (!rows.length) return [];
+  const c = messages("en").ui.containers;
+  return [
+    "Google containers (how each reached the page):",
+    ...rows.map((r) => {
+      const extra = [r.layer !== "dataLayer" && `dataLayer ${r.layer}`, r.served === "site" && `served from ${r.host}`, r.environment && c.environment(r.environment), `${r.pages.length} ${r.pages.length === 1 ? "page" : "pages"}`].filter(Boolean);
+      return `  ${r.id} (${c.script[r.script]}): ${c.kinds[r.kind](r.by)}; ${extra.join(", ")}`;
+    }),
+  ];
+}
+
 export function timelineOf(run) {
   let lastIds = null;
   return (run.steps ?? []).map((st) => {
@@ -230,6 +267,8 @@ export function timelineOf(run) {
     if (st.tagConsent) entry.tag_consent = Object.fromEntries(Object.entries(st.tagConsent.entries).map(([k, e]) => [k, e.update ?? e.default ?? null]));
     const cookies = Object.fromEntries(["added", "changed", "removed"].map((k) => [k, names(k)]).filter(([, list]) => list.length));
     if (Object.keys(cookies).length) entry.cookies = cookies;
+    const loads = loadSources({ containerLoads: (run.containerLoads ?? []).filter((l) => l.step === st.index), dataLayerLog: run.dataLayerLog });
+    if (loads.length) entry.containers = loads.map(containerJson);
     if (st.identity && JSON.stringify(st.identity) !== JSON.stringify(lastIds)) entry.ids = st.identity;
     if (st.identity) lastIds = st.identity;
     return entry;
@@ -466,15 +505,33 @@ export function buildServer(opts) {
     },
   );
 
+  server.registerTool(
+    "get_containers",
+    {
+      title: "List the Google containers loaded so far",
+      description:
+        "Returns every GTM container (gtm.js) and Google tag (gtag/js) this audit's pages loaded so far, and how each reached the page: a script tag in the HTML, the inline snippet, another script (named by its address, such as a consent platform), a Custom HTML tag or a Google tag in another GTM container, a container loading another itself (a Zone or a tag template), a gtag('config') command, an event's send_to with no config, or a destination of the Google tag. Also the dataLayer each reads, whether it was served from the site's own domain, the GTM environment when one is named, and the step it loaded at. Duplicates, GTM environments and split dataLayers are flagged by finish_audit.",
+      inputSchema: { audit_id: z.string() },
+      annotations: { readOnlyHint: true },
+    },
+    async ({ audit_id }) => {
+      const { session } = getAudit(audit_id);
+      const loads = loadSources({ containerLoads: session.containerLoads ?? [], dataLayerLog: session.dataLayerLog });
+      if (!loads.length) return text("No GTM container or Google tag script has loaded on this audit's pages yet.");
+      const lines = loads.map((l) => `Step ${l.step} ("${session.steps[l.step]?.label ?? ""}"), ${l.page ?? "?"}:\n${describeLoad(l)}`);
+      return text(`${loads.length} container ${loads.length === 1 ? "load" : "loads"}:\n${lines.join("\n")}\n\nAs JSON: ${JSON.stringify(loads.map((l) => ({ step: l.step, page: l.page, ...containerJson(l) })))}`);
+    },
+  );
+
   server.registerTool(
     "get_report",
     {
       title: "Read a report this server wrote",
       description:
-        "Returns a report finish_audit or run_audit wrote, so it can be read without access to the computer running this server. part markdown (default): report.md, the verdict, findings, consent and journeys in about 120 lines. summary: summary.json, the counts, journeys and findings as JSON. timeline: one JSON entry per step of each journey (hits with their consent, consent commands, the Google tag's consent, cookies and ids).",
+        "Returns a report finish_audit or run_audit wrote, so it can be read without access to the computer running this server. part markdown (default): report.md, the verdict, findings, consent and journeys in about 120 lines. summary: summary.json, the counts, journeys and findings as JSON. timeline: one JSON entry per step of each journey (hits with their consent, consent commands, the Google tag's consent, cookies and ids, the Google containers loaded). containers: every GTM container and Google tag the journeys loaded as JSON, with how each reached the page (source html, inline, script, custom_html, google_tag, nested, config, send_to or destination, and by: the container or script that loaded it), its dataLayer, host, GTM environment and pages.",
       inputSchema: {
         report: z.string().describe("The report name finish_audit or run_audit gave."),
-        part: z.enum(["markdown", "summary", "timeline"]).optional().describe("Default markdown."),
+        part: z.enum(["markdown", "summary", "timeline", "containers"]).optional().describe("Default markdown."),
       },
       annotations: { readOnlyHint: true },
     },
@@ -485,6 +542,7 @@ export function buildServer(opts) {
         if (part === "markdown") return text(await readFile(path.join(dir, "report.md"), "utf8"));
         if (part === "summary") return text(await readFile(path.join(dir, "summary.json"), "utf8"));
         const capture = JSON.parse(await readFile(path.join(dir, "capture.json"), "utf8"));
+        if (part === "containers") return text(JSON.stringify(containerRows(capture.runs ?? []).map(containerJson)));
         return text(JSON.stringify((capture.runs ?? []).map((r) => ({ journey: r.journeyId, viewport: r.viewport, steps: timelineOf(r) }))));
       } catch (err) {
         return fail(`Could not read the report: ${err.message}`);
@@ -594,13 +652,14 @@ export function buildServer(opts) {
         `${run.hits.length} tracking hits, ${run.dataLayerLog.length} dataLayer pushes and ${run.network.length} analytics or ad network calls captured over ${run.steps.length} steps.`,
         skippedLine(run),
         ...((platform) => (platform ? [`Consent platform: ${platform.vendor}. ${platform.facts.join(" ")}`] : []))(cmpFacts(messages("en"), [run])),
+        ...containerLines([run]),
         opts.allowFiles
           ? `Full report with the event timeline: ${reportPath}`
           : opts.reportsUrl
             ? `Full report with the event timeline: ${opts.reportsUrl}/${path.basename(outDir)}/report.html`
             : "",
         "",
-        `To read the report here: get_report with report "${path.basename(outDir)}" (markdown, summary or timeline).`,
+        `To read the report here: get_report with report "${path.basename(outDir)}" (markdown, summary, timeline or containers).`,
         "Explain each problem to the user with its likely cause and fix.",
       ];
       return {
@@ -746,8 +805,9 @@ export function buildServer(opts) {
             ...(result.baseline ? [`${result.baseline.accepted} accepted from the baseline${result.baseline.partial ? `, ${result.baseline.partial} accepted in some places only (still counted)` : ""}, ${result.baseline.stale.length} stale baseline entries`] : []),
             ...result.runs.map((r) => `${r.journeyId} (${r.viewport}): ${r.completed ? "completed" : "not completed"}, ${r.note}`),
             ...grouped.map((f) => `- ${m.severity[f.severity]}${f.accepted ? ` (${m.ui.accepted})` : ""}: ${f.detail}`),
+            ...containerLines(result.runs),
             `Report: ${result.reportPath}`,
-            `To read the report here: get_report with report "${path.basename(result.outDir)}" (markdown, summary or timeline).`,
+            `To read the report here: get_report with report "${path.basename(result.outDir)}" (markdown, summary, timeline or containers).`,
           ].join("\n"),
         );
       },

package/src/report.js

@@ -5,6 +5,7 @@ import { createProvider } from "./providers.js";
 import { canonicalEvent, groupFindings, summarize } from "./checks.js";
 import { messages } from "./i18n.js";
 import { buildInventory } from "./inventory.js";
+import { containerRows } from "./containers.js";
 import { computeMetrics } from "./metrics.js";
 import { historySummaryLines, sparkline } from "./history.js";
 import { cardIds } from "./html/lib.js";
@@ -396,6 +397,21 @@ function mdInventory(m, runs) {
   return lines;
 }
 
+/** The Google containers and how each reached the page, one row per container and source. Omitted when none loaded. */
+function mdContainers(m, runs) {
+  const rows = containerRows(runs);
+  if (!rows.length) return [];
+  const c = m.ui.containers;
+  const lines = [`## ${m.ui.containersTitle}`, "", `| ${m.ui.containerCol} | ${m.ui.sourceCol} | ${m.ui.layerCol} | ${m.ui.servedCol} | ${m.ui.pagesCol} |`, "|---|---|---|---|---|"];
+  for (const r of rows.slice(0, MD_INVENTORY_ROWS)) {
+    const served = r.served === "google" ? c.served.google : `${c.served.site} (${r.host})`;
+    lines.push(`| ${mdText(r.id)} (${c.script[r.script]}) | ${mdText(c.kinds[r.kind](r.by))}${r.environment ? `, ${mdText(c.environment(r.environment))}` : ""} | ${mdText(r.layer)} | ${mdText(served)} | ${r.pages.length} |`);
+  }
+  if (rows.length > MD_INVENTORY_ROWS) lines.push("", m.ui.md.moreIn(rows.length - MD_INVENTORY_ROWS, "report.html"));
+  lines.push("");
+  return lines;
+}
+
 /** The trend in up to five lines: the text sparkline with the direction, then the open-longest and flapping lines. */
 function mdTrend(m, trend, lang) {
   if (!trend || trend.runs < 2) return [];
@@ -447,6 +463,7 @@ export function renderMarkdown({ title, site = null, generatedAt, findings, expl
   lines.push(...mdJourneys(m, runs, rows));
   lines.push(...mdNotChecked(m, runs, rows, plan, consentScenarios));
   lines.push(...mdInventory(m, runs));
+  lines.push(...mdContainers(m, runs));
   // A report with its own name or logo carries no Analitik İşler credit; the ai tag debugger one stays.
   if (brand?.name || brand?.logo) lines.push("---", "", `_${brand.name ? `${brand.name} · ` : ""}${m.ui.generatedBy}_`, "");
   else if (branding) lines.push("---", "", `_${m.ui.generatedBy} · [analitikisler.com](https://analitikisler.com)_`, "");