diff --git a/.github/workflows/refresh-profile.yml b/.github/workflows/refresh-profile.yml
index a177a2d..519d60a 100644
--- a/.github/workflows/refresh-profile.yml
+++ b/.github/workflows/refresh-profile.yml
@@ -37,7 +37,7 @@ jobs:
       - name: Collect metrics
         env:
           GITHUB_TOKEN: ${{ secrets.SCORE_BOT_PAT }}
-        run: uv run generate-repo-overview collect
+        run: uv run generate-repo-overview collect --org-config org_config.toml
 
       - name: Render overview (MD)
         run: uv run generate-repo-overview render-overview
diff --git a/AGENTS.md b/AGENTS.md
index 3050c44..98bc233 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -6,7 +6,7 @@ Context file for AI coding assistants. See `docs/repo-overview-tool-design.md` f
 
 ```sh
 uv sync --all-groups --frozen                   # install deps
-uv run generate-repo-overview collect           # GitHub API → snapshot JSON
+uv run generate-repo-overview collect --org-config org_config.toml  # GitHub API → snapshot JSON
 uv run generate-repo-overview render-overview   # snapshot → profile/README.md
 uv run generate-repo-overview render-details    # snapshot → _site/ (index + per-repo pages)
 uv run pytest                                   # run tests
@@ -17,14 +17,18 @@ uv run basedpyright src/                        # type check
 ## Key files for website work
 
 ```
+org_config.toml                        — organization-specific settings (org name, tracked deps, workflow signals)
 src/generate_repo_overview/
+  org_config.py       — loads and validates org_config.toml
   metrics_html.py     — HTML renderer (index + per-repo detail pages)
   metrics_report.py   — shared helpers: grouping, version comparison, badges
-  models.py           — RepoEntry, RepoSnapshot, signal dataclasses
+  models.py           — RepoEntry, RepoSnapshot, TrackedDep, WorkflowSignal dataclasses
   cli.py              — render-details writes all pages from render_all_pages()
   constants.py        — default paths (DEFAULT_METRICS_HTML_OUTPUT = _site/)
 tests/
   test_cli_render.py  — render output tests
+  test_org_config.py  — org config loading/validation tests
+  test_repo_overview.py — collector and snapshot round-trip tests
 ```
 
 ## Website rendering notes
diff --git a/CLAUDE.md b/CLAUDE.md
index 8f62ad3..43c994c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -1 +1 @@
-See [AGENTS.md](AGENTS.md) for project context, key files, and dev commands.
+@AGENTS.md
diff --git a/README.md b/README.md
index c53fcfd..3c559d4 100644
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ uv run generate-repo-overview render-details
 For a fresh GitHub pull before rendering, run:
 
 ```sh
