@@ -44,6 +44,7 @@ tests/*
 !tests/test_ruby_analyzer.py
 !tests/test_processing_order_update.py
 !tests/test_leaf_selection.py
+!tests/test_artifact_analyzer.py
 
 # Jupyter
 *.ipynb
 
@@ -150,6 +150,9 @@ def generate(self) -> DocumentationJob:
                 agent_instructions=self.config.get('agent_instructions'),
                 use_gitignore=self.config.get('use_gitignore', True),
                 prompt_caching=self.config.get('prompt_caching', True),
+                artifacts_enabled=self.config.get('artifacts_enabled', True),
+                artifact_token_budget=self.config.get('artifact_token_budget', 200_000),
+                with_prose=self.config.get('with_prose', False),
             )
 
             # Run backend documentation generation
@@ -215,6 +218,7 @@ async def _run_backend_generation(self, backend_config: BackendConfig):
         # Import clustering function
         from codewiki.src.be.cluster_modules import (
             cluster_modules,
+            ensure_artifact_module,
             get_clustering_input_token_count,
             super_group_modules,
         )
@@ -273,6 +277,10 @@ async def _run_backend_generation(self, backend_config: BackendConfig):
                         backend_config,
                         completer=lambda p: doc_generator.backend.complete(p, model=cluster_model),
                     )
+                # Artifact nodes the clustering LLM dropped get a fixed module
+                # so build/CI/config coverage does not depend on the LLM.
+                if getattr(backend_config, "artifacts_enabled", True):
+                    module_tree = ensure_artifact_module(module_tree, leaf_nodes, components)
                 # Only freshly clustered trees are deduped: renaming a cached
                 # key whose .md already exists would orphan the doc.
                 from codewiki.src.be.module_naming import dedupe_module_tree_names
 
@@ -307,6 +307,30 @@ def _find_affected(tree, parent_names=None):
     help="Add prompt-cache breakpoints to agentic LLM calls; auto-falls back to "
          "normal calls if the provider rejects them (default: enabled)",
 )
+@click.option(
+    "--artifacts/--no-artifacts",
+    default=True,
+    help="Document build, CI, container, packaging, manifest, config, schema and "
+         "script files as part of the dependency graph (default: enabled)",
+)
+@click.option(
+    "--artifact-token-budget",
+    type=int,
+    default=200_000,
+    show_default=True,
+    help="Total token budget for artifact file contents added to the graph",
+)
+@click.option(
+    "--with-prose",
+    is_flag=True,
+    help="Also read the root README and docs/ as a `prose` artifact class (off by default)",
+)
+@click.option(
+    "--artifact-exclude",
+    type=str,
+    default=None,
+    help="Comma-separated patterns skipped by artifact analysis (e.g. 'docker/data/*,config/generated/*')",
+)
 @click.option(
     "--update",
     is_flag=True,
@@ -337,6 +361,10 @@ def generate_command(
     max_token_per_leaf_module: Optional[int],
     max_depth: Optional[int],
     prompt_caching: Optional[bool],
+    artifacts: bool = True,
+    artifact_token_budget: int = 200_000,
+    with_prose: bool = False,
+    artifact_exclude: Optional[str] = None,
     update: bool = False,
     compare_to: Optional[str] = None
 ):
@@ -511,13 +539,14 @@ def generate_command(
 
         # Create runtime agent instructions from CLI options
         runtime_instructions = None
-        if any([include, exclude, focus, doc_type, instructions]):
+        if any([include, exclude, focus, doc_type, instructions, artifact_exclude]):
             runtime_instructions = AgentInstructions(
                 include_patterns=parse_patterns(include) if include else None,
                 exclude_patterns=parse_patterns(exclude) if exclude else None,
                 focus_modules=parse_patterns(focus) if focus else None,
                 doc_type=doc_type,
                 custom_instructions=instructions,
+                artifact_exclude=parse_patterns(artifact_exclude) if artifact_exclude else None,
             )
 
             if verbose:
@@ -531,6 +560,8 @@ def generate_command(
                     logger.debug(f"Doc type: {doc_type}")
                 if instructions:
                     logger.debug(f"Custom instructions: {instructions}")
+                if artifact_exclude:
+                    logger.debug(f"Artifact exclude patterns: {parse_patterns(artifact_exclude)}")
 
         # Log max token settings if verbose
         if verbose:
@@ -546,6 +577,7 @@ def generate_command(
             logger.debug(f"Max depth: {effective_max_depth}")
             logger.debug(f"Use gitignore: {effective_use_gitignore}")
             logger.debug(f"Prompt caching: {effective_prompt_caching}")
+            logger.debug(f"Artifacts: {artifacts} (token budget {artifact_token_budget}, prose {with_prose})")
 
         # Get agent instructions (merge runtime with persistent)
         agent_instructions_dict = None
@@ -557,6 +589,7 @@ def generate_command(
                 focus_modules=runtime_instructions.focus_modules or (config.agent_instructions.focus_modules if config.agent_instructions else None),
                 doc_type=runtime_instructions.doc_type or (config.agent_instructions.doc_type if config.agent_instructions else None),
                 custom_instructions=runtime_instructions.custom_instructions or (config.agent_instructions.custom_instructions if config.agent_instructions else None),
+                artifact_exclude=runtime_instructions.artifact_exclude or (config.agent_instructions.artifact_exclude if config.agent_instructions else None),
             )
             agent_instructions_dict = merged.to_dict()
         elif config.agent_instructions and not config.agent_instructions.is_empty():
@@ -587,6 +620,10 @@ def generate_command(
                 'use_gitignore': use_gitignore if use_gitignore is not None else config.use_gitignore,
                 # Prompt caching setting (runtime override takes precedence)
                 'prompt_caching': prompt_caching if prompt_caching is not None else config.prompt_caching,
+                # Artifact-aware generation (runtime-only flags)
+                'artifacts_enabled': artifacts,
+                'artifact_token_budget': artifact_token_budget,
+                'with_prose': with_prose,
             },
             verbose=verbose,
             generate_html=github_pages,
 
@@ -40,6 +40,7 @@ class AgentInstructions:
     focus_modules: Optional[List[str]] = None  # e.g., ["src/core", "src/api"]
     doc_type: Optional[str] = None  # e.g., "api", "architecture", "user-guide"
     custom_instructions: Optional[str] = None  # Free-form instructions
+    artifact_exclude: Optional[List[str]] = None  # e.g., ["docker/data/*"] skipped by artifact analysis
 
     def to_dict(self) -> dict:
         """Convert to dictionary, excluding None values."""
@@ -48,6 +49,8 @@ def to_dict(self) -> dict:
             result['include_patterns'] = self.include_patterns
         if self.exclude_patterns:
             result['exclude_patterns'] = self.exclude_patterns
+        if self.artifact_exclude:
+            result['artifact_exclude'] = self.artifact_exclude
         if self.focus_modules:
             result['focus_modules'] = self.focus_modules
         if self.doc_type:
@@ -65,13 +68,15 @@ def from_dict(cls, data: dict) -> 'AgentInstructions':
             focus_modules=data.get('focus_modules'),
             doc_type=data.get('doc_type'),
             custom_instructions=data.get('custom_instructions'),
+            artifact_exclude=data.get('artifact_exclude'),
         )
 
     def is_empty(self) -> bool:
         """Check if all fields are empty/None."""
         return not any([
             self.include_patterns,
             self.exclude_patterns,
+            self.artifact_exclude,
             self.focus_modules,
             self.doc_type,
             self.custom_instructions,
 
@@ -6,6 +6,7 @@
 
 import json
 import re
+import shlex
 import subprocess
 import sys
 from collections import defaultdict
@@ -487,8 +488,11 @@ def view(self, path: Path, view_range: Optional[List[int]] = None):
                 self.logs.append("The `view_range` parameter is not allowed when `path` points to a directory.")
                 return
 
+            # Hidden entries are skipped except `.github` (CI workflows are
+            # documentation-relevant artifacts the agent must be able to find).
             out = subprocess.run(
-                rf"find {path} -maxdepth 2 -not -path '*/\.*'",
+                rf"find {shlex.quote(str(path))} -maxdepth 2 "
+                r"\( -not -path '*/.*' -o -name .github -o -path '*/.github/*' \)",
                 shell=True,
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
@@ -499,7 +503,7 @@ def view(self, path: Path, view_range: Optional[List[int]] = None):
 
             if not stderr:
                 stdout = stdout.replace(str(path), self._get_display_path(path))