-uv run generate-repo-overview collect
+uv run generate-repo-overview collect --org-config org_config.toml
 ```
 
 By default, `collect` now does a cache-aware refresh: it checks fast, high-level
diff --git a/docs/repo-overview-tool-design.md b/docs/repo-overview-tool-design.md
index 355c665..950b082 100644
--- a/docs/repo-overview-tool-design.md
+++ b/docs/repo-overview-tool-design.md
@@ -11,15 +11,17 @@
 
 The tool is split into three layers:
 
-1. `collector/`
+1. `org_config.py`
+   - Loads organization-specific settings from `org_config.toml`: org name, repo include patterns, tracked Bazel deps, workflow signals, reference integration repo, and registry repo.
+2. `collector/`
    - Connects to GitHub.
    - Loads active repositories and custom properties.
-   - Derives content-based signals such as `has_ci`, `has_lint_config`, `has_coverage_config`, `bazel_version`, and `referenced_by_reference_integration`.
+   - Derives content-based signals such as `has_ci`, `has_lint_config`, `has_coverage_config`, `bazel_version`, `matched_workflow_signals`, `bazel_deps`, and `referenced_by_reference_integration`.
    - Writes and reads a local JSON snapshot cache.
-2. `profile_readme.py`, `metrics_report.py`, `metrics_html.py` (with `_html_index.py`, `_html_detail.py`, `_html_common.py`)
+3. `profile_readme.py`, `metrics_report.py`, `metrics_html.py` (with `_html_index.py`, `_html_detail.py`, `_html_common.py`)
    - Render different views (Markdown and HTML) from the same normalized data model.
    - Keep presentation decisions out of the collection layer.
-3. `cli.py`
+4. `cli.py`
    - Orchestrates cache-aware commands: `collect`, `render-overview`, and `render-details`.
 
 ## Data Model
@@ -32,6 +34,8 @@ The shared model lives in `models.py`.
   - organization name
   - generation timestamp
   - normalized repositories
+  - tracked Bazel dependency definitions (`tracked_deps`)
+  - workflow signal definitions (`workflow_signals`)
 
 The snapshot is intentionally renderer-agnostic. It stores neutral values such as booleans and plain strings rather than Markdown-specific markers.
 
@@ -78,8 +82,9 @@ uv run generate-repo-overview <command>
 
 Built-in commands:
 
-- `collect`
+- `collect --org-config org_config.toml`
   - Sync the cached snapshot from GitHub and write it to disk.
+  - Requires `--org-config` pointing to a TOML file with organization-specific settings.
   - Use `--deep` to force a full refresh for every repository instead of reusing cached signals for unchanged ones.
 - `render-overview`
   - Render the profile README from an existing snapshot.
diff --git a/org_config.toml b/org_config.toml
new file mode 100644
index 0000000..7c9ff66
--- /dev/null
+++ b/org_config.toml
@@ -0,0 +1,40 @@
+# Organization configuration for generate-repo-overview.
+#
+# This file defines which GitHub organization to scan and how to detect
+# repository signals.  The tool requires this file via --org-config.
+#
+# For a different organization, copy this file and adjust the values.
+
+org_name = "eclipse-score"
+
+# Optional fnmatch glob patterns to limit which repositories are included.
+# When empty (or omitted), all non-archived repositories in the org are included.
+# Example: repo_include_patterns = ["my-prefix-*", "another-repo"]
+# repo_include_patterns = []
+
+[signals]
+
+# Repository (org/repo) that serves as the reference integration project.
+# Its MODULE.bazel is parsed to determine which other repositories are
+# referenced as Bazel dependencies.
+# Leave empty if there is no reference integration repository.
+reference_integration_repo = "eclipse-score/reference_integration"
+
+# Full "org/repo" path to the Bazel registry repository.
+# Leave empty if there is no Bazel registry.
+registry_repo = "eclipse-score/bazel_registry"
+
+# Tracked Bazel dependencies.  Each entry maps a source repository (org/repo)
+# to its Bazel module name.  The tool looks up each module_name in every
+# repository's MODULE.bazel to report dependency versions.
+[[signals.tracked_deps]]
+repo = "eclipse-score/docs-as-code"
+module_name = "score_docs_as_code"
+
+# Named workflow signals.  Each entry has a human-readable label shown in the
+# metrics output, and a reference string to search for inside
+# .github/workflows/*.yml files.  A repository is flagged for a signal when
+# any of its workflow files contain the reference string.
+[[signals.workflow_signals]]
+label = "Daily Workflow"
+reference = "eclipse-score/cicd-workflows/.github/workflows/daily.yml@"
diff --git a/src/generate_repo_overview/README.md b/src/generate_repo_overview/README.md
index 96e1369..8f45aff 100644
--- a/src/generate_repo_overview/README.md
+++ b/src/generate_repo_overview/README.md
@@ -38,8 +38,10 @@ This document explains the package structure and cache behavior. It intentionall
   - Renders the main HTML metrics dashboard (tabs, filters, sortable columns).
 - `_html_detail.py`
   - Renders per-repository HTML detail pages.
+- `org_config.py`
+  - Loads `org_config.toml`: org name, repo include patterns, tracked Bazel deps, workflow signals.
 - `constants.py`
-  - Centralizes default org, cache, and output paths.
+  - Centralizes default cache and output paths.
 - `console.py`
   - Keeps status output formatting in one place.
 
@@ -70,6 +72,8 @@ That file stores a serialized `RepoSnapshot` containing:
 - organization name
 - generation timestamp
 - all normalized repositories
+- tracked Bazel dependency definitions (`tracked_deps`)
+- workflow signal definitions (`workflow_signals`)
 
 The cache loader only accepts the current schema version. If the snapshot schema does not match, the cache is treated as unusable and collection falls back to a fresh GitHub fetch.
 
@@ -106,14 +110,13 @@ For each repository, the snapshot currently stores:
   - `is_bazel_repo`
   - `bazel_version`
   - `codeowners`
-  - `docs_as_code_version`
   - `referenced_by_reference_integration`
   - `has_lint_config`
   - `has_gitlint_config`
   - `has_pyproject_toml`
   - `has_pre_commit_config`
   - `has_ci`
-  - `uses_cicd_daily_workflow`
+  - `matched_workflow_signals`
   - `has_coverage_config`
   - `top_languages`
   - `bazel_deps`
diff --git a/src/generate_repo_overview/_html_common.py b/src/generate_repo_overview/_html_common.py
index f802ab6..c00fd1c 100644
--- a/src/generate_repo_overview/_html_common.py
+++ b/src/generate_repo_overview/_html_common.py
@@ -81,9 +81,15 @@ def version_badge(
     version: str | None,
     max_bazel: tuple[int, ...] | None,
     *,
-    latest_dac: str | None,
+    latest_dep_version: str | None,
     is_bazel: bool,
 ) -> str:
+    """Render a colored version badge span.
+
+    Bazel versions are green when equal to *max_bazel*, red otherwise.
+    Dep versions compare against *latest_dep_version*: green if equal,
+    yellow if same major.minor, red if older, muted if unknown.
+    """
     if version is None or not version.strip():
         return '<span class="badge muted">—</span>'
 
@@ -95,9 +101,9 @@ def version_badge(
             return f'<span class="badge green">{e(cleaned)}</span>'
         return f'<span class="badge red">{e(cleaned)}</span>'
 
-    if latest_dac is None:
+    if latest_dep_version is None:
         return f'<span class="badge muted">{e(cleaned)}</span>'
-    latest_cleaned = latest_dac.strip()
+    latest_cleaned = latest_dep_version.strip()
     if cleaned == latest_cleaned:
         return f'<span class="badge green">{e(cleaned)}</span>'
     if parsed is not None:
diff --git a/src/generate_repo_overview/_html_detail.py b/src/generate_repo_overview/_html_detail.py
index e9df6f4..732ab83 100644
--- a/src/generate_repo_overview/_html_detail.py
+++ b/src/generate_repo_overview/_html_detail.py
@@ -3,6 +3,7 @@
 from typing import TYPE_CHECKING
 
 from ._html_common import BAZEL_ICON, CSS, GITHUB_ICON, e, language_badge, version_badge
+from .metrics_report import tracked_dep_label
 
 if TYPE_CHECKING:
     from .models import RepoEntry, RepoSnapshot
@@ -10,11 +11,11 @@
 
 def render_detail_page(
     entry: RepoEntry,
-    org_name: str,
     snapshot: RepoSnapshot,
     max_bazel: tuple[int, ...] | None,
-    latest_dac: str | None,
+    latest_dep_versions: dict[str, str | None],
 ) -> str:
+    org_name = snapshot.org_name
     return (
         "<!DOCTYPE html>\n"
         '<html lang="en">\n<head>\n'
@@ -27,9 +28,9 @@ def render_detail_page(
         + _render_stat_grid(entry)
         + _render_release_section(entry)
         + _render_dep_diff_section(entry)
-        + _render_tooling_section(entry)
+        + _render_tooling_section(entry, snapshot)
         + _render_ownership_section(entry)
-        + _render_versions_section(entry, max_bazel, latest_dac)
+        + _render_versions_section(entry, snapshot, max_bazel, latest_dep_versions)
         + _render_footer(snapshot)
         + "</body>\n</html>\n"
     )
@@ -231,18 +232,21 @@ def _dep_status_badge(status: str, css_class: str) -> str:
     return f'<span class="badge {css_class}">{e(status)}</span>'
 
 
-def _render_tooling_section(entry: RepoEntry) -> str:
+def _render_tooling_section(entry: RepoEntry, snapshot: RepoSnapshot) -> str:
     c = entry.content
-    signals = [
+    signals: list[tuple[bool, str]] = [
         (c.has_ci, "GitHub Actions (CI)"),
-        (c.uses_cicd_daily_workflow, "Daily Workflow"),
+    ]
+    for label in (s.label for s in snapshot.workflow_signals):
+        signals.append((label in c.matched_workflow_signals, label))
+    signals.extend([
         (c.has_lint_config, "Lint Config"),
         (c.has_gitlint_config, "Gitlint"),
         (c.has_pre_commit_config, "Pre-commit"),
         (c.has_pyproject_toml, "pyproject.toml"),
         (c.has_coverage_config, "Coverage Config"),
         (c.is_bazel_repo, "Bazel Repo"),
-    ]
+    ])
 
     items = "\n".join(
         f'    <div class="signal-item">'
@@ -288,26 +292,31 @@ def _render_ownership_section(entry: RepoEntry) -> str:
 
 def _render_versions_section(
     entry: RepoEntry,
+    snapshot: RepoSnapshot,
     max_bazel: tuple[int, ...] | None,
-    latest_dac: str | None,
+    latest_dep_versions: dict[str, str | None],
 ) -> str:
+    from .models import lookup_bazel_dep_version
+
     items: list[str] = []
 
     bazel_badge = version_badge(
-        entry.content.bazel_version, max_bazel, latest_dac=None, is_bazel=True
+        entry.content.bazel_version, max_bazel, latest_dep_version=None, is_bazel=True
     )
     items.append(
         f'<div class="info-item">'
         f'<div class="info-label">Bazel Version</div>{bazel_badge}</div>'
     )
 
-    dac_badge = version_badge(
-        entry.content.docs_as_code_version, None, latest_dac=latest_dac, is_bazel=False
-    )
-    items.append(
-        f'<div class="info-item">'
-        f'<div class="info-label">Docs-As-Code Version</div>{dac_badge}</div>'
-    )
+    for dep in snapshot.tracked_deps:
+        dep_label = tracked_dep_label(dep)
+        dep_ver = lookup_bazel_dep_version(entry.content.bazel_deps, dep.module_name)
+        latest_ver = latest_dep_versions.get(dep.module_name)
+        badge = version_badge(dep_ver, None, latest_dep_version=latest_ver, is_bazel=False)
+        items.append(
+            f'<div class="info-item">'
+            f'<div class="info-label">{e(dep_label)} Version</div>{badge}</div>'
+        )
 
     refint = (
         '<span class="badge green">yes</span>'
diff --git a/src/generate_repo_overview/_html_index.py b/src/generate_repo_overview/_html_index.py
index cead6d9..8e2e24f 100644
--- a/src/generate_repo_overview/_html_index.py
+++ b/src/generate_repo_overview/_html_index.py
@@ -14,15 +14,18 @@
     version_badge,
 )
 from .metrics_report import (
-    get_latest_docs_as_code_release,
+    get_latest_tracked_dep_version,
     get_max_bazel_version,
     group_repos_by_category,
     has_latest_release,
     parse_version_key,
+    tracked_dep_label,
 )
 
 if TYPE_CHECKING:
-    from .models import RepoEntry, RepoSnapshot
+    from .models import RepoEntry, RepoSnapshot, TrackedDep
+
+from .models import is_tracked_dep_repo
 
 _INDEX_JS = (Path(__file__).parent / "templates" / "index.js").read_text(
     encoding="utf-8"
@@ -45,9 +48,9 @@ def render_index_page(snapshot: RepoSnapshot) -> str:
         + _render_filters_placeholder()
         + '<div id="sections">\n'
         + _render_overview_sections(categories, snapshot.org_name)
-        + _render_versions_sections(categories, repos, snapshot.org_name)
-        + _render_automation_sections(categories, snapshot.org_name)
-        + _render_traceability_section(repos, snapshot.org_name)
+        + _render_versions_sections(categories, snapshot)
+        + _render_automation_sections(categories, snapshot)
+        + _render_traceability_section(repos, snapshot)
         + "</div>\n"
         + _render_footer(snapshot)
         + _render_script(categories)
@@ -246,12 +249,7 @@ def _render_release(version: str | None, commits_since: int | None) -> str:
     )
 
 
-_DAC_DEP_NAME = "score_docs_as_code"
-_DAC_REPO_NAME = "docs-as-code"
-
 
-def _is_docs_as_code_repo(entry: RepoEntry) -> bool:
-    return bool(entry.content.docs_as_code_version) or entry.name == _DAC_REPO_NAME
 
 
 def _build_version_tooltip(
@@ -375,15 +373,26 @@ def _render_dep_changes(
 
 def _render_versions_sections(
     categories: list[tuple[str, list[RepoEntry]]],
-    repos: list[RepoEntry],
-    org_name: str,
+    snapshot: RepoSnapshot,
 ) -> str:
+    repos = sorted(snapshot.repos, key=lambda r: r.name.casefold())
     max_bazel = get_max_bazel_version(repos)
-    latest_dac = get_latest_docs_as_code_release(repos)
+    tracked_deps = snapshot.tracked_deps
+    latest_dep_versions = {
+        dep.module_name: get_latest_tracked_dep_version(repos, dep)
+        for dep in tracked_deps
+    }
+    org_name = snapshot.org_name
     parts: list[str] = []
     for category, cat_repos in categories:
         rows = "\n".join(
-            _versions_row(r, org_name, max_bazel, latest_dac) for r in cat_repos
+            _versions_row(r, org_name, max_bazel, tracked_deps, latest_dep_versions)
+            for r in cat_repos
+        )
+        dep_headers = "".join(
+            f'      <th data-sort="dep-{i}" title="Version of the {e(tracked_dep_label(dep))} dependency.">'
+            f'{e(tracked_dep_label(dep))} Version <span class="sort-arrow"></span></th>\n'
+            for i, dep in enumerate(tracked_deps)
         )
         parts.append(
             f'<div class="section hidden" data-tab="versions" data-category="{e(category)}">\n'
@@ -395,10 +404,10 @@ def _render_versions_sections(
             f"    <thead><tr>\n"
             f'      <th data-sort="name">Repository <span class="sort-arrow"></span></th>\n'
             f'      <th data-sort="bazel" title="The version of Bazel (the build tool) in use. Green = on the latest known version, red = a newer version is available.">{BAZEL_ICON} Bazel Version <span class="sort-arrow"></span></th>\n'
-            f'      <th data-sort="dac" title="The version of the Docs-As-Code tooling in use. Green = up to date, yellow = a patch update is available, red = a major or minor update is needed.">Docs-As-Code Version <span class="sort-arrow"></span></th>\n'
+            f"{dep_headers}"
             f'      <th data-sort="refint" class="text-center" title="Whether this repository is included in the shared reference integration test suite.">Reference Integration <span class="sort-arrow"></span></th>\n'
             f'      <th data-sort="release" title="The most recent published release. Green = no unreleased commits, yellow = up to 20 commits not yet released, red = more than 20 commits not yet released.">Latest Release <span class="sort-arrow"></span></th>\n'
-            f'      <th data-sort="depchanges" title="Number of dependency version changes on the main branch since the last release. Bazel and Docs-As-Code versions are shown in their own columns.">Other Dep Changes <span class="sort-arrow"></span></th>\n'
+            f'      <th data-sort="depchanges" title="Number of dependency version changes on the main branch since the last release. Tracked dependency versions are shown in their own columns.">Other Dep Changes <span class="sort-arrow"></span></th>\n'
             f"    </tr></thead>\n"
             f"    <tbody>\n{rows}\n    </tbody>\n"
             f"  </table>\n"
@@ -411,12 +420,15 @@ def _versions_row(
     entry: RepoEntry,
     org_name: str,
     max_bazel: tuple[int, ...] | None,
-    latest_dac: str | None,
+    tracked_deps: tuple[TrackedDep, ...],
+    latest_dep_versions: dict[str, str | None],
 ) -> str:
+    from .models import lookup_bazel_dep_version
+
     name_cell = repo_name_cell(entry, org_name)
 
     bazel_cell = version_badge(
-        entry.content.bazel_version, max_bazel, latest_dac=None, is_bazel=True
+        entry.content.bazel_version, max_bazel, latest_dep_version=None, is_bazel=True
     )
     release_bazel = entry.volatile.release_bazel_version
     if release_bazel and release_bazel != entry.content.bazel_version:
@@ -425,22 +437,32 @@ def _versions_row(
         )
 
     release_deps = dict(entry.volatile.release_bazel_deps)
-    release_dac = release_deps.get(_DAC_DEP_NAME)
-    dac_cell = version_badge(
-        entry.content.docs_as_code_version, None, latest_dac=latest_dac, is_bazel=False
-    )
-    if release_dac and release_dac != entry.content.docs_as_code_version:
-        dac_cell = f'<span class="mono text-muted">{e(release_dac)}</span> → {dac_cell}'
+    dedicated_dep_names = frozenset(dep.module_name for dep in tracked_deps)
+
+    dep_cells: list[str] = []
+    for dep in tracked_deps:
+        dep_label = tracked_dep_label(dep)
+        head_ver = lookup_bazel_dep_version(entry.content.bazel_deps, dep.module_name)
+        release_ver = release_deps.get(dep.module_name)
+        latest_ver = latest_dep_versions.get(dep.module_name)
+        cell = version_badge(head_ver, None, latest_dep_version=latest_ver, is_bazel=False)
+        if release_ver and release_ver != head_ver:
+            cell = f'<span class="mono text-muted">{e(release_ver)}</span> → {cell}'
+        tip = _build_version_tooltip(
+            dependency_version_as_used_on_main_branch=head_ver,
+            latest_available_dependency_version=latest_ver,
+            dependency_version_as_used_in_last_release=release_ver,
+            component_name=dep_label,
+            last_release_tag=entry.volatile.latest_release_version,
+        )
+        dep_cells.append(f'      <td data-tooltip="{e(tip)}">{cell}</td>\n')
 
-    # Deps rendered in their own column — excluded from "Other Dep Changes"
-    dedicated_deps = frozenset({_DAC_DEP_NAME})
     refint = (
         '<span class="badge green">yes</span>'
         if entry.content.referenced_by_reference_integration
         else '<span class="text-muted">no</span>'
     )
 
-    # Format latest Bazel version as string for generic comparison
     max_bazel_str = ".".join(str(x) for x in max_bazel) if max_bazel else None
     bazel_tip = _build_version_tooltip(
         dependency_version_as_used_on_main_branch=entry.content.bazel_version,
@@ -450,15 +472,6 @@ def _versions_row(
         last_release_tag=entry.volatile.latest_release_version,
     )
 
-    # Generate Docs-As-Code version comparison tooltip
-    dac_tip = _build_version_tooltip(
-        dependency_version_as_used_on_main_branch=entry.content.docs_as_code_version,
-        latest_available_dependency_version=latest_dac,
-        dependency_version_as_used_in_last_release=release_dac,
-        component_name="Docs-As-Code",
-        last_release_tag=entry.volatile.latest_release_version,
-    )
-
     refint_tip = (
         "This repository is included in the shared reference integration."
         if entry.content.referenced_by_reference_integration
@@ -480,14 +493,14 @@ def _versions_row(
     else:
         release_tip = f"{ver} — {commits} commit{'s' if commits != 1 else ''} on the main branch not yet included in a release."
 
-    dep_changes_cell, dep_changes_tip = _render_dep_changes(entry, dedicated_deps)
+    dep_changes_cell, dep_changes_tip = _render_dep_changes(entry, dedicated_dep_names)
 
     return (
         f"    <tr>\n"
         f"      <td>{name_cell}</td>\n"
         f'      <td data-tooltip="{e(bazel_tip)}">{bazel_cell}</td>\n'
-        f'      <td data-tooltip="{e(dac_tip)}">{dac_cell}</td>\n'
-        f'      <td class="text-center" data-tooltip="{e(refint_tip)}">{refint}</td>\n'
+        + "".join(dep_cells)
+        + f'      <td class="text-center" data-tooltip="{e(refint_tip)}">{refint}</td>\n'
         f'      <td data-tooltip="{e(release_tip)}">{release}</td>\n'
         f'      <td data-tooltip="{e(dep_changes_tip)}">{dep_changes_cell}</td>\n'
         f"    </tr>"
@@ -496,11 +509,20 @@ def _versions_row(
 
 def _render_automation_sections(
     categories: list[tuple[str, list[RepoEntry]]],
-    org_name: str,
+    snapshot: RepoSnapshot,
 ) -> str:
+    signal_labels = tuple(s.label for s in snapshot.workflow_signals)
+    org_name = snapshot.org_name
     parts: list[str] = []
     for category, cat_repos in categories:
-        rows = "\n".join(_automation_row(r, org_name) for r in cat_repos)
+        rows = "\n".join(
+            _automation_row(r, org_name, signal_labels) for r in cat_repos
+        )
+        signal_headers = "".join(
+            f'      <th data-sort="signal-{i}" class="text-center" title="Whether this repository matches the {e(label)} workflow signal.">'
+            f'{e(label)} <span class="sort-arrow"></span></th>\n'
+            for i, label in enumerate(signal_labels)
+        )
         parts.append(
             f'<div class="section hidden" data-tab="tech-stack" data-category="{e(category)}">\n'
             f'  <div class="section-header">\n'
@@ -516,7 +538,7 @@ def _render_automation_sections(
             f'      <th data-sort="pyproject" class="text-center" title="Whether this repository has a pyproject.toml — the standard configuration file for Python projects.">Pyproject <span class="sort-arrow"></span></th>\n'
             f'      <th data-sort="precommit" class="text-center" title="Whether this repository runs automated checks (formatting, linting, etc.) before each commit is accepted.">Pre-commit <span class="sort-arrow"></span></th>\n'
             f'      <th data-sort="ci" class="text-center" title="Whether this repository has automated CI/CD pipelines that run on every push or pull request.">GitHub Actions <span class="sort-arrow"></span></th>\n'
-            f'      <th data-sort="daily" class="text-center" title="Whether this repository has a scheduled daily job that runs automated tests and checks.">Daily Workflow <span class="sort-arrow"></span></th>\n'
+            f"{signal_headers}"
             f'      <th data-sort="coverage" class="text-center" title="Whether this repository measures test coverage — tracking how much of the code is exercised by automated tests.">Coverage <span class="sort-arrow"></span></th>\n'
             f"    </tr></thead>\n"
             f"    <tbody>\n{rows}\n    </tbody>\n"
@@ -526,7 +548,9 @@ def _render_automation_sections(
     return "".join(parts)
 
 
-def _automation_row(entry: RepoEntry, org_name: str) -> str:
+def _automation_row(
+    entry: RepoEntry, org_name: str, signal_labels: tuple[str, ...]
+) -> str:
     name_cell = repo_name_cell(entry, org_name, bazel_icon=False)
     c = entry.content
 
@@ -556,14 +580,21 @@ def _yesno(val: bool) -> str:
         "ci": "This repository has automated CI/CD pipelines that run on every push or pull request."
         if c.has_ci
         else "This repository has no automated CI/CD pipelines.",
-        "daily": "This repository has a scheduled daily job that runs automated tests and checks."
-        if c.uses_cicd_daily_workflow
-        else "This repository has no scheduled daily automated checks.",
         "coverage": "This repository measures test coverage — tracking how much of the code is exercised by automated tests."
         if c.has_coverage_config
         else "This repository does not measure test coverage.",
     }
 
+    signal_cells = ""
+    for label in signal_labels:
+        matched = label in c.matched_workflow_signals
+        tip = (
+            f"This repository matches the {label} workflow signal."
+            if matched
+            else f"This repository does not match the {label} workflow signal."
+        )
+        signal_cells += f'      <td class="text-center" data-tooltip="{e(tip)}">{_yesno(matched)}</td>\n'
+
     langs = entry.content.top_languages
     lang_cell = (
         " ".join(language_badge(lang) for lang in langs)
@@ -581,7 +612,7 @@ def _yesno(val: bool) -> str:
         f'      <td class="text-center" data-tooltip="{e(tips["pyproject"])}">{_presence(c.has_pyproject_toml, "\U0001f40d")}</td>\n'
         f'      <td class="text-center" data-tooltip="{e(tips["precommit"])}">{_presence(c.has_pre_commit_config, "\U0001fa9d")}</td>\n'
         f'      <td class="text-center" data-tooltip="{e(tips["ci"])}">{_presence(c.has_ci, "⚙️")}</td>\n'
-        f'      <td class="text-center" data-tooltip="{e(tips["daily"])}">{_yesno(c.uses_cicd_daily_workflow)}</td>\n'
+        f"{signal_cells}"
         f'      <td class="text-center" data-tooltip="{e(tips["coverage"])}">{_yesno(c.has_coverage_config)}</td>\n'
         f"    </tr>"
     )
@@ -603,10 +634,11 @@ def _format_type_name(key: str) -> str:
 
 def _render_traceability_section(
     repos: list[RepoEntry],
-    org_name: str,
+    snapshot: RepoSnapshot,
 ) -> str:
-    dac_repos = [r for r in repos if _is_docs_as_code_repo(r)]
-    if not dac_repos:
+    org_name = snapshot.org_name
+    dep_repos = [r for r in repos if is_tracked_dep_repo(r, snapshot.tracked_deps)]
+    if not dep_repos:
         return ""
 
     total_reqs = 0
@@ -616,7 +648,7 @@ def _render_traceability_section(
     loaded_count = 0
 
     row_parts: list[str] = []
-    for r in dac_repos:
+    for r in dep_repos:
         name_cell = repo_name_cell(r, org_name, bazel_icon=False)
         if not r.traceability:
             row_parts.append(
@@ -674,11 +706,11 @@ def _render_traceability_section(
         f'<div class="section hidden" data-tab="traceability">\n'
         f'  <div class="section-header">\n'
         f'    <span class="section-title">Requirement Traceability</span>\n'
-        f'    <span class="section-count">{len(dac_repos)}</span>\n'
+        f'    <span class="section-count">{len(dep_repos)}</span>\n'
         f"  </div>\n"
         f'  <div id="trace-summary">\n'
         f'    <div class="stat-grid">\n'
-        f'      <div class="stat-card"><div class="stat-value">{loaded_count} / {len(dac_repos)}</div><div class="stat-label">Repos Reporting</div></div>\n'
+        f'      <div class="stat-card"><div class="stat-value">{loaded_count} / {len(dep_repos)}</div><div class="stat-label">Repos Reporting</div></div>\n'
         f'      <div class="stat-card"><div class="stat-value">{total_reqs}</div><div class="stat-label">Total Requirements</div></div>\n'
         f'      <div class="stat-card"><div class="stat-value">{code_cov}</div><div class="stat-label">Code Link Coverage</div></div>\n'
         f'      <div class="stat-card"><div class="stat-value">{test_cov}</div><div class="stat-label">Test Link Coverage</div></div>\n'
diff --git a/src/generate_repo_overview/cli.py b/src/generate_repo_overview/cli.py
index 64e0cff..e3ca4c3 100644
--- a/src/generate_repo_overview/cli.py
+++ b/src/generate_repo_overview/cli.py
@@ -10,11 +10,11 @@
 from .constants import (
     DEFAULT_CACHE,
     DEFAULT_METRICS_HTML_OUTPUT,
-    DEFAULT_ORG,
     DEFAULT_OUTPUT,
     DEFAULT_TOKEN_ENV,
 )
 from .metrics_html import render_all_pages
+from .org_config import load_org_config
 from .profile_readme import load_config, load_template, render_readme
 
 if TYPE_CHECKING:
@@ -26,7 +26,7 @@
 CLI_EPILOG = dedent(
     f"""\
     Quick start:
-      uv run generate-repo-overview collect
+      uv run generate-repo-overview collect --org-config org_config.toml
           Sync the cached snapshot from GitHub.
 
       uv run generate-repo-overview render-overview
@@ -63,7 +63,10 @@ def build_parser() -> argparse.ArgumentParser:
         help="Collect and write the cached repository snapshot.",
     )
     collect_parser.add_argument(
-        "--org", default=DEFAULT_ORG, help="GitHub organization name"
+        "--org-config",
+        type=Path,
+        required=True,
+        help="Path to an org_config.toml file with organization-specific settings",
     )
     collect_parser.add_argument(
         "--cache", type=Path, default=DEFAULT_CACHE, help="JSON snapshot cache file"
@@ -145,8 +148,12 @@ def main(argv: Sequence[str] | None = None) -> int:
 
 
 def run_collect(args: argparse.Namespace) -> int:
+    try:
+        config = load_org_config(args.org_config)
+    except ValueError as exc:
+        raise SystemExit(str(exc)) from exc
     collect_snapshot(
-        org_name=args.org,
+        config=config,
         token_env=args.token_env,
         cache_path=args.cache,
         reuse_unchanged_repositories=not args.deep,
diff --git a/src/generate_repo_overview/collector/__init__.py b/src/generate_repo_overview/collector/__init__.py
index f704c2b..d91d156 100644
--- a/src/generate_repo_overview/collector/__init__.py
+++ b/src/generate_repo_overview/collector/__init__.py
@@ -13,7 +13,6 @@
 from generate_repo_overview.console import print_status
 from generate_repo_overview.constants import (
     DEFAULT_CACHE,
-    DEFAULT_ORG,
     DEFAULT_TOKEN_ENV,
 )
 from generate_repo_overview.models import (
@@ -22,6 +21,7 @@
     RepoEntry,
     RepoSnapshot,
 )
+from generate_repo_overview.org_config import OrgConfig
 
 from . import reference_integration, registry_metadata, repo_entry, traceability
 from .registry_metadata import RegistrySignalsPayload
@@ -96,7 +96,7 @@ def get_gh_auth_token() -> str | None:
 
 def ensure_snapshot(
     *,
-    org_name: str = DEFAULT_ORG,
+    config: OrgConfig,
     cache_path: Path = DEFAULT_CACHE,
     token_env: str = DEFAULT_TOKEN_ENV,
     refresh: bool = False,
@@ -112,7 +112,7 @@ def ensure_snapshot(
             return cached_snapshot
 
     return collect_snapshot(
-        org_name=org_name,
+        config=config,
         token_env=token_env,
         cache_path=cache_path,
         status_prefix=status_prefix,
@@ -121,12 +121,18 @@ def ensure_snapshot(
 
 def collect_snapshot(
     *,
-    org_name: str = DEFAULT_ORG,
+    config: OrgConfig,
     token_env: str = DEFAULT_TOKEN_ENV,
     cache_path: Path | None = DEFAULT_CACHE,
     reuse_unchanged_repositories: bool = False,
     status_prefix: str = "repo-overview",
 ) -> RepoSnapshot:
+    """Collect a fresh snapshot from GitHub, optionally reusing cached data.
+
+    Loads the existing snapshot from *cache_path* for incremental reuse.
+    Invalidates the content cache when workflow signal definitions in
+    *config* differ from the cached snapshot.
+    """
     try:
         from github import Auth, Github
     except ModuleNotFoundError as exc:
@@ -134,6 +140,8 @@ def collect_snapshot(
             "Missing PyGithub. Install project dependencies before running the generator."
         ) from exc
 
+    org_name = config.org_name
+
     token = resolve_github_token(token_env)
     if not token:
         message = f"Missing GitHub token. Set {token_env} or authenticate with `gh auth login`."
@@ -152,6 +160,17 @@ def collect_snapshot(
     )
     try:
         organization = github.get_organization(org_name)
+
+        registry_repository = None
+        if config.registry_repo:
+            try:
+                registry_repository = github.get_repo(config.registry_repo)
+            except Exception as exc:
+                print_status(
+                    f"Could not resolve registry repo {config.registry_repo}: {exc}",
+                    prefix=status_prefix,
+                )
+
         print_status("Collecting repository overview", prefix=status_prefix)
         repos = fetch_repositories(
             organization,
@@ -159,11 +178,14 @@ def collect_snapshot(
             reuse_unchanged_repositories=reuse_unchanged_repositories,
             github_token=token,
             status_prefix=status_prefix,
+            config=config,
+            registry_repository=registry_repository,
         )
 
         trace_by_repo = traceability.fetch_all_traceability_metrics(
             org_name,
             repos,
+            tracked_deps=config.tracked_deps,
             status_prefix=status_prefix,
         )
         if trace_by_repo:
@@ -179,6 +201,8 @@ def collect_snapshot(
             org_name=org_name,
             generated_at=datetime.now(UTC).isoformat(),
             repos=tuple(repos),
+            tracked_deps=config.tracked_deps,
+            workflow_signals=config.workflow_signals,
         )
         if cache_path is not None:
             write_snapshot(snapshot, cache_path)
@@ -236,9 +260,21 @@ def fetch_repositories(
     reuse_unchanged_repositories: bool = False,
     github_token: str | None = None,
     status_prefix: str = "repo-overview",
+    config: OrgConfig | None = None,
+    registry_repository: object | None = None,
 ) -> list[RepoEntry]:
+    """Fetch and collect all repository entries for an organization.
+
+    Resolves registry metadata, reference integration dependencies and
+    workflow signals, then dispatches parallel per-repo collection.
+    Reuses cached content signals when the default-branch SHA is unchanged
+    and workflow signal definitions have not changed since the cached snapshot.
+    """
+    if config is None:
+        config = OrgConfig(org_name=organization.login)
+
     print_status("Loading active repositories", prefix=status_prefix)
-    active_repositories = fetch_active_repositories(organization)
+    active_repositories = fetch_active_repositories(organization, config=config)
     print_status(
         f"Found {len(active_repositories)} active repositories",
         prefix=status_prefix,
@@ -257,51 +293,61 @@ def fetch_repositories(
         f"{repositories_with_custom_properties} repositories",
         prefix=status_prefix,
     )
-    print_status("Loading maintainers in bazel_registry", prefix=status_prefix)
-    bazel_registry_data = active_repositories.get("bazel_registry")
-    bazel_registry_metadata_by_repo = (
-        registry_metadata.fetch_bazel_registry_metadata_by_repo(
-            bazel_registry_repository=(
-                bazel_registry_data.repository
-                if bazel_registry_data is not None
-                else None
-            ),
-            active_repository_names=set(active_repositories),
-            github_token=github_token,
+
+    bazel_registry_metadata_by_repo: dict[str, registry_metadata.RegistrySignalsPayload] = {}
+    if config.registry_repo:
+        print_status(
+            f"Loading maintainers in {config.registry_repo}",
+            prefix=status_prefix,
         )
-    )
-    print_status(
-        "Loaded bazel_registry metadata for "
-        f"{len(bazel_registry_metadata_by_repo)} active repositories",
-        prefix=status_prefix,
-    )
-    print_status(
-        "Loading reference_integration Bazel dependencies",
-        prefix=status_prefix,
-    )
-    reference_integration_data = active_repositories.get("reference_integration")
-    reference_integration_repository_names = (
-        reference_integration.fetch_reference_integration_repository_names(
-            reference_integration_repository=(
-                reference_integration_data.repository
-                if reference_integration_data is not None
-                else None
-            ),
-            active_repository_names=set(active_repositories),
-            github_token=github_token,
+        bazel_registry_metadata_by_repo = (
+            registry_metadata.fetch_bazel_registry_metadata_by_repo(
+                bazel_registry_repository=registry_repository,
+                active_repository_names=set(active_repositories),
+                github_token=github_token,
+            )
+        )
+        print_status(
+            f"Loaded {config.registry_repo} metadata for "
+            f"{len(bazel_registry_metadata_by_repo)} active repositories",
+            prefix=status_prefix,
         )
-    )
-    print_status(
-        "Loaded reference_integration Bazel dependencies for "
-        f"{len(reference_integration_repository_names)} active repositories",
-        prefix=status_prefix,
-    )
 
-    cached_by_name = (
-        {repo.name: repo for repo in existing_snapshot.repos}
-        if existing_snapshot is not None
-        else {}
-    )
+    reference_integration_repository_names: set[str] = set()
+    if config.reference_integration_repo:
+        print_status(
+            f"Loading {config.reference_integration_repo} Bazel dependencies",
+            prefix=status_prefix,
+        )
+        ref_int_short_name = config.reference_integration_repo.rsplit("/", 1)[-1]
+        reference_integration_data = active_repositories.get(ref_int_short_name)
+        reference_integration_repository_names = (
+            reference_integration.fetch_reference_integration_repository_names(
+                reference_integration_repository=(
+                    reference_integration_data.repository
+                    if reference_integration_data is not None
+                    else None
+                ),
+                active_repository_names=set(active_repositories),
+                github_token=github_token,
+                org_name=config.org_name,
+            )
+        )
+        print_status(
+            f"Loaded {config.reference_integration_repo} Bazel dependencies for "
+            f"{len(reference_integration_repository_names)} active repositories",
+            prefix=status_prefix,
+        )
+
+    cached_by_name: dict[str, RepoEntry] = {}
+    if existing_snapshot is not None:
+        if config.workflow_signals == existing_snapshot.workflow_signals:
+            cached_by_name = {repo.name: repo for repo in existing_snapshot.repos}
+        else:
+            print_status(
+                "Workflow signal definitions changed — ignoring content cache",
+                prefix=status_prefix,
+            )
     sorted_repositories = sorted(
         active_repositories.items(),
         key=lambda item: item[0].casefold(),
@@ -347,6 +393,7 @@ def fetch_repositories(
                     repository_name in reference_integration_repository_names
                 ),
                 reuse_cached_entry_when_unchanged=reuse_unchanged_repositories,
+                workflow_signals=config.workflow_signals,
             )
             futures[future] = (index, repository_name)
 
@@ -373,10 +420,13 @@ def resolve_max_collection_workers() -> int:
 
 def fetch_active_repositories(
     organization: OrganizationLike,
+    *,
+    config: OrgConfig | None = None,
 ) -> dict[str, ActiveRepositoryData]:
     return fetch_active_repositories_via_rest(
         requester=organization.requester,
         org_login=organization.login,
+        config=config,
     )
 
 
@@ -384,6 +434,7 @@ def fetch_active_repositories_via_rest(
     *,
     requester: Any,
     org_login: str,
+    config: OrgConfig | None = None,
 ) -> dict[str, ActiveRepositoryData]:
     from github.Repository import Repository
 
@@ -405,6 +456,8 @@ def fetch_active_repositories_via_rest(
             "bool", getattr(repository, "archived", False)
         ):
             continue
+        if config is not None and not config.repo_matches_filter(repository_name):
+            continue
         active_repositories[repository_name] = ActiveRepositoryData(
             repository=repository,
             custom_properties=parse_repository_custom_properties(repository),
diff --git a/src/generate_repo_overview/collector/reference_integration.py b/src/generate_repo_overview/collector/reference_integration.py
index c952dcc..debe9f5 100644
--- a/src/generate_repo_overview/collector/reference_integration.py
+++ b/src/generate_repo_overview/collector/reference_integration.py
@@ -32,6 +32,7 @@ def fetch_reference_integration_repository_names(
     reference_integration_repository: object | None,
     active_repository_names: set[str],
     github_token: str | None,
+    org_name: str,
 ) -> set[str]:
     if reference_integration_repository is None:
         return set()
@@ -60,6 +61,7 @@ def fetch_reference_integration_repository_names(
     git_override_repositories = get_git_override_repositories_by_module(
         module_file_contents.values(),
         active_repository_names=active_repository_names,
+        org_name=org_name,
     )
     registry_repositories = get_bazel_registry_repositories_by_module(
         active_repository_names=active_repository_names,
@@ -173,6 +175,7 @@ def get_git_override_repositories_by_module(
     contents: Iterable[str],
     *,
     active_repository_names: set[str],
+    org_name: str,
 ) -> dict[str, str]:
     repositories_by_module: dict[str, str] = {}
     for content in contents:
@@ -180,6 +183,7 @@ def get_git_override_repositories_by_module(
             get_git_override_repositories_from_text(
                 content,
                 active_repository_names=active_repository_names,
+                org_name=org_name,
             )
         )
     return repositories_by_module
@@ -189,6 +193,7 @@ def get_git_override_repositories_from_text(
     text: str | None,
     *,
     active_repository_names: set[str],
+    org_name: str,
 ) -> dict[str, str]:
     if not text:
         return {}
@@ -201,7 +206,8 @@ def get_git_override_repositories_from_text(
         if module_name_match is None or remote_match is None:
             continue
         repository_name = parse_github_remote_repository_name(
-            remote_match.group("value")
+            remote_match.group("value"),
+            org_name=org_name,
         )
         if repository_name is None or repository_name not in active_repository_names:
             continue
@@ -211,7 +217,11 @@ def get_git_override_repositories_from_text(
     return repositories_by_module
 
 
-def parse_github_remote_repository_name(remote: str) -> str | None:
+def parse_github_remote_repository_name(
+    remote: str,
+    *,
+    org_name: str,
+) -> str | None:
     parsed = urlsplit(remote)
     if parsed.netloc != "github.com":
         return None
@@ -221,7 +231,7 @@ def parse_github_remote_repository_name(remote: str) -> str | None:
         return None
 
     owner, repository_name = path_parts
-    if owner != "eclipse-score":
+    if owner != org_name:
         return None
 
     return repository_name.removesuffix(".git") or None
diff --git a/src/generate_repo_overview/collector/repo_entry.py b/src/generate_repo_overview/collector/repo_entry.py
index 1b7a03f..1a0a2be 100644
--- a/src/generate_repo_overview/collector/repo_entry.py
+++ b/src/generate_repo_overview/collector/repo_entry.py
@@ -13,6 +13,7 @@
     RegistrySignals,
     RepoEntry,
     VolatileMetricsSnapshot,
+    WorkflowSignal,
 )
 
 from .signal_detection import (
@@ -69,15 +70,8 @@ def collect_repository_entry(
     cached_entry: RepoEntry | None,
     referenced_by_reference_integration: bool = False,
     reuse_cached_entry_when_unchanged: bool = False,
+    workflow_signals: tuple[WorkflowSignal, ...] = (),
 ) -> RepoEntry:
-    """Collect one repository entry using explicit fast/slow collection paths.
-
-    Fast path: when cache reuse is enabled and default-branch state is unchanged,
-    reuse cached content indicators and optionally cached volatile metrics.
-
-    Slow path: when cache reuse is impossible (or disabled), inspect repository
-    content and refresh volatile metrics from live API calls.
-    """
     fast_entry = maybe_collect_repository_entry_fast_path(
         repository_name=repository_name,
         repository=repository,
@@ -97,6 +91,7 @@ def collect_repository_entry(
         bazel_registry_metadata=bazel_registry_metadata,
         referenced_by_reference_integration=referenced_by_reference_integration,
         cached_entry=cached_entry,
+        workflow_signals=workflow_signals,
     )
 
 
@@ -179,8 +174,13 @@ def collect_repository_entry_slow_path(
     bazel_registry_metadata: RegistrySignalsPayload | None,
     referenced_by_reference_integration: bool,
     cached_entry: RepoEntry | None,
+    workflow_signals: tuple[WorkflowSignal, ...] = (),
 ) -> RepoEntry:
-    """Collect using slow path logic (deep content inspection when cache can't prove reuse)."""
+    """Collect a repository entry with deep content inspection.
+
+    Reuses cached content signals when the default-branch SHA matches the
+    cached entry.  Always refreshes volatile metrics and registry signals.
+    """
     default_branch = cast("str | None", getattr(repository, "default_branch", None))
     default_branch_sha = get_default_branch_sha(repository, default_branch)
 
@@ -194,6 +194,7 @@ def collect_repository_entry_slow_path(
         content_signals = inspect_repository_content_slow(
             repository,
             ref=default_branch_sha,
+            workflow_signals=workflow_signals,
         )
     else:
         content_signals = cached_content_signals
@@ -304,7 +305,6 @@ def cached_signals_for_repository(
         "is_bazel_repo": cached_entry.content.is_bazel_repo,
         "bazel_version": cached_entry.content.bazel_version,
         "codeowners": cached_entry.content.codeowners,
-        "docs_as_code_version": cached_entry.content.docs_as_code_version,
         "referenced_by_reference_integration": (
             cached_entry.content.referenced_by_reference_integration
         ),
@@ -313,7 +313,7 @@ def cached_signals_for_repository(
         "has_pyproject_toml": cached_entry.content.has_pyproject_toml,
         "has_pre_commit_config": cached_entry.content.has_pre_commit_config,
         "has_ci": cached_entry.content.has_ci,
-        "uses_cicd_daily_workflow": cached_entry.content.uses_cicd_daily_workflow,
+        "matched_workflow_signals": cached_entry.content.matched_workflow_signals,
         "has_coverage_config": cached_entry.content.has_coverage_config,
         "top_languages": cached_entry.content.top_languages,
         "bazel_deps": cached_entry.content.bazel_deps,
@@ -408,7 +408,6 @@ def build_repo_entry(
             is_bazel_repo=content_signals["is_bazel_repo"],
             bazel_version=content_signals["bazel_version"],
             codeowners=content_signals["codeowners"],
-            docs_as_code_version=content_signals["docs_as_code_version"],
             referenced_by_reference_integration=bool(
                 content_signals.get("referenced_by_reference_integration", False)
             ),
@@ -419,7 +418,7 @@ def build_repo_entry(
                 content_signals.get("has_pre_commit_config", False)
             ),
             has_ci=content_signals["has_ci"],
-            uses_cicd_daily_workflow=content_signals["uses_cicd_daily_workflow"],
+            matched_workflow_signals=content_signals["matched_workflow_signals"],
             has_coverage_config=content_signals["has_coverage_config"],
             top_languages=content_signals.get("top_languages", ()),
             bazel_deps=content_signals.get("bazel_deps", ()),
diff --git a/src/generate_repo_overview/collector/signal_detection.py b/src/generate_repo_overview/collector/signal_detection.py
index 8d838e3..274d3d8 100644
--- a/src/generate_repo_overview/collector/signal_detection.py
+++ b/src/generate_repo_overview/collector/signal_detection.py
@@ -2,21 +2,23 @@
 
 import fnmatch
 import re
-from typing import Any, TypedDict
+from typing import TYPE_CHECKING, Any, TypedDict
+
+if TYPE_CHECKING:
+    from generate_repo_overview.models import WorkflowSignal
 
 
 class DeepContentPayload(TypedDict):
     is_bazel_repo: bool
     bazel_version: str | None
     codeowners: tuple[str, ...]
-    docs_as_code_version: str | None
     referenced_by_reference_integration: bool
     has_gitlint_config: bool
     has_pyproject_toml: bool
     has_pre_commit_config: bool
     has_lint_config: bool
     has_ci: bool
-    uses_cicd_daily_workflow: bool
+    matched_workflow_signals: tuple[str, ...]
     has_coverage_config: bool
     top_languages: tuple[str, ...]
     bazel_deps: tuple[tuple[str, str], ...]
@@ -41,10 +43,6 @@ class DeepContentPayload(TypedDict):
 CODEOWNERS_PATH = ".github/CODEOWNERS"
 WORKFLOW_PATH_PREFIX = ".github/workflows/"
 WORKFLOW_FILE_SUFFIXES = (".yml", ".yaml")
-DAILY_WORKFLOW_REFERENCE = "cicd-workflows/.github/workflows/daily.yml@"
-BAZEL_DEP_PATTERN_TEMPLATE = (
-    r'\bbazel_dep\s*\(\s*name\s*=\s*"{module_name}"(?P<body>.*?)\)'
-)
 VERSION_PATTERN = re.compile(r'\bversion\s*=\s*"(?P<version>[^"]+)"')
 
 
@@ -52,8 +50,8 @@ def inspect_repository_content_slow(
     repository: Any,
     *,
     ref: str | None,
+    workflow_signals: tuple[WorkflowSignal, ...] = (),
 ) -> DeepContentPayload:
-    """Run slow deep content inspection using repository tree and file reads."""
     tree_paths = fetch_repository_tree_paths(repository, ref=ref)
     if not tree_paths:
         return default_content_signals()
@@ -70,12 +68,6 @@ def inspect_repository_content_slow(
             tree_paths=tree_paths,
             ref=ref,
         ),
-        "docs_as_code_version": detect_dependency_version(
-            repository,
-            tree_paths=tree_paths,
-            ref=ref,
-            module_name="score_docs_as_code",
-        ),
         "bazel_deps": detect_all_bazel_deps(
             repository,
             tree_paths=tree_paths,
@@ -95,10 +87,11 @@ def inspect_repository_content_slow(
             tree_contains_path(tree_paths, path) for path in LINT_CONFIG_PATHS
         ),
         "has_ci": any(tree_contains_path(tree_paths, path) for path in CI_PATHS),
-        "uses_cicd_daily_workflow": uses_cicd_daily_workflow(
+        "matched_workflow_signals": detect_matched_workflow_signals(
             repository,
             tree_paths=tree_paths,
             ref=ref,
+            workflow_signals=workflow_signals,
         ),
         "has_coverage_config": any(
             tree_contains_path(tree_paths, path) for path in COVERAGE_PATHS
@@ -112,7 +105,6 @@ def default_content_signals() -> DeepContentPayload:
         "is_bazel_repo": False,
         "bazel_version": None,
         "codeowners": (),
-        "docs_as_code_version": None,
         "bazel_deps": (),
         "referenced_by_reference_integration": False,
         "has_gitlint_config": False,
@@ -120,7 +112,7 @@ def default_content_signals() -> DeepContentPayload:
         "has_pre_commit_config": False,
         "has_lint_config": False,
         "has_ci": False,
-        "uses_cicd_daily_workflow": False,
+        "matched_workflow_signals": (),
         "has_coverage_config": False,
         "top_languages": (),
     }
@@ -188,24 +180,6 @@ def detect_is_bazel_repo(tree_paths: set[str]) -> bool:
     )
 
 
-def detect_dependency_version(
-    repository: Any,
-    *,
-    tree_paths: set[str],
-    ref: str | None,
-    module_name: str,
-) -> str | None:
-    for candidate in MODULE_PATHS:
-        if not tree_contains_path(tree_paths, candidate):
-            continue
-        content = fetch_text_file(repository, candidate, ref=ref)
-        version = get_bazel_dep_version(content, module_name=module_name)
-        if version:
-            return version
-
-    return None
-
-
 def detect_all_bazel_deps(
     repository: Any,
     *,
@@ -275,7 +249,6 @@ def codeowners_pattern_matches(pattern: str, *, target_path: str) -> bool:
         )
 
     if "/" not in normalized_pattern:
-        # Bare patterns can match either the basename or the full path, mirroring CODEOWNERS behavior.
         return fnmatch.fnmatch(
             normalized_target_path.rsplit("/", maxsplit=1)[-1],
             normalized_pattern,
@@ -284,26 +257,6 @@ def codeowners_pattern_matches(pattern: str, *, target_path: str) -> bool:
     return fnmatch.fnmatch(normalized_target_path, normalized_pattern)
 
 
-def get_bazel_dep_version(text: str | None, *, module_name: str) -> str | None:
-    if not text:
-        return None
-
-    pattern = re.compile(
-        BAZEL_DEP_PATTERN_TEMPLATE.format(module_name=re.escape(module_name)),
-        re.DOTALL,
-    )
-    match = pattern.search(text)
-    if match is None:
-        return None
-
-    version_match = VERSION_PATTERN.search(match.group("body"))
-    if version_match is None:
-        return None
-
-    version = version_match.group("version").strip()
-    return version or None
-
-
 def get_all_bazel_dep_versions(text: str | None) -> tuple[tuple[str, str], ...]:
     if not text:
         return ()
@@ -328,12 +281,18 @@ def get_all_bazel_dep_versions(text: str | None) -> tuple[tuple[str, str], ...]:
     return tuple(sorted(result, key=lambda x: x[0]))
 
 
-def uses_cicd_daily_workflow(
+def detect_matched_workflow_signals(
     repository: Any,
     *,
     tree_paths: set[str],
     ref: str | None,
-) -> bool:
+    workflow_signals: tuple[WorkflowSignal, ...] = (),
+) -> tuple[str, ...]:
+    """Return labels of workflow signals whose reference string appears in any workflow file."""
+    if not workflow_signals:
+        return ()
+
+    workflow_contents: list[str] = []
     workflow_paths = sorted(
         path
         for path in tree_paths
@@ -342,11 +301,17 @@ def uses_cicd_daily_workflow(
     )
     for workflow_path in workflow_paths:
         content = fetch_text_file(repository, workflow_path, ref=ref)
-        if content is None:
-            continue
-        if DAILY_WORKFLOW_REFERENCE in content:
-            return True
-    return False
+        if content is not None:
+            workflow_contents.append(content)
+
+    if not workflow_contents:
+        return ()
+
+    matched: list[str] = []
+    for signal in workflow_signals:
+        if any(signal.reference in content for content in workflow_contents):
+            matched.append(signal.label)
+    return tuple(matched)
 
 
 def fetch_text_file(repository: Any, path: str, *, ref: str | None) -> str | None:
diff --git a/src/generate_repo_overview/collector/traceability.py b/src/generate_repo_overview/collector/traceability.py
index 54cd5b7..ed9f828 100644
--- a/src/generate_repo_overview/collector/traceability.py
+++ b/src/generate_repo_overview/collector/traceability.py
@@ -6,17 +6,16 @@
 from typing import TYPE_CHECKING, Any, cast
 
 from generate_repo_overview.console import print_status
-from generate_repo_overview.models import TraceabilityTypeMetrics
+from generate_repo_overview.models import (
+    TraceabilityTypeMetrics,
+    TrackedDep,
+    is_tracked_dep_repo,
+)
 
 if TYPE_CHECKING:
     from generate_repo_overview.models import RepoEntry
 
 _METRICS_TIMEOUT_SECONDS = 10
-_DAC_REPO_NAME = "docs-as-code"
-
-
-def is_docs_as_code_repo(entry: RepoEntry) -> bool:
-    return bool(entry.content.docs_as_code_version) or entry.name == _DAC_REPO_NAME
 
 
 def fetch_traceability_metrics(
@@ -24,7 +23,7 @@ def fetch_traceability_metrics(
     repo_name: str,
 ) -> tuple[TraceabilityTypeMetrics, ...]:
     base = f"https://{org_name}.github.io/{repo_name}"
-    for path in ("main/metrics.json", "pr-484/metrics.json"):
+    for path in ("main/metrics.json",):
         try:
             with urllib.request.urlopen(
                 f"{base}/{path}", timeout=_METRICS_TIMEOUT_SECONDS
@@ -75,22 +74,23 @@ def fetch_all_traceability_metrics(
     org_name: str,
     repos: list[RepoEntry],
     *,
+    tracked_deps: tuple[TrackedDep, ...] = (),
     status_prefix: str = "repo-overview",
 ) -> dict[str, tuple[TraceabilityTypeMetrics, ...]]:
-    dac_repos = [r for r in repos if is_docs_as_code_repo(r)]
-    if not dac_repos:
+    eligible_repos = [r for r in repos if is_tracked_dep_repo(r, tracked_deps)]
+    if not eligible_repos:
         return {}
 
     print_status(
-        f"Fetching traceability metrics for {len(dac_repos)} docs-as-code repositories",
+        f"Fetching traceability metrics for {len(eligible_repos)} tracked-dep repositories",
         prefix=status_prefix,
     )
 
     results: dict[str, tuple[TraceabilityTypeMetrics, ...]] = {}
-    with ThreadPoolExecutor(max_workers=min(8, len(dac_repos))) as executor:
+    with ThreadPoolExecutor(max_workers=min(8, len(eligible_repos))) as executor:
         futures = {
             executor.submit(fetch_traceability_metrics, org_name, r.name): r.name
-            for r in dac_repos
+            for r in eligible_repos
         }
         for future in as_completed(futures):
             repo_name = futures[future]
@@ -98,7 +98,7 @@ def fetch_all_traceability_metrics(
 
     loaded = sum(1 for v in results.values() if v)
     print_status(
-        f"Loaded traceability metrics for {loaded}/{len(dac_repos)} repositories",
+        f"Loaded traceability metrics for {loaded}/{len(eligible_repos)} repositories",
         prefix=status_prefix,
     )
     return results
diff --git a/src/generate_repo_overview/constants.py b/src/generate_repo_overview/constants.py
index b3b3e34..0d00687 100644
--- a/src/generate_repo_overview/constants.py
+++ b/src/generate_repo_overview/constants.py
@@ -2,7 +2,6 @@
 
 from pathlib import Path
 
-DEFAULT_ORG = "eclipse-score"
 DEFAULT_OUTPUT = Path("profile/README.md")
 DEFAULT_METRICS_HTML_OUTPUT = Path("_site")
 DEFAULT_CACHE = Path("profile/cache/repo_overview.json")
diff --git a/src/generate_repo_overview/metrics_html.py b/src/generate_repo_overview/metrics_html.py
index 132d903..92ba8d5 100644
--- a/src/generate_repo_overview/metrics_html.py
+++ b/src/generate_repo_overview/metrics_html.py
@@ -5,7 +5,7 @@
 
 from ._html_detail import render_detail_page
 from ._html_index import render_index_page
-from .metrics_report import get_latest_docs_as_code_release, get_max_bazel_version
+from .metrics_report import get_latest_tracked_dep_version, get_max_bazel_version
 
 if TYPE_CHECKING:
     from .models import RepoSnapshot
@@ -14,7 +14,10 @@
 def render_all_pages(snapshot: RepoSnapshot) -> dict[str, str]:
     repos = sorted(snapshot.repos, key=lambda r: r.name.casefold())
     max_bazel = get_max_bazel_version(list(repos))
-    latest_dac = get_latest_docs_as_code_release(list(repos))
+    latest_dep_versions = {
+        dep.module_name: get_latest_tracked_dep_version(list(repos), dep)
+        for dep in snapshot.tracked_deps
+    }
 
     pages: dict[str, str] = {
         "index.html": render_index_page(snapshot),
@@ -22,6 +25,6 @@ def render_all_pages(snapshot: RepoSnapshot) -> dict[str, str]:
     }
     for entry in repos:
         pages[f"{entry.name}/index.html"] = render_detail_page(
-            entry, snapshot.org_name, snapshot, max_bazel, latest_dac
+            entry, snapshot, max_bazel, latest_dep_versions
         )
     return pages
diff --git a/src/generate_repo_overview/metrics_report.py b/src/generate_repo_overview/metrics_report.py
index 57256ff..a7f798f 100644
--- a/src/generate_repo_overview/metrics_report.py
+++ b/src/generate_repo_overview/metrics_report.py
@@ -8,7 +8,7 @@
 if TYPE_CHECKING:
     from collections.abc import Callable
 
-    from .models import RepoEntry, RepoSnapshot
+    from .models import RepoEntry, RepoSnapshot, TrackedDep
 
 
 HANDLE_PATTERN = re.compile(r"@[A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)?")
@@ -32,8 +32,8 @@ def render_metrics_report(snapshot: RepoSnapshot) -> str:
         "",
     ]
     lines.extend(render_overview_section(repos, org_name=snapshot.org_name))
-    lines.extend(render_versions_section(repos, org_name=snapshot.org_name))
-    lines.extend(render_automation_section(repos, org_name=snapshot.org_name))
+    lines.extend(render_versions_section(repos, snapshot=snapshot))
+    lines.extend(render_automation_section(repos, snapshot=snapshot))
     return "\n".join(lines).rstrip() + "\n"
 
 
@@ -41,7 +41,7 @@ def render_summary(repos: list[RepoEntry]) -> list[str]:
     return [
         f"- Repositories: {len(repos)}",
         f"- With GitHub Actions: {sum(repo.content.has_ci for repo in repos)}",
-        f"- Using daily workflow: {sum(repo.content.uses_cicd_daily_workflow for repo in repos)}",
+        f"- With workflow signals: {sum(bool(repo.content.matched_workflow_signals) for repo in repos)}",
         f"- With lint/style config: {sum(repo.content.has_lint_config for repo in repos)}",
         f"- With coverage config: {sum(repo.content.has_coverage_config for repo in repos)}",
         f"- With releases: {sum(has_latest_release(repo) for repo in repos)}",
@@ -74,41 +74,99 @@ def render_overview_section(repos: list[RepoEntry], org_name: str) -> list[str]:
     return lines
 
 
-def render_versions_section(repos: list[RepoEntry], org_name: str) -> list[str]:
-    latest_docs_as_code_release = get_latest_docs_as_code_release(repos)
+def render_versions_section(repos: list[RepoEntry], *, snapshot: RepoSnapshot) -> list[str]:
+    """Render the Versions table with one column per tracked dep plus Bazel and Ref-Int."""
+    from .models import lookup_bazel_dep_version
+
+    tracked_deps = snapshot.tracked_deps
     max_bazel_version = get_max_bazel_version(repos)
+    latest_dep_versions = {
+        dep.module_name: get_latest_tracked_dep_version(repos, dep)
+        for dep in tracked_deps
+    }
+
+    dep_labels = [tracked_dep_label(dep) for dep in tracked_deps]
 
     def render_row(entry: RepoEntry, *, org_name: str) -> str:
-        return render_versions_row(
-            entry,
-            org_name=org_name,
-            max_bazel_version=max_bazel_version,
-            latest_docs_as_code_release=latest_docs_as_code_release,
+        url = f"https://github.com/{org_name}/{entry.name}"
+        bazel_cell = render_bazel_version_status(entry.content.bazel_version, max_bazel_version)
+        dep_cells = " | ".join(
+            render_dep_version_status(
+                lookup_bazel_dep_version(entry.content.bazel_deps, dep.module_name),
+                latest_dep_versions.get(dep.module_name),
+            )
+            for dep in tracked_deps
         )
+        refint = render_bool(entry.content.referenced_by_reference_integration)
+        parts = f"| [{entry.name}]({url}) | {bazel_cell} |"
+        if dep_cells:
+            parts += f" {dep_cells} |"
+        return f"{parts} {refint} |"
+
+    dep_headers = " | ".join(f"{label} Version" for label in dep_labels)
+    dep_dividers = " | ".join("---" for _ in dep_labels)
+    header = f"| Repository | {render_bazel_version_column_header()} |"
+    divider = "|------------|---------------|"
+    if dep_headers:
+        header += f" {dep_headers} |"
+        divider += f" {dep_dividers} |"
+    header += " Reference Integration |"
+    divider += " ----------------------|"
 
     lines = [
         "## Versions",
         "",
         "- Generic view of repository version signals.",
-        '- `Docs-As-Code Version`: `version = "..."` for `bazel_dep(name = "score_docs_as_code", ...)` in the repository root `MODULE.bazel`.',
-        "- `Reference Integration`: `yes` when the repository is a direct `bazel_dep(...)` in `reference_integration`'s root `MODULE.bazel` or included module files.",
+        "- `Reference Integration`: `yes` when the repository is a direct `bazel_dep(...)` in the reference integration's root `MODULE.bazel` or included module files.",
         "- `Bazel Version`: highest version in the table is `🟢`; every other value is `🔴`.",
-        "- `Docs-As-Code Version`: `⚪` if missing, `🟢` if equal to latest docs-as-code release, `🟡` if same major.minor, else `🔴`.",
-        "",
     ]
+    for label in dep_labels:
+        lines.append(
+            f"- `{label} Version`: `⚪` if missing, `🟢` if equal to latest release, `🟡` if same major.minor, else `🔴`."
+        )
+    lines.append("")
     lines.extend(
         render_category_tables(
             repos,
-            org_name=org_name,
-            header=f"| Repository | {render_bazel_version_column_header()} | Docs-As-Code Version | Reference Integration |",
-            divider="|------------|---------------|----------------------|-----------------------|",
+            org_name=snapshot.org_name,
+            header=header,
+            divider=divider,
             row_renderer=render_row,
         )
     )
     return lines
 
 
-def render_automation_section(repos: list[RepoEntry], org_name: str) -> list[str]:
+def render_automation_section(repos: list[RepoEntry], *, snapshot: RepoSnapshot) -> list[str]:
+    """Render the Automation table with one column per workflow signal."""
+    signal_labels = tuple(s.label for s in snapshot.workflow_signals)
+
+    def render_row(entry: RepoEntry, *, org_name: str) -> str:
+        url = f"https://github.com/{org_name}/{entry.name}"
+        signal_cells = " | ".join(
+            render_bool(label in entry.content.matched_workflow_signals)
+            for label in signal_labels
+        )
+        parts = (
+            f"| [{entry.name}]({url}) | {render_presence(entry.content.has_gitlint_config, icon='🔍')} | "
+            f"{render_presence(entry.content.has_pyproject_toml, icon='🐍')} | "
+            f"{render_presence(entry.content.has_pre_commit_config, icon='🪝')} | "
+            f"{render_presence(entry.content.has_ci, icon='⚙')} |"
+        )
+        if signal_cells:
+            parts += f" {signal_cells} |"
+        return f"{parts} {render_bool(entry.content.has_coverage_config)} |"
+
+    signal_headers = " | ".join(signal_labels)
+    signal_dividers = " | ".join("---" for _ in signal_labels)
+    header = "| Repository | 🔍 Gitlint | 🐍 Pyproject | 🪝 Pre-commit | ⚙ GitHub Actions |"
+    divider = "|------------|------------|-------------|---------------|------------------|"
+    if signal_headers:
+        header += f" {signal_headers} |"
+        divider += f" {signal_dividers} |"
+    header += " Coverage Config |"
+    divider += " ---------------|"
+
     lines = [
         "## Delivery And Automation",
         "",
@@ -116,17 +174,20 @@ def render_automation_section(repos: list[RepoEntry], org_name: str) -> list[str
         "- `🐍 Pyproject`: shown when `pyproject.toml` exists.",
         "- `🪝 Pre-commit`: shown when `.pre-commit-config.yaml` exists.",
         "- `⚙ GitHub Actions`: shown when `.github/workflows` exists.",
-        "- `Daily Workflow`: `yes` if any workflow file references `cicd-workflows/.github/workflows/daily.yml@...`.",
+    ]
+    for label in signal_labels:
+        lines.append(f"- `{label}`: `yes` if a matching workflow reference is detected.")
+    lines.extend([
         "- `Coverage Config`: `yes` if `coverage.yml`, `coverage.xml`, `pytest.ini`, or `.coveragerc` exists.",
         "",
-    ]
+    ])
     lines.extend(
         render_category_tables(
             repos,
-            org_name=org_name,
-            header="| Repository | 🔍 Gitlint | 🐍 Pyproject | 🪝 Pre-commit | ⚙ GitHub Actions | Daily Workflow | Coverage Config |",
-            divider="|------------|------------|-------------|---------------|------------------|----------------|-----------------|",
-            row_renderer=render_automation_row,
+            org_name=snapshot.org_name,
+            header=header,
+            divider=divider,
+            row_renderer=render_row,
         )
     )
     return lines
@@ -207,32 +268,6 @@ def render_release_and_commits(
     return f"{latest_release} + {commits}"
 
 
-def render_versions_row(
-    entry: RepoEntry,
-    *,
-    org_name: str,
-    max_bazel_version: tuple[int, ...] | None,
-    latest_docs_as_code_release: str | None,
-) -> str:
-    url = f"https://github.com/{org_name}/{entry.name}"
-    return (
-        f"| [{entry.name}]({url}) | {render_bazel_version_status(entry.content.bazel_version, max_bazel_version)} | "
-        f"{render_docs_as_code_version_status(entry.content.docs_as_code_version, latest_docs_as_code_release)} | "
-        f"{render_bool(entry.content.referenced_by_reference_integration)} |"
-    )
-
-
-def render_automation_row(entry: RepoEntry, *, org_name: str) -> str:
-    url = f"https://github.com/{org_name}/{entry.name}"
-    return (
-        f"| [{entry.name}]({url}) | {render_presence(entry.content.has_gitlint_config, icon='🔍')} | "
-        f"{render_presence(entry.content.has_pyproject_toml, icon='🐍')} | "
-        f"{render_presence(entry.content.has_pre_commit_config, icon='🪝')} | "
-        f"{render_presence(entry.content.has_ci, icon='⚙')} | "
-        f"{render_bool(entry.content.uses_cicd_daily_workflow)} | "
-        f"{render_bool(entry.content.has_coverage_config)} |"
-    )
-
 
 def render_bool(value: bool) -> str:
     return "yes" if value else "no"
@@ -337,16 +372,19 @@ def get_max_bazel_version(repos: list[RepoEntry]) -> tuple[int, ...] | None:
     return max(keys) if keys else None
 
 
-def get_latest_docs_as_code_release(repos: list[RepoEntry]) -> str | None:
+def get_latest_tracked_dep_version(repos: list[RepoEntry], dep: TrackedDep) -> str | None:
+    repo_short_name = dep.repo.rsplit("/", 1)[-1]
     for repo in repos:
-        if repo.name.casefold() != "docs-as-code":
-            continue
-        if repo.volatile.latest_release_version is None:
-            return None
-        return repo.volatile.latest_release_version.removeprefix("v").strip() or None
+        if repo.name == repo_short_name:
+            v = repo.volatile.latest_release_version
+            return v.removeprefix("v").strip() if v else None
     return None
 
 
+def tracked_dep_label(dep: TrackedDep) -> str:
+    return dep.repo.rsplit("/", 1)[-1].replace("-", " ").replace("_", " ").title()
+
+
 def render_bazel_version_status(
     bazel_version: str | None,
     max_bazel_version: tuple[int, ...] | None,
@@ -372,18 +410,18 @@ def major_minor(version: str) -> tuple[int, int] | None:
     return (parsed[0], parsed[1])
 
 
-def render_docs_as_code_version_status(
-    docs_as_code_version: str | None,
-    latest_docs_as_code_release: str | None,
+def render_dep_version_status(
+    dep_version: str | None,
+    latest_version: str | None,
 ) -> str:
-    if docs_as_code_version is None or not docs_as_code_version.strip():
+    if dep_version is None or not dep_version.strip():
         return "⚪ -"
 
-    cleaned = docs_as_code_version.strip()
-    if latest_docs_as_code_release is None:
+    cleaned = dep_version.strip()
+    if latest_version is None:
         return f"⚪ {escape_markdown_table_cell(cleaned)}"
 
-    latest_cleaned = latest_docs_as_code_release.strip()
+    latest_cleaned = latest_version.strip()
     if cleaned == latest_cleaned:
         return f"🟢 {escape_markdown_table_cell(cleaned)}"
 
diff --git a/src/generate_repo_overview/models.py b/src/generate_repo_overview/models.py
index f5a7dab..155754c 100644
--- a/src/generate_repo_overview/models.py
+++ b/src/generate_repo_overview/models.py
@@ -8,7 +8,43 @@
 
 DEFAULT_CATEGORY = "Uncategorized"
 DEFAULT_SUBCATEGORY = "General"
-SNAPSHOT_SCHEMA_VERSION = 15
+SNAPSHOT_SCHEMA_VERSION = 18
+
+
+@dataclass(frozen=True, slots=True)
+class TrackedDep:
+    """A Bazel dependency tracked across all repositories."""
+
+    repo: str
+    module_name: str
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> TrackedDep:
+        return cls(
+            repo=cast("str", data.get("repo", "")),
+            module_name=cast("str", data.get("module_name", "")),
+        )
+
+    def to_dict(self) -> dict[str, str]:
+        return {"repo": self.repo, "module_name": self.module_name}
+
+
+@dataclass(frozen=True, slots=True)
+class WorkflowSignal:
+    """A named workflow signal with a reference string to match."""
+
+    label: str
+    reference: str
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> WorkflowSignal:
+        return cls(
+            label=cast("str", data.get("label", "")),
+            reference=cast("str", data.get("reference", "")),
+        )
+
+    def to_dict(self) -> dict[str, str]:
+        return {"label": self.label, "reference": self.reference}
 
 
 @dataclass(frozen=True, slots=True)
@@ -18,14 +54,13 @@ class DeepContentSignals:
     is_bazel_repo: bool = False
     bazel_version: str | None = None
     codeowners: tuple[str, ...] = ()
-    docs_as_code_version: str | None = None
     referenced_by_reference_integration: bool = False
     has_lint_config: bool = False
     has_gitlint_config: bool = False
     has_pyproject_toml: bool = False
     has_pre_commit_config: bool = False
     has_ci: bool = False
-    uses_cicd_daily_workflow: bool = False
+    matched_workflow_signals: tuple[str, ...] = ()
     has_coverage_config: bool = False
     top_languages: tuple[str, ...] = ()
     bazel_deps: tuple[tuple[str, str], ...] = ()
@@ -36,7 +71,6 @@ def from_dict(cls, data: Mapping[str, Any]) -> DeepContentSignals:
             is_bazel_repo=bool(data.get("is_bazel_repo", False)),
             bazel_version=cast("str | None", data.get("bazel_version")),
             codeowners=normalize_string_tuple(data.get("codeowners")),
-            docs_as_code_version=cast("str | None", data.get("docs_as_code_version")),
             referenced_by_reference_integration=bool(
                 data.get("referenced_by_reference_integration", False)
             ),
@@ -45,7 +79,9 @@ def from_dict(cls, data: Mapping[str, Any]) -> DeepContentSignals:
             has_pyproject_toml=bool(data.get("has_pyproject_toml", False)),
             has_pre_commit_config=bool(data.get("has_pre_commit_config", False)),
             has_ci=bool(data.get("has_ci", False)),
-            uses_cicd_daily_workflow=bool(data.get("uses_cicd_daily_workflow", False)),
+            matched_workflow_signals=normalize_string_tuple(
+                data.get("matched_workflow_signals")
+            ),
             has_coverage_config=bool(data.get("has_coverage_config", False)),
             top_languages=normalize_string_tuple(data.get("top_languages")),
             bazel_deps=normalize_string_pairs(data.get("bazel_deps")),
@@ -223,6 +259,8 @@ class RepoSnapshot:
     org_name: str
     generated_at: str
     repos: tuple[RepoEntry, ...]
+    tracked_deps: tuple[TrackedDep, ...] = ()
+    workflow_signals: tuple[WorkflowSignal, ...] = ()
 
     @classmethod
     def from_dict(cls, data: Mapping[str, Any]) -> RepoSnapshot:
@@ -248,11 +286,28 @@ def from_dict(cls, data: Mapping[str, Any]) -> RepoSnapshot:
 
         typed_repos_data = cast("list[Mapping[str, Any]]", repos_data)
 
+        tracked_deps = tuple(
+            TrackedDep.from_dict(cast("Mapping[str, Any]", item))
+            for item in (data.get("tracked_deps") or ())
+            if isinstance(item, dict)
+            and isinstance(item.get("repo"), str) and item["repo"]
+            and isinstance(item.get("module_name"), str) and item["module_name"]
+        )
+        workflow_signals = tuple(
+            WorkflowSignal.from_dict(cast("Mapping[str, Any]", item))
+            for item in (data.get("workflow_signals") or ())
+            if isinstance(item, dict)
+            and isinstance(item.get("label"), str) and item["label"]
+            and isinstance(item.get("reference"), str) and item["reference"]
+        )
+
         return cls(
             schema_version=cast("int", schema_version),
             org_name=org_name,
             generated_at=generated_at,
             repos=tuple(RepoEntry.from_dict(repo) for repo in typed_repos_data),
+            tracked_deps=tracked_deps,
+            workflow_signals=workflow_signals,
         )
 
     def to_dict(self) -> dict[str, Any]:
@@ -261,6 +316,8 @@ def to_dict(self) -> dict[str, Any]:
             "org_name": self.org_name,
             "generated_at": self.generated_at,
             "repos": [repo.to_dict() for repo in self.repos],
+            "tracked_deps": [dep.to_dict() for dep in self.tracked_deps],
+            "workflow_signals": [s.to_dict() for s in self.workflow_signals],
         }
 
 
@@ -289,3 +346,24 @@ def normalize_string_tuple(value: object) -> tuple[str, ...]:
         sequence_items = cast("list[object]", value)
         return tuple(item for item in sequence_items if isinstance(item, str))
     return ()
+
+
+def lookup_bazel_dep_version(
+    bazel_deps: tuple[tuple[str, str], ...],
+    dep_name: str,
+) -> str | None:
+    for name, version in bazel_deps:
+        if name == dep_name:
+            return version
+    return None
+
+
+def is_tracked_dep_repo(
+    entry: RepoEntry,
+    tracked_deps: tuple[TrackedDep, ...],
+) -> bool:
+    return any(
+        lookup_bazel_dep_version(entry.content.bazel_deps, dep.module_name) is not None
+        or entry.name == dep.repo.rsplit("/", 1)[-1]
+        for dep in tracked_deps
+    )
diff --git a/src/generate_repo_overview/org_config.py b/src/generate_repo_overview/org_config.py
new file mode 100644
index 0000000..fc2c312
--- /dev/null
+++ b/src/generate_repo_overview/org_config.py
@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import fnmatch
+import tomllib
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, cast
+
+from generate_repo_overview.models import TrackedDep, WorkflowSignal
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+@dataclass(frozen=True, slots=True)
+class OrgConfig:
+    """Organization-specific settings loaded from a TOML config file."""
+
+    org_name: str
+    repo_include_patterns: tuple[str, ...] = ()
+    tracked_deps: tuple[TrackedDep, ...] = ()
+    workflow_signals: tuple[WorkflowSignal, ...] = ()
+    reference_integration_repo: str = ""
+    registry_repo: str = ""
+
+    def repo_matches_filter(self, repo_name: str) -> bool:
+        if not self.repo_include_patterns:
+            return True
+        return any(
+            fnmatch.fnmatch(repo_name, pattern)
+            for pattern in self.repo_include_patterns
+        )
+
+
+def load_org_config(path: Path) -> OrgConfig:
+    """Load and validate an OrgConfig from a TOML file.
+
+    Raises ``ValueError`` for missing/invalid required fields and malformed
+    repo paths.  Silently drops tracked_deps and workflow_signals entries
+    that have missing or non-string fields.
+    """
+    raw = tomllib.loads(path.read_text(encoding="utf-8"))
+    signals = cast("dict[str, Any]", raw.get("signals", {}))
+
+    org_name = raw.get("org_name")
+    if not isinstance(org_name, str) or not org_name.strip():
+        raise ValueError("org_name is required in the config file.")
+
+    reference_integration_repo = _str_or(
+        signals.get("reference_integration_repo"), ""
+    )
+    registry_repo = _str_or(signals.get("registry_repo"), "")
+    for field_name, field_value in (
+        ("reference_integration_repo", reference_integration_repo),
+        ("registry_repo", registry_repo),
+    ):
+        if field_value and "/" not in field_value:
+            raise ValueError(
+                f"{field_name} must be in 'org/repo' format, got '{field_value}'."
+            )
+
+    return OrgConfig(
+        org_name=org_name.strip(),
+        repo_include_patterns=_parse_string_list(raw.get("repo_include_patterns")),
+        tracked_deps=_parse_tracked_deps(signals.get("tracked_deps")),
+        workflow_signals=_parse_workflow_signals(signals.get("workflow_signals")),
+        reference_integration_repo=reference_integration_repo,
+        registry_repo=registry_repo,
+    )
+
+
+def _str_or(value: object, default: str) -> str:
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return default
+
+
+def _parse_string_list(value: object) -> tuple[str, ...]:
+    if value is None:
+        return ()
+    if not isinstance(value, list):
+        raise ValueError(
+            f"Expected a list of strings, got {type(value).__name__}."
+        )
+    return tuple(item.strip() for item in value if isinstance(item, str) and item.strip())
+
+
+def _parse_tracked_deps(value: object) -> tuple[TrackedDep, ...]:
+    if not isinstance(value, list):
+        return ()
+    result: list[TrackedDep] = []
+    for item in cast("list[Any]", value):
+        if not isinstance(item, dict):
+            continue
+        repo = item.get("repo")
+        module_name = item.get("module_name")
+        if (
+            isinstance(repo, str)
+            and repo.strip()
+            and "/" in repo
+            and isinstance(module_name, str)
+            and module_name.strip()
+        ):
+            result.append(TrackedDep(repo=repo.strip(), module_name=module_name.strip()))
+    return tuple(result)
+
+
+def _parse_workflow_signals(value: object) -> tuple[WorkflowSignal, ...]:
+    if not isinstance(value, list):
+        return ()
+    result: list[WorkflowSignal] = []
+    for item in cast("list[Any]", value):
+        if not isinstance(item, dict):
+            continue
+        label = item.get("label")
+        if not isinstance(label, str) or not label.strip():
+            continue
+        reference = item.get("reference")
+        if isinstance(reference, str) and reference.strip():
+            result.append(WorkflowSignal(label=label.strip(), reference=reference.strip()))
+    return tuple(result)
diff --git a/src/generate_repo_overview/profile_readme.py b/src/generate_repo_overview/profile_readme.py
index 247d8c0..879428f 100644
--- a/src/generate_repo_overview/profile_readme.py
+++ b/src/generate_repo_overview/profile_readme.py
@@ -7,7 +7,6 @@
 from typing import TYPE_CHECKING, cast
 
 from ._text_utils import escape_markdown_table_cell
-from .constants import DEFAULT_ORG
 from .models import (
     DEFAULT_SUBCATEGORY,
     CategoryConfig,
@@ -246,7 +245,8 @@ def render_readme(
     repos: list[RepoEntry],
     template: str,
     config: ReadmeConfig | None = None,
-    org_name: str = DEFAULT_ORG,
+    *,
+    org_name: str,
 ) -> str:
     grouped = group_repositories(repos, config=config)
     config_index = ConfigIndex.from_config(config)
@@ -355,7 +355,7 @@ def render_repo_table(entries: list[RepoEntry], org_name: str) -> list[str]:
     return lines
 
 
-def render_repo_row(entry: RepoEntry, org_name: str = DEFAULT_ORG) -> str:
+def render_repo_row(entry: RepoEntry, org_name: str) -> str:
     url = f"https://github.com/{org_name}/{entry.name}"
     safe_description = escape_markdown_table_cell(entry.description)
     return f"| [{entry.name}]({url}) | {safe_description} |"
diff --git a/tests/test_cli_render.py b/tests/test_cli_render.py
index 1dbe9c0..9b7864f 100644
--- a/tests/test_cli_render.py
+++ b/tests/test_cli_render.py
@@ -8,6 +8,7 @@
     RepoEntry,
     RepoSnapshot,
     TraceabilityTypeMetrics,
+    TrackedDep,
     VolatileMetricsSnapshot,
 )
 
@@ -111,11 +112,35 @@ def test_render_details_writes_repo_detail_pages(tmp_path: Path) -> None:
     assert "<!DOCTYPE html>" in detail_content
 
 
+def test_render_detail_page_shows_tracked_dep_versions(tmp_path: Path) -> None:
+    snapshot_path = tmp_path / "repo_overview.json"
+    output_dir = tmp_path / "_site"
+    write_snapshot(_make_snapshot_with_dac(), snapshot_path)
+
+    cli.main(
+        [
+            "render-details",
+            "--input",
+            str(snapshot_path),
+            "--output",
+            str(output_dir),
+        ]
+    )
+
+    detail = output_dir / "my-dac-repo" / "index.html"
+    assert detail.exists()
+    detail_content = detail.read_text(encoding="utf-8")
+    assert "Docs As Code Version" in detail_content
+
+
 def _make_snapshot_with_dac() -> RepoSnapshot:
     return RepoSnapshot(
         schema_version=SNAPSHOT_SCHEMA_VERSION,
         org_name="eclipse-score",
         generated_at="2026-04-13T12:00:00+00:00",
+        tracked_deps=(
+            TrackedDep(repo="eclipse-score/docs-as-code", module_name="score_docs_as_code"),
+        ),
         repos=(
             RepoEntry(
                 name="my-dac-repo",
@@ -123,7 +148,7 @@ def _make_snapshot_with_dac() -> RepoSnapshot:
                 category="Components",
                 subcategory="General",
                 content=DeepContentSignals(
-                    docs_as_code_version="4.0.1",
+                    bazel_deps=(("score_docs_as_code", "4.0.1"),),
                 ),
                 traceability=(
                     TraceabilityTypeMetrics(
diff --git a/tests/test_generator.py b/tests/test_generator.py
index 7348f4e..aba8e47 100644
--- a/tests/test_generator.py
+++ b/tests/test_generator.py
@@ -143,7 +143,7 @@ def test_fetch_repository_descriptions_skips_archived_repositories(
     monkeypatch.setattr(
         collector,
         "fetch_active_repositories",
-        lambda organization: {
+        lambda organization, **_kwargs: {
             "active-repo": collector.ActiveRepositoryData(
                 repository=active_repo,
                 custom_properties={},
@@ -234,6 +234,7 @@ def test_render_readme_uses_simple_markdown_sections() -> None:
             RepoEntry("score", "(no description)", "Modules", "Core"),
         ],
         template=template,
+        org_name="eclipse-score",
     )
 
     assert "# Title" in markdown
@@ -248,7 +249,8 @@ def test_render_readme_uses_simple_markdown_sections() -> None:
 
 def test_render_repo_row_escapes_markdown_table_metacharacters() -> None:
     row = profile_readme.render_repo_row(
-        RepoEntry("tools", "Line 1 | Line 2\nLine 3", "Infrastructure", "General")
+        RepoEntry("tools", "Line 1 | Line 2\nLine 3", "Infrastructure", "General"),
+        org_name="eclipse-score",
     )
 
     assert row == (
@@ -266,6 +268,7 @@ def test_render_readme_omits_general_subheading_for_single_subcategory() -> None
     markdown = render_readme(
         [RepoEntry("infra", "Infra repo", "Infrastructure", "General")],
         template=template,
+        org_name="eclipse-score",
     )
 
     assert "### Infrastructure" in markdown
@@ -294,6 +297,7 @@ def test_render_readme_uses_category_descriptions_from_config() -> None:
         [RepoEntry("infra", "Infra repo", "Infrastructure", "General")],
         template=template,
         config=config,
+        org_name="eclipse-score",
     )
 
     assert "### Infrastructure" in markdown
@@ -324,6 +328,7 @@ def test_render_readme_uses_subcategory_descriptions_from_config() -> None:
         [RepoEntry("infra", "Infra repo", "Infrastructure", "Tooling")],
         template=template,
         config=config,
+        org_name="eclipse-score",
     )
 
     assert "#### Tooling" in markdown
@@ -354,6 +359,7 @@ def test_render_readme_uses_general_subcategory_description_without_heading() ->
         [RepoEntry("infra", "Infra repo", "Infrastructure", "General")],
         template=template,
         config=config,
+        org_name="eclipse-score",
     )
 
     assert "#### General" not in markdown
@@ -381,6 +387,7 @@ def test_render_readme_matches_category_descriptions_case_insensitively() -> Non
         [RepoEntry("infra", "Infra repo", "infrastructure", "General")],
         template=template,
         config=config,
+        org_name="eclipse-score",
     )
 
     assert "### Infrastructure" in markdown
@@ -411,6 +418,7 @@ def test_render_readme_matches_subcategory_descriptions_case_insensitively() ->
         [RepoEntry("infra", "Infra repo", "infrastructure", "tooling")],
         template=template,
         config=config,
+        org_name="eclipse-score",
     )
 
     assert "### Infrastructure" in markdown
@@ -442,6 +450,7 @@ def test_render_readme_uses_config_casing_for_category_and_subcategory_names() -
         [RepoEntry("score", "Core repo", "modules", "core")],
         template=template,
         config=config,
+        org_name="eclipse-score",
     )
 
     assert "### MODULES" in markdown
diff --git a/tests/test_org_config.py b/tests/test_org_config.py
new file mode 100644
index 0000000..6f7c882
--- /dev/null
+++ b/tests/test_org_config.py
@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from textwrap import dedent
+from typing import TYPE_CHECKING
+
+import pytest
+
+from generate_repo_overview.models import TrackedDep, WorkflowSignal
+from generate_repo_overview.org_config import OrgConfig, load_org_config
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+
+class TestOrgConfigDefaults:
+    def test_org_name_is_required(self) -> None:
+        with pytest.raises(TypeError):
+            OrgConfig()  # type: ignore[call-arg]
+
+    def test_signal_defaults_are_empty(self) -> None:
+        config = OrgConfig(org_name="my-org")
+        assert config.repo_include_patterns == ()
+        assert config.tracked_deps == ()
+        assert config.workflow_signals == ()
+        assert config.reference_integration_repo == ""
+        assert config.registry_repo == ""
+
+
+class TestLoadOrgConfig:
+    def test_load_minimal_toml(self, tmp_path: Path) -> None:
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text('org_name = "my-org"\n', encoding="utf-8")
+        config = load_org_config(toml_path)
+        assert config.org_name == "my-org"
+        assert config.repo_include_patterns == ()
+        assert config.tracked_deps == ()
+
+    def test_toml_without_org_name_errors(self, tmp_path: Path) -> None:
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text("", encoding="utf-8")
+        with pytest.raises(ValueError, match="org_name is required"):
+            load_org_config(toml_path)
+
+    def test_load_full_toml(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "other-org"
+            repo_include_patterns = ["lib-*", "tool-*"]
+
+            [signals]
+            reference_integration_repo = "other-org/ref-int"
+            registry_repo = "other-org/my_registry"
+
+            [[signals.tracked_deps]]
+            repo = "other-org/my-docs"
+            module_name = "my_docs_dep"
+
+            [[signals.workflow_signals]]
+            label = "Nightly"
+            reference = "other-org/my-cicd/.github/workflows/nightly.yml@"
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        config = load_org_config(toml_path)
+        assert config.org_name == "other-org"
+        assert config.repo_include_patterns == ("lib-*", "tool-*")
+        assert config.tracked_deps == (
+            TrackedDep(repo="other-org/my-docs", module_name="my_docs_dep"),
+        )
+        assert config.workflow_signals == (
+            WorkflowSignal(
+                label="Nightly",
+                reference="other-org/my-cicd/.github/workflows/nightly.yml@",
+            ),
+        )
+        assert config.reference_integration_repo == "other-org/ref-int"
+        assert config.registry_repo == "other-org/my_registry"
+
+    def test_missing_signals_section_uses_empty_defaults(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "test"
+            repo_include_patterns = ["foo*"]
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        config = load_org_config(toml_path)
+        assert config.repo_include_patterns == ("foo*",)
+        assert config.tracked_deps == ()
+        assert config.registry_repo == ""
+
+
+class TestRepoMatchesFilter:
+    def test_empty_patterns_matches_all(self) -> None:
+        config = OrgConfig(org_name="x", repo_include_patterns=())
+        assert config.repo_matches_filter("anything") is True
+        assert config.repo_matches_filter("lib-foo") is True
+
+    def test_glob_patterns(self) -> None:
+        config = OrgConfig(org_name="x", repo_include_patterns=("lib-*", "tool-*"))
+        assert config.repo_matches_filter("lib-a") is True
+        assert config.repo_matches_filter("lib-module-a") is True
+        assert config.repo_matches_filter("tool-cli") is True
+        assert config.repo_matches_filter("other-repo") is False
+        assert config.repo_matches_filter("my-lib-thing") is False
+
+    def test_exact_name_pattern(self) -> None:
+        config = OrgConfig(org_name="x", repo_include_patterns=("specific-repo",))
+        assert config.repo_matches_filter("specific-repo") is True
+        assert config.repo_matches_filter("specific-repo-2") is False
+
+    def test_question_mark_glob(self) -> None:
+        config = OrgConfig(org_name="x", repo_include_patterns=("lib-?",))
+        assert config.repo_matches_filter("lib-a") is True
+        assert config.repo_matches_filter("lib-ab") is False
+
+
+class TestConfigValidation:
+    def test_whitespace_only_org_name_errors(self, tmp_path: Path) -> None:
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text('org_name = "   "\n', encoding="utf-8")
+        with pytest.raises(ValueError, match="org_name is required"):
+            load_org_config(toml_path)
+
+    def test_repo_include_patterns_string_instead_of_list_errors(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "test"
+            repo_include_patterns = "single-pattern"
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        with pytest.raises(ValueError, match="Expected a list"):
+            load_org_config(toml_path)
+
+    def test_repo_without_slash_in_reference_integration_repo_errors(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "test"
+            [signals]
+            reference_integration_repo = "just-a-name"
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        with pytest.raises(ValueError, match="org/repo"):
+            load_org_config(toml_path)
+
+    def test_whitespace_stripped_from_patterns(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "test"
+            repo_include_patterns = [" lib-* ", "  tool-*  "]
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        config = load_org_config(toml_path)
+        assert config.repo_include_patterns == ("lib-*", "tool-*")
+
+
+    def test_registry_repo_without_slash_errors(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "test"
+            [signals]
+            registry_repo = "just-a-name"
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        with pytest.raises(ValueError, match="org/repo"):
+            load_org_config(toml_path)
+
+    def test_malformed_tracked_deps_entries_are_skipped(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "test"
+            [signals]
+            [[signals.tracked_deps]]
+            repo = "org/valid"
+            module_name = "valid_mod"
+            [[signals.tracked_deps]]
+            repo = "org/missing-module"
+            [[signals.tracked_deps]]
+            module_name = "missing-repo"
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        config = load_org_config(toml_path)
+        assert len(config.tracked_deps) == 1
+        assert config.tracked_deps[0].repo == "org/valid"
+
+    def test_malformed_workflow_signals_entries_are_skipped(self, tmp_path: Path) -> None:
+        content = dedent("""\
+            org_name = "test"
+            [signals]
+            [[signals.workflow_signals]]
+            label = "Valid"
+            reference = "org/ref@"
+            [[signals.workflow_signals]]
+            label = "Missing Reference"
+            [[signals.workflow_signals]]
+            reference = "org/no-label@"
+        """)
+        toml_path = tmp_path / "org.toml"
+        toml_path.write_text(content, encoding="utf-8")
+        config = load_org_config(toml_path)
+        assert len(config.workflow_signals) == 1
+        assert config.workflow_signals[0].label == "Valid"
+
+
+class TestReferenceIntegrationOrgName:
+    def test_parse_github_remote_with_custom_org(self) -> None:
+        from generate_repo_overview.collector.reference_integration import (
+            parse_github_remote_repository_name,
+        )
+
+        result = parse_github_remote_repository_name(
+            "https://github.com/other-org/my-repo.git",
+            org_name="other-org",
+        )
+        assert result == "my-repo"
+
+    def test_parse_github_remote_rejects_wrong_org(self) -> None:
+        from generate_repo_overview.collector.reference_integration import (
+            parse_github_remote_repository_name,
+        )
+
+        result = parse_github_remote_repository_name(
+            "https://github.com/other-org/my-repo.git",
+            org_name="wrong-org",
+        )
+        assert result is None
diff --git a/tests/test_repo_overview.py b/tests/test_repo_overview.py
index 7cafa35..2e3372b 100644
--- a/tests/test_repo_overview.py
+++ b/tests/test_repo_overview.py
@@ -20,8 +20,11 @@
     RegistrySignals,
     RepoEntry,
     RepoSnapshot,
+    TrackedDep,
     VolatileMetricsSnapshot,
+    WorkflowSignal,
 )
+from generate_repo_overview.org_config import OrgConfig
 
 
 def test_snapshot_round_trip_preserves_repository_overview(tmp_path: Path) -> None:
@@ -47,7 +50,7 @@ def test_snapshot_round_trip_preserves_repository_overview(tmp_path: Path) -> No
                     has_pyproject_toml=True,
                     has_pre_commit_config=True,
                     has_ci=True,
-                    uses_cicd_daily_workflow=True,
+                    matched_workflow_signals=("Daily Workflow",),
                     has_coverage_config=False,
                 ),
                 registry=RegistrySignals(
@@ -68,6 +71,12 @@ def test_snapshot_round_trip_preserves_repository_overview(tmp_path: Path) -> No
                 forks=4,
             ),
         ),
+        tracked_deps=(
+            TrackedDep(repo="eclipse-score/docs-as-code", module_name="score_docs_as_code"),
+        ),
+        workflow_signals=(
+            WorkflowSignal(label="Daily Workflow", reference="org/cicd/.github/workflows/daily.yml@"),
+        ),
     )
     snapshot_path = tmp_path / "repo_overview.json"
 
@@ -86,7 +95,10 @@ def test_ensure_snapshot_prefers_existing_cache(tmp_path: Path) -> None:
     snapshot_path = tmp_path / "repo_overview.json"
     snapshot_io.write_snapshot(snapshot, snapshot_path)
 
-    loaded_snapshot = collector.ensure_snapshot(cache_path=snapshot_path)
+    loaded_snapshot = collector.ensure_snapshot(
+        config=OrgConfig(org_name="eclipse-score"),
+        cache_path=snapshot_path,
+    )
 
     assert loaded_snapshot == snapshot
 
@@ -140,7 +152,7 @@ def compare(self, base: str, head: str) -> SimpleNamespace:
             return SimpleNamespace(total_commits=7)
 
     fake_repo = FakeRepo()
-    organization = SimpleNamespace()
+    organization = SimpleNamespace(login="eclipse-score")
     cached_snapshot = RepoSnapshot(
         schema_version=SNAPSHOT_SCHEMA_VERSION,
         org_name="eclipse-score",
@@ -159,7 +171,7 @@ def compare(self, base: str, head: str) -> SimpleNamespace:
                     codeowners=("@infra-team",),
                     has_lint_config=True,
                     has_ci=True,
-                    uses_cicd_daily_workflow=True,
+                    matched_workflow_signals=("Daily Workflow",),
                     has_coverage_config=False,
                 ),
                 volatile=VolatileMetricsSnapshot(
@@ -171,7 +183,7 @@ def compare(self, base: str, head: str) -> SimpleNamespace:
 
     original_fetch_active_repositories = collector.fetch_active_repositories
     try:
-        collector.fetch_active_repositories = lambda organization: {
+        collector.fetch_active_repositories = lambda organization, **_kwargs: {
             "tools": collector.ActiveRepositoryData(
                 repository=fake_repo,
                 custom_properties={},
@@ -204,6 +216,92 @@ def compare(self, base: str, head: str) -> SimpleNamespace:
     assert entry.forks == 4
 
 
+def test_fetch_repositories_invalidates_cache_when_signal_labels_change() -> None:
+    """D4.1: When workflow signal labels in config differ from cached snapshot,
+    content cache is ignored and signals are re-evaluated from scratch."""
+    pushed_at = datetime(2026, 4, 13, 10, 0, tzinfo=UTC)
+
+    class FakeRepo:
+        archived = False
+        name = "tools"
+        description = "Tooling"
+        default_branch = "main"
+
+        def __init__(self) -> None:
+            self.pushed_at = pushed_at
+            self.open_issues_count = 0
+            self.stargazers_count = 0
+            self.forks_count = 0
+
+        def get_branch(self, branch_name: str) -> SimpleNamespace:
+            return SimpleNamespace(commit=SimpleNamespace(sha="abc123"))
+
+        def get_git_tree(self, ref: str, recursive: bool = True) -> SimpleNamespace:
+            return SimpleNamespace(tree=[])
+
+        def get_pulls(self, state: str = "open", **_: Any) -> list[SimpleNamespace]:
+            return []
+
+        def get_latest_release(self) -> SimpleNamespace:
+            raise Exception("no releases")
+
+    fake_repo = FakeRepo()
+    organization = SimpleNamespace(login="eclipse-score")
+
+    cached_snapshot = RepoSnapshot(
+        schema_version=SNAPSHOT_SCHEMA_VERSION,
+        org_name="eclipse-score",
+        generated_at="2026-04-13T12:00:00+00:00",
+        workflow_signals=(
+            WorkflowSignal(label="Daily Workflow", reference="org/cicd/.github/workflows/daily.yml@"),
+        ),
+        repos=(
+            RepoEntry(
+                name="tools",
+                description="Tooling",
+                category="Infrastructure",
+                subcategory="Tooling",
+                default_branch="main",
+                default_branch_sha="abc123",
+                content=DeepContentSignals(
+                    is_bazel_repo=True,
+                    matched_workflow_signals=("Daily Workflow",),
+                ),
+            ),
+        ),
+    )
+
+    config = OrgConfig(
+        org_name="eclipse-score",
+        workflow_signals=(
+            WorkflowSignal(label="Nightly Build", reference="org/ref@"),
+        ),
+    )
+
+    original_fetch = collector.fetch_active_repositories
+    try:
+        collector.fetch_active_repositories = lambda organization, **_kwargs: {
+            "tools": collector.ActiveRepositoryData(
+                repository=fake_repo,
+                custom_properties={},
+            )
+        }
+        repos = collector.fetch_repositories(
+            cast("Any", organization),
+            existing_snapshot=cached_snapshot,
+            config=config,
+        )
+    finally:
+        collector.fetch_active_repositories = original_fetch
+
+    assert len(repos) == 1
+    entry = repos[0]
+    # Cache was invalidated: is_bazel_repo should be False (empty tree)
+    # instead of True (from cache)
+    assert entry.content.is_bazel_repo is False
+    assert entry.content.matched_workflow_signals == ()
+
+
 def test_collect_repository_entry_reuses_cached_details_when_unchanged() -> None:
     class FakeRepo:
         default_branch = "main"
@@ -242,15 +340,15 @@ def get_latest_release(self) -> SimpleNamespace:
             is_bazel_repo=True,
             bazel_version="8.4.2",
             codeowners=("@infra-team",),
-            docs_as_code_version="1.2.3",
             referenced_by_reference_integration=False,
             has_lint_config=True,
             has_gitlint_config=True,
             has_pyproject_toml=True,
             has_pre_commit_config=True,
             has_ci=True,
-            uses_cicd_daily_workflow=True,
+            matched_workflow_signals=("Daily Workflow",),
             has_coverage_config=True,
+            bazel_deps=(("score_docs_as_code", "1.2.3"),),
         ),
         registry=RegistrySignals(
             maintainers_in_bazel_registry=("Old Maintainer",),
@@ -296,15 +394,15 @@ def get_latest_release(self) -> SimpleNamespace:
             is_bazel_repo=True,
             bazel_version="8.4.2",
             codeowners=("@infra-team",),
-            docs_as_code_version="1.2.3",
             referenced_by_reference_integration=True,
             has_lint_config=True,
             has_gitlint_config=True,
             has_pyproject_toml=True,
             has_pre_commit_config=True,
             has_ci=True,
-            uses_cicd_daily_workflow=True,
+            matched_workflow_signals=("Daily Workflow",),
             has_coverage_config=True,
+            bazel_deps=(("score_docs_as_code", "1.2.3"),),
         ),
         registry=RegistrySignals(
             maintainers_in_bazel_registry=("New Maintainer",),
@@ -450,7 +548,7 @@ def compare(self, base: str, head: str) -> SimpleNamespace:
             codeowners=("@infra-team",),
             has_lint_config=True,
             has_ci=True,
-            uses_cicd_daily_workflow=True,
+            matched_workflow_signals=("Daily Workflow",),
             has_coverage_config=False,
         ),
         volatile=VolatileMetricsSnapshot(
@@ -624,24 +722,15 @@ def test_detect_bazel_version_ignores_module_version_without_dot_bazelversion()
     )
 
 
-def test_get_bazel_dep_version_extracts_docs_as_code_dependency_version() -> None:
-    assert (
-        signal_detection.get_bazel_dep_version(
-            'bazel_dep(name = "score_docs_as_code", version = "4.0.0")\n',
-            module_name="score_docs_as_code",
-        )
-        == "4.0.0"
-    )
+def test_get_all_bazel_dep_versions_extracts_dependency_versions() -> None:
+    assert signal_detection.get_all_bazel_dep_versions(
+        'bazel_dep(name = "score_docs_as_code", version = "4.0.0")\n'
+        'bazel_dep(name = "score_process", version = "1.2.3")\n',
+    ) == (("score_docs_as_code", "4.0.0"), ("score_process", "1.2.3"))
 
 
-def test_get_bazel_dep_version_ignores_other_dependencies() -> None:
-    assert (
-        signal_detection.get_bazel_dep_version(
-            'bazel_dep(name = "score_process", version = "1.2.3")\n',
-            module_name="score_docs_as_code",
-        )
-        is None
-    )
+def test_get_all_bazel_dep_versions_returns_empty_for_no_deps() -> None:
+    assert signal_detection.get_all_bazel_dep_versions("# no deps\n") == ()
 
 
 def test_reference_integration_reads_recursive_included_module_files(
@@ -694,6 +783,7 @@ def test_reference_integration_maps_git_overrides_to_active_repositories() -> No
 )
 """.strip(),
         active_repository_names={"tooling"},
+        org_name="eclipse-score",
     ) == {"score_tooling": "tooling"}
 
 
@@ -797,7 +887,9 @@ def test_merge_bazel_registry_metadata_combines_owners_and_keeps_latest_version(
     }
 
 
-def test_uses_cicd_daily_workflow_detects_shared_daily_workflow_reference() -> None:
+def test_detect_matched_workflow_signals_detects_shared_workflow_reference() -> None:
+    from generate_repo_overview.models import WorkflowSignal
+
     class FakeRepo:
         def get_contents(self, path: str, ref: str) -> SimpleNamespace:
             assert path == ".github/workflows/nightly.yml"
@@ -810,11 +902,42 @@ def get_contents(self, path: str, ref: str) -> SimpleNamespace:
                 )
             )
 
-    assert signal_detection.uses_cicd_daily_workflow(
+    assert signal_detection.detect_matched_workflow_signals(
         FakeRepo(),
         tree_paths={".github/workflows/nightly.yml"},
         ref="abc123",
+        workflow_signals=(
+            WorkflowSignal(
+                label="Daily Workflow",
+                reference="eclipse-score/cicd-workflows/.github/workflows/daily.yml@",
+            ),
+        ),
+    ) == ("Daily Workflow",)
+
+
+def test_detect_matched_workflow_signals_multiple_signals_partial_match() -> None:
+    from generate_repo_overview.models import WorkflowSignal
+
+    class FakeRepo:
+        def get_contents(self, path: str, ref: str) -> SimpleNamespace:
+            return SimpleNamespace(
+                decoded_content=(
+                    b"jobs:\n"
+                    b"  daily:\n"
+                    b"    uses: org/workflows/.github/workflows/daily.yml@main\n"
+                )
+            )
+
+    result = signal_detection.detect_matched_workflow_signals(
+        FakeRepo(),
+        tree_paths={".github/workflows/ci.yml"},
+        ref="abc",
+        workflow_signals=(
+            WorkflowSignal(label="Daily Workflow", reference="org/workflows/.github/workflows/daily.yml@"),
+            WorkflowSignal(label="Nightly Build", reference="org/workflows/.github/workflows/nightly.yml@"),
+        ),
     )
+    assert result == ("Daily Workflow",)
 
 
 def test_get_commits_since_release_returns_none_when_compare_is_lazy() -> None:
@@ -878,7 +1001,10 @@ def get_organization(self, org_name: str) -> SimpleNamespace:
     monkeypatch.setattr(collector, "resolve_github_token", lambda token_env: "token")
     monkeypatch.setattr(collector, "fetch_repositories", lambda *args, **kwargs: [])
 
-    snapshot = collector.collect_snapshot(cache_path=None)
+    snapshot = collector.collect_snapshot(
+        config=OrgConfig(org_name="eclipse-score"),
+        cache_path=None,
+    )
 
     captured = capsys.readouterr()
 
@@ -899,7 +1025,7 @@ def test_fetch_repositories_reports_per_repository_progress(
 ) -> None:
     tools_repo = SimpleNamespace(archived=False, name="tools")
     alpha_repo = SimpleNamespace(archived=False, name="alpha")
-    organization = SimpleNamespace()
+    organization = SimpleNamespace(login="eclipse-score")
     cached_snapshot = RepoSnapshot(
         schema_version=SNAPSHOT_SCHEMA_VERSION,
         org_name="eclipse-score",
@@ -926,7 +1052,7 @@ def fake_collect_repository_entry(**kwargs: Any) -> RepoEntry:
         )
 
     try:
-        collector.fetch_active_repositories = lambda organization: {
+        collector.fetch_active_repositories = lambda organization, **_kwargs: {
             "tools": collector.ActiveRepositoryData(
                 repository=tools_repo,
                 custom_properties={},
@@ -955,12 +1081,12 @@ def fake_collect_repository_entry(**kwargs: Any) -> RepoEntry:
 def test_fetch_repositories_preserves_sorted_output_with_parallel_collection() -> None:
     alpha_repo = SimpleNamespace(archived=False, name="alpha")
     tools_repo = SimpleNamespace(archived=False, name="tools")
-    organization = SimpleNamespace()
+    organization = SimpleNamespace(login="eclipse-score")
 
     original_collect_repository_entry = repo_entry.collect_repository_entry
     original_fetch_active_repositories = collector.fetch_active_repositories
     try:
-        collector.fetch_active_repositories = lambda organization: {
+        collector.fetch_active_repositories = lambda organization, **_kwargs: {
             "tools": collector.ActiveRepositoryData(
                 repository=tools_repo,
                 custom_properties={},
@@ -1014,6 +1140,9 @@ def test_metrics_report_renders_summary_and_table() -> None:
         schema_version=SNAPSHOT_SCHEMA_VERSION,
         org_name="eclipse-score",
         generated_at="2026-04-13T12:00:00+00:00",
+        workflow_signals=(
+            WorkflowSignal(label="Daily Workflow", reference="org/cicd/.github/workflows/daily.yml@"),
+        ),
         repos=(
             RepoEntry(
                 name="tools",
@@ -1032,7 +1161,7 @@ def test_metrics_report_renders_summary_and_table() -> None:
                     referenced_by_reference_integration=True,
                     has_lint_config=True,
                     has_ci=True,
-                    uses_cicd_daily_workflow=True,
+                    matched_workflow_signals=("Daily Workflow",),
                     has_coverage_config=False,
                 ),
                 registry=RegistrySignals(
@@ -1064,7 +1193,7 @@ def test_metrics_report_renders_summary_and_table() -> None:
     assert "# Cross-Repo Metrics Report" in markdown
     assert "- Repositories: 1" in markdown
     assert "- With GitHub Actions: 1" in markdown
-    assert "- Using daily workflow: 1" in markdown
+    assert "- With workflow signals: 1" in markdown
     assert "## Table Of Contents" in markdown
     assert "- [Repository Overview](#repository-overview)" in markdown
     assert "- [Versions](#versions)" in markdown
@@ -1090,7 +1219,7 @@ def test_metrics_report_renders_summary_and_table() -> None:
     )
     assert (
         "| [tools](https://github.com/eclipse-score/tools) | "
-        "🟢 8.4.2 | ⚪ - | yes |" in markdown
+        "🟢 8.4.2 | yes |" in markdown
     )
     assert (
         "| [tools](https://github.com/eclipse-score/tools) | - | - | - | ⚙ | yes | no |"
@@ -1204,6 +1333,9 @@ def test_metrics_report_renders_versions_table() -> None:
         schema_version=SNAPSHOT_SCHEMA_VERSION,
         org_name="eclipse-score",
         generated_at="2026-04-13T12:00:00+00:00",
+        tracked_deps=(
+            TrackedDep(repo="eclipse-score/docs-as-code", module_name="score_docs_as_code"),
+        ),
         repos=(
             RepoEntry(
                 name="process_description",
@@ -1213,10 +1345,10 @@ def test_metrics_report_renders_versions_table() -> None:
                 content=DeepContentSignals(
                     is_bazel_repo=True,
                     bazel_version="8.4.2",
-                    docs_as_code_version="4.0.0",
+                    bazel_deps=(("score_docs_as_code", "4.0.0"),),
                     referenced_by_reference_integration=True,
                     has_ci=True,
-                    uses_cicd_daily_workflow=True,
+                    matched_workflow_signals=("Daily Workflow",),
                 ),
                 volatile=VolatileMetricsSnapshot(
                     last_push_date="2026-04-12",
@@ -1239,11 +1371,14 @@ def test_metrics_report_renders_versions_table() -> None:
     )
 
 
-def test_versions_table_docs_as_code_color_rules() -> None:
+def test_versions_table_tracked_dep_color_rules() -> None:
     snapshot = RepoSnapshot(
         schema_version=SNAPSHOT_SCHEMA_VERSION,
         org_name="eclipse-score",
         generated_at="2026-04-13T12:00:00+00:00",
+        tracked_deps=(
+            TrackedDep(repo="eclipse-score/docs-as-code", module_name="score_docs_as_code"),
+        ),
         repos=(
             RepoEntry(
                 name="docs-as-code",
@@ -1259,7 +1394,7 @@ def test_versions_table_docs_as_code_color_rules() -> None:
                 category="Infrastructure",
                 subcategory="Tooling",
                 content=DeepContentSignals(
-                    docs_as_code_version="4.1.3",
+                    bazel_deps=(("score_docs_as_code", "4.1.3"),),
                     bazel_version="8.5.0",
                 ),
             ),
@@ -1269,7 +1404,7 @@ def test_versions_table_docs_as_code_color_rules() -> None:
                 category="Infrastructure",
                 subcategory="Tooling",
                 content=DeepContentSignals(
-                    docs_as_code_version="4.1.1",
+                    bazel_deps=(("score_docs_as_code", "4.1.1"),),
                     bazel_version="8.4.0",
                 ),
             ),
@@ -1279,7 +1414,7 @@ def test_versions_table_docs_as_code_color_rules() -> None:
                 category="Infrastructure",
                 subcategory="Tooling",
                 content=DeepContentSignals(
-                    docs_as_code_version="3.9.9",
+                    bazel_deps=(("score_docs_as_code", "3.9.9"),),
                     bazel_version="8.3.0",
                 ),
             ),
@@ -1289,7 +1424,6 @@ def test_versions_table_docs_as_code_color_rules() -> None:
                 category="Infrastructure",
                 subcategory="Tooling",
                 content=DeepContentSignals(
-                    docs_as_code_version=None,
                     bazel_version=None,
                 ),
             ),
@@ -1320,6 +1454,133 @@ def test_versions_table_docs_as_code_color_rules() -> None:
     )
 
 
+def test_versions_table_multiple_tracked_deps() -> None:
+    snapshot = RepoSnapshot(
+        schema_version=SNAPSHOT_SCHEMA_VERSION,
+        org_name="eclipse-score",
+        generated_at="2026-04-13T12:00:00+00:00",
+        tracked_deps=(
+            TrackedDep(repo="eclipse-score/docs-as-code", module_name="score_docs_as_code"),
+            TrackedDep(repo="eclipse-score/toolchain", module_name="score_toolchain"),
+        ),
+        repos=(
+            RepoEntry(
+                name="docs-as-code",
+                description="Docs",
+                category="Infrastructure",
+                subcategory="Tooling",
+                volatile=VolatileMetricsSnapshot(latest_release_version="v4.1.3"),
+                content=DeepContentSignals(bazel_version="8.6.0"),
+            ),
+            RepoEntry(
+                name="toolchain",
+                description="TC",
+                category="Infrastructure",
+                subcategory="Tooling",
+                volatile=VolatileMetricsSnapshot(latest_release_version="v2.0.0"),
+                content=DeepContentSignals(bazel_version="8.6.0"),
+            ),
+            RepoEntry(
+                name="consumer",
+                description="Consumer",
+                category="Infrastructure",
+                subcategory="Tooling",
+                content=DeepContentSignals(
+                    bazel_version="8.6.0",
+                    bazel_deps=(
+                        ("score_docs_as_code", "4.1.3"),
+                        ("score_toolchain", "1.9.0"),
+                    ),
+                ),
+            ),
+        ),
+    )
+
+    markdown = render_metrics_report(snapshot)
+
+    assert "Docs As Code Version" in markdown
+    assert "Toolchain Version" in markdown
+    assert "🟢 4.1.3 | 🔴 1.9.0" in markdown
+
+
+def test_metrics_report_renders_without_tracked_deps_or_signals() -> None:
+    """D4.2: Versions/Automation tables with zero deps and zero signals."""
+    snapshot = RepoSnapshot(
+        schema_version=SNAPSHOT_SCHEMA_VERSION,
+        org_name="eclipse-score",
+        generated_at="2026-04-13T12:00:00+00:00",
+        tracked_deps=(),
+        workflow_signals=(),
+        repos=(
+            RepoEntry(
+                name="basic-repo",
+                description="Basic",
+                category="Infrastructure",
+                subcategory="Tooling",
+                content=DeepContentSignals(bazel_version="8.0.0", has_ci=True),
+            ),
+        ),
+    )
+
+    markdown = render_metrics_report(snapshot)
+
+    assert "## Versions" in markdown
+    assert "## Delivery And Automation" in markdown
+    assert "| Reference Integration |" in markdown
+    assert "| Coverage Config |" in markdown
+    assert "Daily Workflow" not in markdown
+
+
+def test_metrics_report_automation_with_multiple_signals() -> None:
+    """D4.3: Automation table with 2 signal columns."""
+    snapshot = RepoSnapshot(
+        schema_version=SNAPSHOT_SCHEMA_VERSION,
+        org_name="eclipse-score",
+        generated_at="2026-04-13T12:00:00+00:00",
+        workflow_signals=(
+            WorkflowSignal(label="Daily Workflow", reference="org/cicd/.github/workflows/daily.yml@"),
+            WorkflowSignal(label="Nightly Build", reference="org/cicd/.github/workflows/nightly.yml@"),
+        ),
+        repos=(
+            RepoEntry(
+                name="repo-a",
+                description="A",
+                category="Infrastructure",
+                subcategory="Tooling",
+                content=DeepContentSignals(
+                    has_ci=True,
+                    matched_workflow_signals=("Daily Workflow",),
+                ),
+            ),
+        ),
+    )
+
+    markdown = render_metrics_report(snapshot)
+
+    assert "Daily Workflow" in markdown
+    assert "Nightly Build" in markdown
+    assert "| yes | no |" in markdown
+
+
+def test_snapshot_from_dict_filters_empty_tracked_deps() -> None:
+    """D4.6: TrackedDep with empty repo/module_name is dropped during deserialization."""
+    snapshot = RepoSnapshot(
+        schema_version=SNAPSHOT_SCHEMA_VERSION,
+        org_name="test",
+        generated_at="2026-01-01",
+        repos=(),
+        tracked_deps=(TrackedDep(repo="org/valid", module_name="valid_mod"),),
+    )
+    raw = snapshot.to_dict()
+    raw["tracked_deps"].append({"repo": "", "module_name": "empty_repo"})
+    raw["tracked_deps"].append({"repo": "org/x", "module_name": ""})
+
+    loaded = RepoSnapshot.from_dict(raw)
+
+    assert len(loaded.tracked_deps) == 1
+    assert loaded.tracked_deps[0].repo == "org/valid"
+
+
 def test_load_snapshot_if_present_ignores_mismatched_schema(tmp_path: Path) -> None:
     cache_path = tmp_path / "repo_overview.json"
     cache_path.write_text(
diff --git a/uv.lock b/uv.lock
index a744d6f..dc98d61 100644
--- a/uv.lock
+++ b/uv.lock
@@ -395,11 +395,11 @@ wheels = [
 
 [[package]]
 name = "pygments"
-version = "2.20.0"
+version = "2.19.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/77/a5b8c569bf593b0140bde72ea885a803b82086995367bf2037de0159d924/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887", size = 4968631, upload-time = "2025-06-21T13:39:12.283Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/21/705964c7812476f378728bdf590ca4b771ec72385c533964653c68e86bdc/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b", size = 1225217, upload-time = "2025-06-21T13:39:07.939Z" },
 ]
 
 [[package]]
@@ -453,7 +453,7 @@ wheels = [
 
 [[package]]
 name = "pytest"
-version = "9.0.3"
+version = "9.0.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -462,9 +462,9 @@ dependencies = [
     { name = "pluggy" },
     { name = "pygments" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/d1/db/7ef3487e0fb0049ddb5ce41d3a49c235bf9ad299b6a25d5780a89f19230f/pytest-9.0.2.tar.gz", hash = "sha256:75186651a92bd89611d1d9fc20f0b4345fd827c41ccd5c299a868a05d70edf11", size = 1568901, upload-time = "2025-12-06T21:30:51.014Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/ab/b3226f0bd7cdcf710fbede2b3548584366da3b19b5021e74f5bde2a8fa3f/pytest-9.0.2-py3-none-any.whl", hash = "sha256:711ffd45bf766d5264d487b917733b453d917afd2b0ad65223959f59089f875b", size = 374801, upload-time = "2025-12-06T21:30:49.154Z" },
 ]
 
 [[package]]
@@ -589,11 +589,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.7.0"
+version = "2.6.3"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c7/24/5f1b3bdffd70275f6661c76461e25f024d5a38a46f04aaca912426a2b1d3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed", size = 435556, upload-time = "2026-01-07T16:24:43.925Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+    { url = "https://files.pythonhosted.org/packages/39/08/aaaad47bc4e9dc8c725e68f9d04865dbcb2052843ff09c97b08904852d84/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4", size = 131584, upload-time = "2026-01-07T16:24:42.685Z" },
 ]
 
 [[package]]