-                stdout = f"Here's the files and directories up to 2 levels deep in {self._get_display_path(path)}, excluding hidden items:\n{stdout}\n"
+                stdout = f"Here's the files and directories up to 2 levels deep in {self._get_display_path(path)}, excluding hidden items (except .github):\n{stdout}\n"
                 self.logs.append(stdout)
             return
 
@@ -747,14 +751,14 @@ async def str_replace_editor(
     """
     Custom editing tool for viewing, creating and editing files
         * State is persistent across command calls and discussions with the user
-        * If `path` is a file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep.
+        * If `path` is a file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories (plus `.github`) up to 2 levels deep.
         * The `create` command cannot be used if the specified `path` already exists as a file
         * If a `command` generates a long output, it will be truncated and marked with `<response clipped>`
         * The `undo_edit` command will revert the last edit made to the file at `path`
         * Only `view` command is allowed when `working_dir` is `repo`.
 
     Args:
-        working_dir: The working directory to use. Choose `repo` to work with the repository files, or `docs` to work with the generated documentation files.
+        working_dir: The working directory to use. Choose `repo` to view repository files (source code, and build/CI/container/manifest/config artifacts such as Dockerfile, Makefile, .github/workflows/*.yml, pyproject.toml), or `docs` to work with the generated documentation files.
         command: The command to run. Allowed options are: `view`, `create`, `str_replace`, `insert`, `undo_edit`.
         path: Path to file or directory, e.g. `./chat_core.md` or `./agents/`
         file: Alias for `path` parameter (for compatibility with some models)
@@ -805,7 +809,7 @@ async def str_replace_editor(
     description="""
 Custom editing tool for viewing, creating and editing files
     * State is persistent across command calls and discussions with the user
-    * If `path` is a file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep.
+    * If `path` is a file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories (plus `.github`) up to 2 levels deep.
     * The `create` command cannot be used if the specified `path` already exists as a file
     * If a `command` generates a long output, it will be truncated and marked with `<response clipped>`
     * The `undo_edit` command will revert the last edit made to the file at `path`
 
@@ -123,7 +123,7 @@ async def read_code_components(self, component_ids: list[str]) -> str:
         description=(
             "Custom editing tool for viewing, creating and editing files.\n"
             "* If `path` is a file, `view` displays the result of applying `cat -n`. "
-            "If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep.\n"
+            "If `path` is a directory, `view` lists non-hidden files and directories (plus `.github`) up to 2 levels deep.\n"
             "* The `create` command cannot be used if the specified `path` already exists as a file.\n"
             "* If a `command` generates a long output, it will be truncated and marked with `<response clipped>`.\n"
             "* The `undo_edit` command will revert the last edit made to the file at `path`.\n"
 
@@ -43,8 +43,11 @@ def format_potential_core_components(leaf_nodes: List[str], components: Dict[str
     potential_core_components = ""
     potential_core_components_with_code = ""
     for file, leaf_nodes in dict(sorted(leaf_nodes_by_file.items())).items():
-        potential_core_components += f"# {file}\n"
-        potential_core_components_with_code += f"# {file}\n"
+        header = f"# {file}"
+        if all(components[n].component_type == "artifact" for n in leaf_nodes):
+            header += f" (artifact: {components[leaf_nodes[0]].artifact_class or 'config'})"
+        potential_core_components += f"{header}\n"
+        potential_core_components_with_code += f"{header}\n"
         for leaf_node in leaf_nodes:
             potential_core_components += f"\t{leaf_node}\n"
             potential_core_components_with_code += f"\t{leaf_node}\n"
@@ -603,3 +606,85 @@ def super_group_modules(
         len(subsystems),
     )
     return result
+
+
+# --------------------------------------------------------------------------- #
+# Guaranteed artifact module
+# --------------------------------------------------------------------------- #
+
+ARTIFACT_MODULE_NAME = "Build, Deployment and Configuration"
+# Insert the fallback module when clustering kept less than this share of the
+# artifact leaf nodes.
+ARTIFACT_MIN_SHARE = 0.8
+
+
+def collect_module_tree_component_ids(module_tree: Dict[str, Any]) -> set:
+    """Return every component id referenced anywhere in ``module_tree``."""
+    ids: set = set()
+
+    def _walk(tree: Dict[str, Any]) -> None:
+        for module_info in tree.values():
+            if not isinstance(module_info, dict):
+                continue
+            ids.update(module_info.get("components", []) or [])
+            children = module_info.get("children", {})
+            if isinstance(children, dict):
+                _walk(children)
+
+    _walk(module_tree)
+    return ids
+
+
+def ensure_artifact_module(
+    module_tree: Dict[str, Any],
+    leaf_nodes: List[str],
+    components: Dict[str, Node],
+    min_share: float = ARTIFACT_MIN_SHARE,
+) -> Dict[str, Any]:
+    """Guarantee that artifact leaf nodes are documented.
+
+    Clustering is an LLM call and may drop or scatter artifact nodes despite
+    the prompt. If fewer than ``min_share`` of the artifact leaf nodes landed
+    in ``module_tree``, add a fixed top-level module holding every unassigned
+    artifact node. Returns ``module_tree`` unchanged in whole-repository mode
+    (empty tree: one agent documents all leaf nodes anyway).
+    """
+    if not module_tree:
+        return module_tree
+    artifact_leaves = [
+        n for n in leaf_nodes
+        if n in components and components[n].component_type == "artifact"
+    ]
+    if not artifact_leaves:
+        return module_tree
+    assigned = collect_module_tree_component_ids(module_tree)
+    unassigned = [n for n in artifact_leaves if n not in assigned]
+    share = 1.0 - len(unassigned) / len(artifact_leaves)
+    logger.info(
+        "Artifact coverage after clustering: %d/%d artifact leaf nodes assigned (%.0f%%)",
+        len(artifact_leaves) - len(unassigned), len(artifact_leaves), share * 100,
+    )
+    if not unassigned or share >= min_share:
+        return module_tree
+
+    from codewiki.src.be.dependency_analyzer.analyzers.artifact import CLASS_PRIORITY
+    from codewiki.src.be.module_naming import collect_module_tree_names
+
+    def _order(node_id: str):
+        node = components[node_id]
+        cls = node.artifact_class or "config"
+        rank = CLASS_PRIORITY.index(cls) if cls in CLASS_PRIORITY else len(CLASS_PRIORITY)
+        return (rank, node.relative_path, node_id)
+
+    unassigned.sort(key=_order)
+    name = resolve_unique_name(ARTIFACT_MODULE_NAME, None, collect_module_tree_names(module_tree))
+    module_tree[name] = {
+        "path": _common_path_prefix([components[n].relative_path for n in unassigned]) or ".",
+        "components": unassigned,
+        "children": {},
+    }
+    logger.info(
+        "Artifact coverage %.0f%% < %.0f%%; inserted top-level module '%s' with %d components",
+        share * 100, min_share * 100, name, len(unassigned),
+    )
+    return module_tree
@@ -9,7 +9,7 @@
 import logging
 import traceback
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from codewiki.src.be.dependency_analyzer.analysis.call_graph_analyzer import CallGraphAnalyzer
 from codewiki.src.be.dependency_analyzer.analysis.cloning import (
@@ -22,6 +22,9 @@
 from codewiki.src.be.dependency_analyzer.models.core import Repository
 from codewiki.src.be.dependency_analyzer.utils.security import assert_safe_path, safe_open_text
 
+if TYPE_CHECKING:  # pragma: no cover
+    from codewiki.src.be.dependency_analyzer.analyzers.artifact import ArtifactOptions
+
 logger = logging.getLogger(__name__)
 
 
@@ -288,14 +291,20 @@ def _read_readme_file(self, repo_dir: str) -> str | None:
         logger.debug("No README file found in repository root.")
         return None
 
-    def _analyze_call_graph(self, file_tree: dict[str, Any], repo_dir: str) -> dict[str, Any]:
+    def _analyze_call_graph(
+        self,
+        file_tree: dict[str, Any],
+        repo_dir: str,
+        artifact_options: "ArtifactOptions | None" = None,
+    ) -> dict[str, Any]:
         """
         Perform multi-language call graph analysis.
 
-        This method will be expanded to handle:
-        - Python AST analysis (current)
-        - JavaScript/TypeScript AST analysis (planned)
-        - Additional language support (future)
+        When ``artifact_options`` is given and enabled, a second pass turns
+        build/CI/container/manifest/config files in the same file tree into
+        ``artifact`` nodes (see ``analyzers/artifact.py``) and appends them to
+        the ``functions``/``relationships`` lists so the rest of the pipeline
+        treats them like any other component.
         """
         logger.debug("Extracting code files from file tree...")
         code_files = self.call_graph_analyzer.extract_code_files(file_tree)
@@ -311,6 +320,19 @@ def _analyze_call_graph(self, file_tree: dict[str, Any], repo_dir: str) -> dict[
         result["call_graph"]["supported_languages"] = self._get_supported_languages()
         result["call_graph"]["unsupported_files"] = len(code_files) - len(supported_files)
 
+        if artifact_options is not None and artifact_options.enabled:
+            from codewiki.src.be.dependency_analyzer.analyzers.artifact import analyze_artifacts
+
+            artifacts = analyze_artifacts(
+                file_tree, repo_dir, result.get("functions", []), artifact_options
+            )
+            result.setdefault("functions", []).extend(n.model_dump() for n in artifacts.nodes)
+            result.setdefault("relationships", []).extend(
+                r.model_dump() for r in artifacts.relationships
+            )
+            result["artifact_index"] = artifacts.index
+            result["call_graph"]["artifact_nodes"] = len(artifacts.nodes)
+
         return result
 
     def _filter_supported_languages(self, code_files: list[dict]) -> list[dict]: