diff --git a/CHANGELOG.md b/CHANGELOG.md
index 445480d..b0877a5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 - `forge exec <skill>` runs skill-bundled scripts through a small synchronous runtime table (`uv run`, `bash`, `deno run`, `node`), injects `FORGE_*`/`INPUT_*` environment, supports JSON stdin/stdout wrapping, dry-runs, and output schema validation.
 - Unknown `forge <verb>` commands now dispatch to external `forge-<verb>` scripts from the module `commands/` directory, configured extension directories, or `PATH`, keeping new capabilities out of the Rust kernel.
 - `forge tui` and bare `forge` under `--features tui` launch a ratatui terminal dashboard over the shared `commands::services` scan model, with artifacts, provenance, projects/ontology placeholder, sources/watch/find panes, and a command palette.
+- `forge tui` now opens an instant Miller-column dashboard at full web-dashboard parity: sections, artifact lists, tabbed artifact detail, provenance chain/deploy groups, ADRs, variants, integrity attention list, search filters/sorts, git history, Settings/Hooks/Config/Schemas file-browser sections, and a `?` help overlay driven by the same keybinding table as the footer hints. Scans run on a background thread so the shell renders immediately while module discovery continues.
 - Model-level qualifier resolution for rules and agents (PROV-0005 Phase 1). Assembly now resolves the full `user/` > `provider/<model>/` > `provider/` > base precedence: a file at `rules/<provider>/<model-id>/Rule.md` overrides the base for that provider and model, and the long-documented `user/` overlay is finally wired for rules and agents too. Each provider gains a default `model` in `defaults.yaml` (an exact ID from `config/models.yaml`); `forge assemble --model <ID>` and `forge install --model <ID>` override it for providers that list that model. Qualifier directory names are validated as exact model IDs: model IDs are no longer split into segments, so a directory named `4` or `6` (from `claude-opus-4-6`) is no longer a valid qualifier, and a model-only file under `rules/<provider>/<model-id>/` is collected instead of silently dropped. An unrecognized model-qualifier subdirectory is skipped with a warning rather than dropped silently. Skill overlays, recording the model in `.manifest`/provenance sidecars, and the per-model release matrix are deferred to Phase 2. (#60)
 - `forge drift --target <BASE>` verifies a module's assembled `build/` against where it was deployed, scoped to the module's own files. It mirrors `forge install --target`: each provider's `build/<provider>` is compared to `<BASE>/<provider-target>`, so files built but not yet deployed surface as local-only, deployment edits surface as frontmatter/body drift, and this module's deployed files (per the target `.manifest` plus provenance attribution) that are no longer built surface as drift. Unlike `--upstream` against a multi-module tree such as `~/.claude`, other modules' files are never reported. `--target` and `--upstream` are mutually exclusive. (#61)
 - `forge validate` sanity-checks Claude Code plugin scaffolding when `.claude-plugin/plugin.json` is present: each manifest (`plugin.json`, `.claude-plugin/marketplace.json`, `hooks/hooks.json`) must be valid JSON, and every hook script referenced via `${CLAUDE_PLUGIN_ROOT}` must exist and be executable (the most common cause of hooks silently not firing). It deliberately makes no assertions about the plugin or marketplace field schema, so it does not break when Claude Code's plugin format changes. Non-plugin modules are unaffected: the check runs only when `plugin.json` exists. (#59)
@@ -19,9 +20,14 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
 ### Changed
 
+- Pure dashboard view builders for nested overview, matrix, variant coverage, deployment grouping, dependency links, and search sorting/filtering moved into `commands::services::builders` so the axum dashboard and TUI share the same rendering inputs.
 - Dashboard scan logic moved from the dashboard binary into `commands::services`, shared by the axum dashboard and reusable by a future TUI with no behavioral change.
 - `forge install` and `forge deploy` default `--target` to `--source` when a `.forge` consumer manifest is present and `--target` is omitted. The consumer dir IS the place the user wants provider trees written; the previous behavior forced redundant `--target .` on every consumer-mode invocation. Module-root flows (no `.forge`) are unchanged: an omitted `--target` still resolves provider directories relative to the current working directory. (#52)
 
+### Deferred
+
+- Line-level annotation export from the TUI Code tab remains follow-up work.
+
 ### Fixed
 
 - `forge provenance` verifies source-side `.provenance/` sidecars, not just deployed targets. Pointed at a source repository or an artifact subdirectory (detected by a `module.yaml` at or above the path), it walks `.provenance/*.yaml`, resolves each `subject.name` to a repo-relative file, recomputes its SHA-256 against the recorded digest, and verifies the digests of in-repo `resolvedDependencies` (the remote `upstream` dependency is left to its recorded pin). Previously the strict typed sidecar model rejected `adopt/v1` sidecars (which carry `upstream_url` rather than `source`) and the directory walk only iterated provider kind roots, so `forge provenance skills/Foo` reported "No provenance found" and source-side drift went undetected. The model now tolerates both `assemble/v1` and `adopt/v1` schemas without changing generated sidecar output, and `--json` emits a machine-readable per-sidecar report. (#44)
diff --git a/src/cli/dashboard/routes/artifact.rs b/src/cli/dashboard/routes/artifact.rs
index fea1499..5a76c03 100644
--- a/src/cli/dashboard/routes/artifact.rs
+++ b/src/cli/dashboard/routes/artifact.rs
@@ -8,9 +8,8 @@ use super::{AppState, DashboardState};
 use crate::cli::dashboard::scan;
 use crate::cli::dashboard::server;
 use crate::cli::dashboard::templates;
-use commands::view::{
-    ArtifactView, DashboardView, DeployGroup, DeployHarness, ModuleView, ProvenanceArtifact,
-};
+use commands::services::builders::{group_deployments, resolve_dep_links};
+use commands::view::{ArtifactView, DashboardView, ModuleView, ProvenanceArtifact};
 
 /// Artifact detail: `/artifact/{module}/{kind}/{name}`. The module qualifier
 /// disambiguates the same artifact present in more than one module (e.g. an
@@ -109,39 +108,6 @@ fn render_artifact(
     Html(template.to_string()).into_response()
 }
 
-/// Resolves each adoption dependency to the module containing a skill of that
-/// name (first match), so the dep chip links to the correct copy. An unresolved
-/// dependency gets an empty module and renders as plain text (no link, no 404).
-pub(super) fn resolve_dep_links(
-    view: &DashboardView,
-    adoption: Option<&commands::view::Adoption>,
-) -> Vec<templates::DepLink> {
-    let Some(adoption) = adoption else {
-        return Vec::new();
-    };
-    adoption
-        .dependencies
-        .iter()
-        .map(|dependency| {
-            let module = view
-                .modules
-                .iter()
-                .find(|candidate| {
-                    candidate
-                        .artifacts
-                        .iter()
-                        .any(|art| art.kind == "skills" && art.name == dependency.name)
-                })
-                .map_or_else(String::new, |candidate| candidate.name.clone());
-            templates::DepLink {
-                name: dependency.name.clone(),
-                uri: dependency.uri.clone(),
-                module,
-            }
-        })
-        .collect()
-}
-
 /// Falls back to the deployed `assemble/v1` sidecar (at the target's
 /// `.provenance/` directory) when an artifact has no source-side adoption
 /// sidecar, so the Provenance "Sidecar" view is available for authored
@@ -293,46 +259,6 @@ pub(super) async fn companion_detail(
     Html(template.to_string()).into_response()
 }
 
-/// Groups deployment provenance entries by target location, so the graph
-/// shows one node per directory (expandable) rather than a flat harness list.
-fn group_deployments(entries: &[&ProvenanceArtifact]) -> Vec<DeployGroup> {
-    let mut order: Vec<String> = Vec::new();
-    let mut groups: std::collections::HashMap<String, DeployGroup> =
-        std::collections::HashMap::new();
-    for entry in entries {
-        let group = groups.entry(entry.target.clone()).or_insert_with(|| {
-            order.push(entry.target.clone());
-            DeployGroup {
-                target: entry.target.clone(),
-                verified: 0,
-                total: 0,
-                harnesses: Vec::new(),
-            }
-        });
-        group.total += 1;
-        if entry.verified {
-            group.verified += 1;
-        }
-        let deployed_dir = entry
-            .deployed_path
-            .rsplit_once('/')
-            .map_or_else(String::new, |(dir, _)| dir.to_string());
-        group.harnesses.push(DeployHarness {
-            harness: entry.harness.clone(),
-            deployed_path: entry.deployed_path.clone(),
-            deployed_dir,
-            verified: entry.verified,
-        });
-    }
-    for group in groups.values_mut() {
-        group.harnesses.sort_by(|a, b| a.harness.cmp(&b.harness));
-    }
-    order
-        .into_iter()
-        .filter_map(|target| groups.remove(&target))
-        .collect()
-}
-
 pub(super) async fn refresh(State(app): State<AppState>) -> impl IntoResponse {
     match server::build_state(&app.root) {
         Ok(new_state) => {
diff --git a/src/cli/dashboard/routes/browse.rs b/src/cli/dashboard/routes/browse.rs
index 0bc378d..daa8829 100644
--- a/src/cli/dashboard/routes/browse.rs
+++ b/src/cli/dashboard/routes/browse.rs
@@ -5,6 +5,7 @@ use serde::Deserialize;
 use super::AppState;
 use super::PAGE_SIZE;
 use crate::cli::dashboard::templates;
+use commands::services::builders::{SearchFilters, search_results};
 use commands::view::ArtifactView;
 
 #[derive(Deserialize)]
@@ -58,11 +59,12 @@ pub(super) async fn overview(
         "comfortable"
     };
     let nested = if layout == "nested" {
-        templates::build_nested(&state.view, primary)
+        commands::services::builders::build_nested(&state.view, primary)
     } else {
         Vec::new()
     };
-    let matrix = (layout == "matrix").then(|| templates::build_matrix(&state.view));
+    let matrix =
+        (layout == "matrix").then(|| commands::services::builders::build_matrix(&state.view));
     let template = templates::OverviewTemplate {
         tab: "overview",
         version: &state.version,
@@ -131,33 +133,14 @@ pub(super) async fn search(
     headers: axum::http::HeaderMap,
 ) -> impl IntoResponse {
     let state = app.shared.read().await;
-    let query_lower = params.query.to_lowercase();
-    let mut matched: Vec<(&ArtifactView, &str)> = state
-        .view
-        .modules
-        .iter()
-        .filter(|module| params.module.is_empty() || module.name == params.module)
-        .flat_map(|module| {
-            module
-                .artifacts
-                .iter()
-                .map(move |artifact| (artifact, module.name.as_str()))
-        })
-        .filter(|(artifact, _)| {
-            if !params.kind.is_empty() && artifact.kind != params.kind {
-                return false;
-            }
-            if !params.status.is_empty() && !matches_status(artifact, &params.status) {
-                return false;
-            }
-            if query_lower.is_empty() {
-                return true;
-            }
-            artifact.matches_query(&query_lower)
-        })
-        .collect();
-
-    sort_results(&mut matched, &params.sort);
+    let filters = SearchFilters {
+        query: params.query.clone(),
+        kind: params.kind.clone(),
+        module: params.module.clone(),
+        status: params.status.clone(),
+        sort: params.sort.clone(),
+    };
+    let matched = search_results(&state.view, &filters);
 
     let total = matched.len();
     let total_pages = total.div_ceil(PAGE_SIZE);
@@ -203,55 +186,3 @@ pub(super) async fn search(
     };
     Html(template.to_string())
 }
-
-/// Sorts matched artifacts in place. `recent` (default) orders by latest commit
-/// date descending; `name` / `module` lexically; `size` by total lines
-/// descending; `age` by oldest commit first; `staleness` by worst signal first
-/// (broken references, then modified, then stale).
-fn sort_results(matched: &mut [(&ArtifactView, &str)], sort: &str) {
-    match sort {
-        "name" => matched.sort_by(|a, b| a.0.name.cmp(&b.0.name)),
-        "module" => matched.sort_by(|a, b| a.1.cmp(b.1).then_with(|| a.0.name.cmp(&b.0.name))),
-        "size" => matched.sort_by(|a, b| {
-            b.0.total_lines()
-                .cmp(&a.0.total_lines())
-                .then_with(|| a.0.name.cmp(&b.0.name))
-        }),
-        "age" => matched.sort_by(|a, b| {
-            // Oldest first; artifacts with no git history sort last.
-            match (a.0.age_days, b.0.age_days) {
-                (Some(left), Some(right)) => right.cmp(&left).then_with(|| a.0.name.cmp(&b.0.name)),
-                (Some(_), None) => std::cmp::Ordering::Less,
-                (None, Some(_)) => std::cmp::Ordering::Greater,
-                (None, None) => a.0.name.cmp(&b.0.name),
-            }
-        }),
-        "staleness" => matched.sort_by(|a, b| {
-            a.0.staleness_rank()
-                .cmp(&b.0.staleness_rank())
-                .reverse()
-                .then_with(|| a.0.name.cmp(&b.0.name))
-        }),
-        _ => matched.sort_by(|a, b| {
-            let a_date = a.0.latest_commit_date();
-            let b_date = b.0.latest_commit_date();
-            match (a_date.is_empty(), b_date.is_empty()) {
-                (true, true) => a.0.name.cmp(&b.0.name),
-                (true, false) => std::cmp::Ordering::Greater,
-                (false, true) => std::cmp::Ordering::Less,
-                (false, false) => b_date.cmp(a_date).then_with(|| a.0.name.cmp(&b.0.name)),
-            }
-        }),
-    }
-}
-
-/// Whether an artifact matches a status filter value. `attention` is a composite
-/// matching anything needing review (broken references, modified, or stale);
-/// other values match `overall_status` exactly.
-fn matches_status(artifact: &ArtifactView, status: &str) -> bool {
-    if status == "attention" {
-        return artifact.has_broken_refs()
-            || matches!(artifact.overall_status(), "modified" | "stale");
-    }
-    artifact.overall_status() == status
-}
diff --git a/src/cli/dashboard/routes/files.rs b/src/cli/dashboard/routes/files.rs
index 5392b41..20de556 100644
--- a/src/cli/dashboard/routes/files.rs
+++ b/src/cli/dashboard/routes/files.rs
@@ -3,24 +3,10 @@ use axum::response::{Html, IntoResponse};
 use std::path::PathBuf;
 
 use super::AppState;
-use super::shared::{display_path, not_found};
+use super::shared::not_found;
 use crate::cli::dashboard::scan;
 use crate::cli::dashboard::templates;
-
-/// Reads a file into a `ConfigFile` if it exists, abbreviating the path with `~`.
-fn read_config_file(
-    label: &str,
-    path: &std::path::Path,
-    language: &str,
-) -> Option<templates::ConfigFile> {
-    let content = std::fs::read_to_string(path).ok()?;
-    Some(templates::ConfigFile {
-        label: label.to_string(),
-        path: display_path(path, dirs::home_dir().as_deref()),
-        language: language.to_string(),
-        content,
-    })
-}
+use commands::services::files as file_services;
 
 /// Builds a grid card for a config file, pointing at its detail route.
 fn file_card(file: &templates::ConfigFile, href: String) -> templates::FileCard {
@@ -51,65 +37,9 @@ fn render_single_file(
     Html(template.to_string()).into_response()
 }
 
-/// Forge-cli's own config files surfaced from `~/.config/forge`. Per-artifact
-/// config there (forensic.yaml, avatar.yaml, ...) holds private identifiers and
-/// is deliberately excluded; only this allowlist is rendered.
-const FORGE_CONFIG_FILES: &[&str] = &[
-    "config.yaml",
-    "config.yml",
-    "config.toml",
-    "config.json",
-    "watchlist.yaml",
-];
-
-/// Forge config files at the scanned root plus the allowlisted forge-cli config
-/// files in `~/.config/forge`, in a stable order so index-based detail routing
-/// stays valid across requests.
-fn collect_dashboard_config_files(root: &std::path::Path) -> Vec<templates::ConfigFile> {
-    let mut files = Vec::new();
-    for (label, name, lang) in [
-        ("Module manifest", "module.yaml", "yaml"),
-        ("Defaults", "defaults.yaml", "yaml"),
-        ("Config override", "config.yaml", "yaml"),
-        ("Consumer manifest", ".forge", "yaml"),
-    ] {
-        if let Some(file) = read_config_file(label, &root.join(name), lang) {
-            files.push(file);
-        }
-    }
-    if let Some(home) = dirs::home_dir() {
-        let forge_dir = home.join(".config/forge");
-        if let Ok(entries) = std::fs::read_dir(&forge_dir) {
-            let mut names: Vec<_> = entries
-                .flatten()
-                .filter(|entry| entry.path().is_file())
-                .map(|entry| entry.file_name().to_string_lossy().to_string())
-                .filter(|name| {
-                    FORGE_CONFIG_FILES
-                        .iter()
-                        .any(|allowed| name.eq_ignore_ascii_case(allowed))
-                })
-                .collect();
-            names.sort();
-            for name in names {
-                let is_toml = std::path::Path::new(&name)
-                    .extension()
-                    .is_some_and(|ext| ext.eq_ignore_ascii_case("toml"));
-                let lang = if is_toml { "toml" } else { "yaml" };
-                if let Some(file) =
-                    read_config_file("~/.config/forge", &forge_dir.join(&name), lang)
-                {
-                    files.push(file);
-                }
-            }
-        }
-    }
-    files
-}
-
 pub(super) async fn settings_page(State(app): State<AppState>) -> impl IntoResponse {
     let state = app.shared.read().await;
-    let groups = settings_by_harness(
+    let groups = file_services::settings_by_harness(
         &app.root,
         &state.provider_targets,
         &state.settings_filenames,
@@ -140,7 +70,7 @@ pub(super) async fn settings_detail(
     Path((harness, index)): Path<(String, usize)>,
 ) -> impl IntoResponse {
     let state = app.shared.read().await;
-    let groups = settings_by_harness(
+    let groups = file_services::settings_by_harness(
         &app.root,
         &state.provider_targets,
         &state.settings_filenames,
@@ -157,7 +87,7 @@ pub(super) async fn settings_detail(
 
 pub(super) async fn hooks_page(State(app): State<AppState>) -> impl IntoResponse {
     let state = app.shared.read().await;
-    let groups = hooks_by_harness(
+    let groups = file_services::hooks_by_harness(
         &app.root,
         &state.provider_targets,
         &state.settings_filenames,
@@ -175,7 +105,7 @@ pub(super) async fn hook_detail(
     Path((harness, index)): Path<(String, usize)>,
 ) -> impl IntoResponse {
     let state = app.shared.read().await;
-    let groups = hooks_by_harness(
+    let groups = file_services::hooks_by_harness(
         &app.root,
         &state.provider_targets,
         &state.settings_filenames,
@@ -188,7 +118,7 @@ pub(super) async fn hook_detail(
         return not_found("Unknown hook.");
     }
     let hook = hooks.remove(index);
-    let (wrapper, command) = unwrap_shell(&hook.command);
+    let (wrapper, command) = file_services::unwrap_shell(&hook.command);
     let template = templates::HookDetailTemplate {
         tab: "hooks",
         version: &state.version,
@@ -202,24 +132,6 @@ pub(super) async fn hook_detail(
     Html(template.to_string()).into_response()
 }
 
-/// Strips a `sh -c '<script>'` / `bash -c "<script>"` wrapper so the inner shell
-/// highlights as code instead of one opaque string. Returns the wrapper label
-/// (empty when none) and the command to display.
-fn unwrap_shell(command: &str) -> (String, String) {
-    let trimmed = command.trim();
-    for program in ["sh", "bash", "zsh"] {
-        for quote in ['\'', '"'] {
-            let prefix = format!("{program} -c {quote}");
-            if let Some(rest) = trimmed.strip_prefix(&prefix)
-                && let Some(inner) = rest.strip_suffix(quote)
-            {
-                return (format!("{program} -c"), inner.to_string());
-            }
-        }
-    }
-    (String::new(), command.to_string())
-}
-
 /// Forge config files plus each harness's settings files, in a stable order so
 /// the index-based detail route stays valid. Harness settings are prefixed with
 /// the harness name to disambiguate user and project copies.
@@ -228,14 +140,7 @@ fn all_config_files(
     provider_targets: &[(String, String)],
     settings_filenames: &[String],
 ) -> Vec<templates::ConfigFile> {
-    let mut files = collect_dashboard_config_files(root);
-    for group in settings_by_harness(root, provider_targets, settings_filenames) {
-        for mut file in group.files {
-            file.label = format!("{} · {}", group.harness, file.label);
-            files.push(file);
-        }
-    }
-    files
+    file_services::collect_dashboard_config_files(root, provider_targets, settings_filenames)
 }
 
 pub(super) async fn config_page(State(app): State<AppState>) -> impl IntoResponse {
@@ -282,7 +187,7 @@ pub(super) async fn config_detail(
 pub(super) async fn schemas_page(State(app): State<AppState>) -> impl IntoResponse {
     let state = app.shared.read().await;
     let allowed = scan::active_repo_names(&state.view.modules, &app.root);
-    let groups = schemas_by_source(
+    let groups = file_services::schemas_by_source(
         &app.root,
         &state.provider_targets,
         &state.local_repos,
@@ -316,7 +221,7 @@ pub(super) async fn schema_file_detail(
 ) -> impl IntoResponse {
     let state = app.shared.read().await;
     let allowed = scan::active_repo_names(&state.view.modules, &app.root);
-    let groups = schemas_by_source(
+    let groups = file_services::schemas_by_source(
         &app.root,
         &state.provider_targets,
         &state.local_repos,
@@ -332,75 +237,6 @@ pub(super) async fn schema_file_detail(
     render_single_file("schemas", files.remove(index), &state.version)
 }
 
-/// Collects `.mdschema` (per artifact kind + decisions) and `.manifest` files,
-/// grouped by source: one group per repo (its schemas + module manifest) and
-/// one per deploy target (its deployed `.manifest`).
-fn schemas_by_source(
-    root: &std::path::Path,
-    provider_targets: &[(String, String)],
-    local_repos: &std::collections::HashMap<String, PathBuf>,
-    allowed: &std::collections::HashSet<String>,
-) -> Vec<templates::SchemaGroup> {
-    let mut groups = Vec::new();
-    let mut repos: Vec<&PathBuf> = local_repos
-        .values()
-        .filter(|path| {
-            path.file_name()
-                .is_some_and(|name| allowed.contains(name.to_string_lossy().as_ref()))
-        })
-        .collect();
-    repos.sort();
-    for repo_path in repos {
-        let mut files = Vec::new();
-        for kind in ["skills", "agents", "rules"] {
-            if let Some(file) = read_config_file(
-                &format!("{kind}/.mdschema"),
-                &repo_path.join(kind).join(".mdschema"),
-                "yaml",
-            ) {
-                files.push(file);
-            }
-        }
-        if let Some(file) = read_config_file(
-            "docs/decisions/.mdschema",
-            &repo_path.join("docs/decisions/.mdschema"),
-            "yaml",
-        ) {
-            files.push(file);
-        }
-        if let Some(file) = read_config_file(".manifest", &repo_path.join(".manifest"), "yaml") {
-            files.push(file);
-        }
-        if !files.is_empty() {
-            let source = repo_path.file_name().map_or_else(
-                || repo_path.display().to_string(),
-                |name| name.to_string_lossy().to_string(),
-            );
-            groups.push(templates::SchemaGroup { source, files });
-        }
-    }
-    let home = dirs::home_dir();
-    for (_harness, target) in provider_targets {
-        let mut bases: Vec<PathBuf> = Vec::new();
-        if let Some(ref home) = home {
-            bases.push(home.clone());
-        }
-        bases.push(root.to_path_buf());
-        for base in bases {
-            let provider_dir = base.join(target);
-            if let Some(file) =
-                read_config_file(".manifest", &provider_dir.join(".manifest"), "yaml")
-            {
-                groups.push(templates::SchemaGroup {
-                    source: format!("deployed: {}", display_path(&provider_dir, home.as_deref())),
-                    files: vec![file],
-                });
-            }
-        }
-    }
-    groups
-}
-
 /// The artifact-kind directory holding a kind's `.mdschema`. ADRs live under
 /// `docs/decisions`; every other kind under its own directory.
 fn schema_dir(kind: &str) -> &str {
@@ -457,10 +293,11 @@ pub(super) async fn schema_page(
         )
             .into_response();
     };
-    let Some(file) = read_config_file(
+    let Some(file) = file_services::read_config_file(
         &format!("{dir}/.mdschema"),
         &repo_path.join(dir).join(".mdschema"),
         "yaml",
+        dirs::home_dir().as_deref(),
     ) else {
         return (
             axum::http::StatusCode::NOT_FOUND,
@@ -478,128 +315,3 @@ pub(super) async fn schema_page(
     };
     Html(template.to_string()).into_response()
 }
-
-/// Settings/config files grouped per harness, auto-detected from each
-/// provider's target directory (user scope then project scope). A harness with
-/// no config files is omitted.
-fn settings_by_harness(
-    root: &std::path::Path,
-    provider_targets: &[(String, String)],
-    allowed: &[String],
-) -> Vec<templates::HarnessFiles> {
-    let home = dirs::home_dir();
-    let mut groups = Vec::new();
-    for (harness, target) in provider_targets {
-        let mut files = Vec::new();
-        if let Some(home) = &home {
-            collect_config_files(&home.join(target), allowed, &mut files);
-        }
-        collect_config_files(&root.join(target), allowed, &mut files);
-        if !files.is_empty() {
-            groups.push(templates::HarnessFiles {
-                harness: harness.clone(),
-                files,
-            });
-        }
-    }
-    groups
-}
-
-/// Hooks grouped per harness, parsed from each harness's JSON settings files.
-fn hooks_by_harness(
-    root: &std::path::Path,
-    provider_targets: &[(String, String)],
-    allowed: &[String],
-) -> Vec<templates::HarnessHooks> {
-    let mut groups = Vec::new();
-    for harness_files in settings_by_harness(root, provider_targets, allowed) {
-        let mut hooks = Vec::new();
-        for file in &harness_files.files {
-            if file.language == "json" {
-                parse_hooks(&file.content, &file.path, &mut hooks);
-            }
-        }
-        if !hooks.is_empty() {
-            groups.push(templates::HarnessHooks {
-                harness: harness_files.harness,
-                hooks,
-            });
-        }
-    }
-    groups
-}
-
-/// Reads allowlisted settings files at the top level of a directory, skipping
-/// artifact subdirectories. The allowlist (from `dashboard.settings_files`)
-/// keeps runtime state, caches, npm manifests, and credential files out of the
-/// view. Files are added in sorted name order.
-fn collect_config_files(
-    dir: &std::path::Path,
-    allowed: &[String],
-    out: &mut Vec<templates::ConfigFile>,
-) {
-    let Ok(entries) = std::fs::read_dir(dir) else {
-        return;
-    };
-    let mut names: Vec<String> = entries
-        .flatten()
-        .filter(|entry| entry.path().is_file())
-        .map(|entry| entry.file_name().to_string_lossy().to_string())
-        .filter(|name| allowed.iter().any(|known| name.eq_ignore_ascii_case(known)))
-        .collect();
-    names.sort();
-    for name in names {
-        if let Some(language) = extension_language(&name)
-            && let Some(file) = read_config_file(&name, &dir.join(&name), language)
-        {
-            out.push(file);
-        }
-    }
-}
-
-/// Maps a filename extension to a highlight language for config files.
-fn extension_language(name: &str) -> Option<&'static str> {
-    let extension = std::path::Path::new(name).extension()?.to_str()?;
-    match extension.to_ascii_lowercase().as_str() {
-        "json" => Some("json"),
-        "toml" => Some("toml"),
-        "yaml" | "yml" => Some("yaml"),
-        _ => None,
-    }
-}
-
-/// Parses a settings.json `hooks` block into flat `HookEntry` rows.
-fn parse_hooks(content: &str, source: &str, out: &mut Vec<templates::HookEntry>) {
-    #[derive(serde::Deserialize)]
-    struct Settings {
-        #[serde(default)]
-        hooks: std::collections::BTreeMap<String, Vec<HookMatcher>>,
-    }
-    #[derive(serde::Deserialize)]
-    struct HookMatcher {
-        #[serde(default)]
-        matcher: String,
-        #[serde(default)]
-        hooks: Vec<HookCommand>,
-    }
-    #[derive(serde::Deserialize)]
-    struct HookCommand {
-        #[serde(default)]
-        command: String,
-    }
-    let Ok(settings) = serde_json::from_str::<Settings>(content) else {
-        return;
-    };
-    for (event, matchers) in settings.hooks {
-        for matcher in matchers {
-            for command in matcher.hooks {
-                out.push(templates::HookEntry {
-                    event: event.clone(),
-                    matcher: matcher.matcher.clone(),
-                    command: command.command,
-                    source: source.to_string(),
-                });
-            }
-        }
-    }
-}
diff --git a/src/cli/dashboard/routes/integrity.rs b/src/cli/dashboard/routes/integrity.rs
index ab05743..e0d1cd9 100644
--- a/src/cli/dashboard/routes/integrity.rs
+++ b/src/cli/dashboard/routes/integrity.rs
@@ -79,7 +79,7 @@ pub(super) async fn adrs_page(State(app): State<AppState>) -> impl IntoResponse
 /// against the targets they cover.
 pub(super) async fn variants_page(State(app): State<AppState>) -> impl IntoResponse {
     let state = app.shared.read().await;
-    let coverage = templates::build_variant_coverage(&state.view);
+    let coverage = commands::services::builders::build_variant_coverage(&state.view);
     let template = templates::VariantsTemplate {
         tab: "variants",
         version: &state.version,
@@ -114,7 +114,8 @@ pub(super) async fn adr_detail(
         &state.local_repos,
     )
     .unwrap_or_default();
-    let dep_links = super::artifact::resolve_dep_links(&state.view, artifact.adoption.as_ref());
+    let dep_links =
+        commands::services::builders::resolve_dep_links(&state.view, artifact.adoption.as_ref());
     let template = templates::ArtifactDetailTemplate {
         tab: "adrs",
         version: &state.version,
diff --git a/src/cli/dashboard/templates/mod.rs b/src/cli/dashboard/templates/mod.rs
index 018e009..f2181a3 100644
--- a/src/cli/dashboard/templates/mod.rs
+++ b/src/cli/dashboard/templates/mod.rs
@@ -1,11 +1,8 @@
-mod builders;
 mod views;
 
-pub use builders::{build_matrix, build_nested, build_variant_coverage};
 pub use views::{
-    AdrsTemplate, ArtifactDetailTemplate, ChromeTemplate, ConfigFile, DepLink, DeployedTemplate,
-    FileCard, FileCardGroup, FileGridTemplate, FilesTemplate, HarnessFiles, HarnessHooks,
-    HookDetailTemplate, HookEntry, HooksTemplate, IntegrityProblem, ModuleDetailTemplate,
-    ModulesTemplate, OverviewTemplate, ProvenanceTemplate, SchemaGroup, SearchPageTemplate,
-    SearchResultsTemplate, VariantsTemplate,
+    AdrsTemplate, ArtifactDetailTemplate, ChromeTemplate, ConfigFile, DeployedTemplate, FileCard,
+    FileCardGroup, FileGridTemplate, FilesTemplate, HookDetailTemplate, HooksTemplate,
+    IntegrityProblem, ModuleDetailTemplate, ModulesTemplate, OverviewTemplate, ProvenanceTemplate,
+    SearchPageTemplate, SearchResultsTemplate, VariantsTemplate,
 };
diff --git a/src/cli/dashboard/templates/views.rs b/src/cli/dashboard/templates/views.rs
index 245472d..a42d492 100644
--- a/src/cli/dashboard/templates/views.rs
+++ b/src/cli/dashboard/templates/views.rs
@@ -1,4 +1,6 @@
 use askama::Template;
+pub use commands::services::builders::{DepLink, MatrixView, NestedGroup, VariantCoverage};
+pub use commands::services::files::{ConfigFile, HarnessHooks};
 use commands::view::{ArtifactView, DashboardView, ModuleView};
 
 /// Shared status + search bar loaded into card-list views via htmx.
@@ -23,48 +25,6 @@ pub struct OverviewTemplate<'a> {
     pub matrix: Option<MatrixView>,
 }
 
-/// A primary-facet section in the nested overview (e.g. one kind, or one module).
-pub struct NestedGroup<'a> {
-    pub label: String,
-    /// Kind name when the outer facet is kind (drives the color class); else empty.
-    pub kind: String,
-    pub count: usize,
-    pub subgroups: Vec<NestedSub<'a>>,
-}
-
-/// A secondary-facet sub-section holding the artifact rows.
-pub struct NestedSub<'a> {
-    pub label: String,
-    pub kind: String,
-    pub count: usize,
-    pub items: Vec<&'a ArtifactView>,
-}
-
-/// Count matrix: rows = modules, columns = kinds, cells = counts.
-pub struct MatrixView {
-    pub cols: Vec<String>,
-    pub rows: Vec<MatrixRow>,
-    pub col_totals: Vec<usize>,
-    pub total: usize,
-}
-
-pub struct MatrixRow {
-    pub module: String,
-    pub cells: Vec<MatrixCell>,
-    pub total: usize,
-}
-
-pub struct MatrixCell {
-    pub kind: String,
-    pub module: String,
-    pub count: usize,
-    /// Worst status among the cell's artifacts, or empty when the cell is empty.
-    pub status: String,
-}
-
-/// Coverage grid for model/harness variants: rows = artifacts that carry at
-/// least one qualifier override, columns = the distinct qualifiers seen across
-/// all such artifacts, cells = the merge mode for that (artifact, qualifier).
 #[derive(Template)]
 #[template(path = "dashboard/pages/variants.html")]
 pub struct VariantsTemplate<'a> {
@@ -73,34 +33,6 @@ pub struct VariantsTemplate<'a> {
     pub coverage: VariantCoverage,
 }
 
-pub struct VariantCoverage {
-    pub cols: Vec<VariantCol>,
-    pub rows: Vec<VariantCoverageRow>,
-    pub col_totals: Vec<usize>,
-}
-
-pub struct VariantCol {
-    pub qualifier: String,
-    /// Provider segment, drives the column tint.
-    pub provider: String,
-    /// Short header label: the model segment, or the provider when there is none.
-    pub label: String,
-}
-
-pub struct VariantCoverageRow {
-    pub module: String,
-    pub kind: String,
-    pub name: String,
-    pub cells: Vec<VariantCoverageCell>,
-}
-
-pub struct VariantCoverageCell {
-    /// Merge mode (`replace`/`append`/`prepend`) when a variant exists, else empty.
-    pub mode: String,
-    /// `/effective/...` link for a present cell, else empty.
-    pub link: String,
-}
-
 #[derive(Template)]
 #[template(path = "dashboard/pages/adrs.html")]
 pub struct AdrsTemplate<'a> {
@@ -125,15 +57,6 @@ pub struct ModuleDetailTemplate<'a> {
     pub module: &'a ModuleView,
 }
 
-/// A resolved adoption dependency: its module is filled in when a scanned
-/// module contains a skill of that name, so the chip can link to the right
-/// copy. An empty module renders as plain text (no link).
-pub struct DepLink {
-    pub name: String,
-    pub uri: String,
-    pub module: String,
-}
-
 #[derive(Template)]
 #[template(path = "dashboard/pages/artifact_detail.html")]
 pub struct ArtifactDetailTemplate<'a> {
@@ -219,40 +142,6 @@ pub struct DeployedTemplate<'a> {
     pub source: String,
 }
 
-/// A read-only config/settings file shown in the dashboard.
-pub struct ConfigFile {
-    pub label: String,
-    pub path: String,
-    pub language: String,
-    pub content: String,
-}
-
-/// One registered hook parsed from a settings.json `hooks` block.
-pub struct HookEntry {
-    pub event: String,
-    pub matcher: String,
-    pub command: String,
-    pub source: String,
-}
-
-/// Settings/config files found in one harness's target directory.
-pub struct HarnessFiles {
-    pub harness: String,
-    pub files: Vec<ConfigFile>,
-}
-
-/// Hooks parsed from one harness's settings files.
-pub struct HarnessHooks {
-    pub harness: String,
-    pub hooks: Vec<HookEntry>,
-}
-
-/// `.mdschema` and `.manifest` files from one source (a repo or a deploy target).
-pub struct SchemaGroup {
-    pub source: String,
-    pub files: Vec<ConfigFile>,
-}
-
 #[derive(Template)]
 #[template(path = "dashboard/pages/files.html")]
 pub struct FilesTemplate<'a> {
diff --git a/src/cli/dashboard/templates/builders.rs b/src/services/builders.rs
similarity index 53%
rename from src/cli/dashboard/templates/builders.rs
rename to src/services/builders.rs
index 22be21b..c508e8a 100644
--- a/src/cli/dashboard/templates/builders.rs
+++ b/src/services/builders.rs
@@ -1,10 +1,101 @@
-use commands::view::{ArtifactView, DashboardView, KIND_ORDER, ModuleView};
+//! Pure dashboard view builders shared by the web UI and terminal UI.
 
-use super::views::{
-    MatrixCell, MatrixRow, MatrixView, NestedGroup, NestedSub, VariantCol, VariantCoverage,
-    VariantCoverageCell, VariantCoverageRow,
+use crate::view::{
+    Adoption, ArtifactView, DashboardView, DeployGroup, DeployHarness, KIND_ORDER, ModuleView,
+    ProvenanceArtifact,
 };
 
+/// A primary-facet section in the nested overview.
+pub struct NestedGroup<'a> {
+    pub label: String,
+    pub kind: String,
+    pub count: usize,
+    pub subgroups: Vec<NestedSub<'a>>,
+}
+
+/// A secondary-facet sub-section holding artifact rows.
+pub struct NestedSub<'a> {
+    pub label: String,
+    pub kind: String,
+    pub count: usize,
+    pub items: Vec<&'a ArtifactView>,
+}
+
+/// Count matrix: rows = modules, columns = kinds, cells = counts.
+pub struct MatrixView {
+    pub cols: Vec<String>,
+    pub rows: Vec<MatrixRow>,
+    pub col_totals: Vec<usize>,
+    pub total: usize,
+}
+
+pub struct MatrixRow {
+    pub module: String,
+    pub cells: Vec<MatrixCell>,
+    pub total: usize,
+}
+
+pub struct MatrixCell {
+    pub kind: String,
+    pub module: String,
+    pub count: usize,
+    pub status: String,
+}
+
+/// Coverage grid for model/harness variants.
+pub struct VariantCoverage {
+    pub cols: Vec<VariantCol>,
+    pub rows: Vec<VariantCoverageRow>,
+    pub col_totals: Vec<usize>,
+}
+
+pub struct VariantCol {
+    pub qualifier: String,
+    pub provider: String,
+    pub label: String,
+}
+
+pub struct VariantCoverageRow {
+    pub module: String,
+    pub kind: String,
+    pub name: String,
+    pub cells: Vec<VariantCoverageCell>,
+}
+
+pub struct VariantCoverageCell {
+    pub mode: String,
+    pub link: String,
+}
+
+/// A resolved adoption dependency.
+pub struct DepLink {
+    pub name: String,
+    pub uri: String,
+    pub module: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SearchFilters {
+    pub query: String,
+    pub kind: String,
+    pub module: String,
+    pub status: String,
+    pub sort: String,
+}
+
+impl SearchFilters {
+    #[must_use]
+    pub fn empty() -> Self {
+        Self {
+            query: String::new(),
+            kind: String::new(),
+            module: String::new(),
+            status: String::new(),
+            sort: String::new(),
+        }
+    }
+}
+
 /// Worst (most attention-worthy) status among a set of artifacts, for a cell dot.
 fn worst_status(items: &[&ArtifactView]) -> String {
     let rank = |status: &str| match status {
@@ -22,15 +113,14 @@ fn worst_status(items: &[&ArtifactView]) -> String {
         .to_string()
 }
 
-/// Builds the nested two-facet grouping. `primary` is the outer facet
-/// (`kind` or `module`); the other facet becomes the inner sub-groups. Only
-/// non-empty groups are emitted, so ragged data produces no empty sections.
+/// Builds the nested two-facet grouping.
+#[must_use]
 pub fn build_nested<'a>(view: &'a DashboardView, primary: &str) -> Vec<NestedGroup<'a>> {
     if primary == "module" {
         view.modules
             .iter()
             .filter_map(|module| {
-                let subgroups: Vec<NestedSub> = KIND_ORDER
+                let subgroups: Vec<NestedSub<'_>> = KIND_ORDER
                     .iter()
                     .filter_map(|&kind| kind_sub(module, kind))
                     .collect();
@@ -41,7 +131,7 @@ pub fn build_nested<'a>(view: &'a DashboardView, primary: &str) -> Vec<NestedGro
         KIND_ORDER
             .iter()
             .filter_map(|&kind| {
-                let subgroups: Vec<NestedSub> = view
+                let subgroups: Vec<NestedSub<'_>> = view
                     .modules
                     .iter()
                     .filter_map(|module| module_sub(module, kind))
@@ -52,8 +142,6 @@ pub fn build_nested<'a>(view: &'a DashboardView, primary: &str) -> Vec<NestedGro
     }
 }
 
-/// A module's artifacts of one kind, largest first (total lines incl. companion
-/// files), so the overview peek surfaces the most substantial artifacts.
 fn items_of_kind<'a>(module: &'a ModuleView, kind: &str) -> Vec<&'a ArtifactView> {
     let mut items: Vec<&ArtifactView> = module
         .artifacts
@@ -88,7 +176,11 @@ fn module_sub<'a>(module: &'a ModuleView, kind: &str) -> Option<NestedSub<'a>> {
     })
 }
 
-fn build_group(label: String, kind: String, subgroups: Vec<NestedSub>) -> Option<NestedGroup> {
+fn build_group(
+    label: String,
+    kind: String,
+    subgroups: Vec<NestedSub<'_>>,
+) -> Option<NestedGroup<'_>> {
     if subgroups.is_empty() {
         return None;
     }
@@ -101,7 +193,7 @@ fn build_group(label: String, kind: String, subgroups: Vec<NestedSub>) -> Option
     })
 }
 
-/// Builds the count matrix (modules × kinds) with row/column totals.
+/// Builds the count matrix (modules x kinds) with row/column totals.
 #[must_use]
 pub fn build_matrix(view: &DashboardView) -> MatrixView {
     let cols: Vec<String> = KIND_ORDER.iter().map(|&kind| kind.to_string()).collect();
@@ -152,9 +244,7 @@ pub fn build_matrix(view: &DashboardView) -> MatrixView {
     }
 }
 
-/// Builds the variant-coverage grid across every artifact that has qualifier
-/// overrides. Columns are sorted so provider-level qualifiers precede their
-/// per-model children (lexical order places `claude` before `claude/...`).
+/// Builds the variant-coverage grid across every artifact that has qualifier overrides.
 #[must_use]
 pub fn build_variant_coverage(view: &DashboardView) -> VariantCoverage {
     let mut qualifiers: Vec<String> = Vec::new();
@@ -171,9 +261,10 @@ pub fn build_variant_coverage(view: &DashboardView) -> VariantCoverage {
     let cols: Vec<VariantCol> = qualifiers
         .iter()
         .map(|qualifier| {
-            let (provider, label) = qualifier
-                .split_once('/')
-                .map_or((qualifier.as_str(), qualifier.as_str()), |(p, m)| (p, m));
+            let (provider, label) = qualifier.split_once('/').map_or(
+                (qualifier.as_str(), qualifier.as_str()),
+                |(provider, model)| (provider, model),
+            );
             VariantCol {
                 qualifier: qualifier.clone(),
                 provider: provider.to_string(),
@@ -230,10 +321,164 @@ pub fn build_variant_coverage(view: &DashboardView) -> VariantCoverage {
     }
 }
 
+/// Resolves each adoption dependency to the module containing a skill of that name.
+#[must_use]
+pub fn resolve_dep_links(view: &DashboardView, adoption: Option<&Adoption>) -> Vec<DepLink> {
+    let Some(adoption) = adoption else {
+        return Vec::new();
+    };
+    adoption
+        .dependencies
+        .iter()
+        .map(|dependency| {
+            let module = view
+                .modules
+                .iter()
+                .find(|candidate| {
+                    candidate.artifacts.iter().any(|artifact| {
+                        artifact.kind == "skills" && artifact.name == dependency.name
+                    })
+                })
+                .map_or_else(String::new, |candidate| candidate.name.clone());
+            DepLink {
+                name: dependency.name.clone(),
+                uri: dependency.uri.clone(),
+                module,
+            }
+        })
+        .collect()
+}
+
+/// Groups deployment provenance entries by target location.
+#[must_use]
+pub fn group_deployments(entries: &[&ProvenanceArtifact]) -> Vec<DeployGroup> {
+    let mut order: Vec<String> = Vec::new();
+    let mut groups: std::collections::HashMap<String, DeployGroup> =
+        std::collections::HashMap::new();
+    for entry in entries {
+        let group = groups.entry(entry.target.clone()).or_insert_with(|| {
+            order.push(entry.target.clone());
+            DeployGroup {
+                target: entry.target.clone(),
+                verified: 0,
+                total: 0,
+                harnesses: Vec::new(),
+            }
+        });
+        group.total += 1;
+        if entry.verified {
+            group.verified += 1;
+        }
+        let deployed_dir = entry
+            .deployed_path
+            .rsplit_once('/')
+            .map_or_else(String::new, |(dir, _)| dir.to_string());
+        group.harnesses.push(DeployHarness {
+            harness: entry.harness.clone(),
+            deployed_path: entry.deployed_path.clone(),
+            deployed_dir,
+            verified: entry.verified,
+        });
+    }
+    for group in groups.values_mut() {
+        group.harnesses.sort_by(|a, b| a.harness.cmp(&b.harness));
+    }
+    order
+        .into_iter()
+        .filter_map(|target| groups.remove(&target))
+        .collect()
+}
+
+/// Whether an artifact matches a status filter value.
+#[must_use]
+pub fn matches_status(artifact: &ArtifactView, status: &str) -> bool {
+    if status == "attention" {
+        return artifact.has_broken_refs()
+            || matches!(artifact.overall_status(), "modified" | "stale");
+    }
+    artifact.overall_status() == status
+}
+
+/// Sorts matched artifacts in place.
+pub fn sort_results(matched: &mut [(&ArtifactView, &str)], sort: &str) {
+    match sort {
+        "name" => matched.sort_by(|a, b| a.0.name.cmp(&b.0.name)),
+        "module" => matched.sort_by(|a, b| a.1.cmp(b.1).then_with(|| a.0.name.cmp(&b.0.name))),
+        "size" => matched.sort_by(|a, b| {
+            b.0.total_lines()
+                .cmp(&a.0.total_lines())
+                .then_with(|| a.0.name.cmp(&b.0.name))
+        }),
+        "age" => matched.sort_by(|a, b| match (a.0.age_days, b.0.age_days) {
+            (Some(left), Some(right)) => right.cmp(&left).then_with(|| a.0.name.cmp(&b.0.name)),
+            (Some(_), None) => std::cmp::Ordering::Less,
+            (None, Some(_)) => std::cmp::Ordering::Greater,
+            (None, None) => a.0.name.cmp(&b.0.name),
+        }),
+        "staleness" => matched.sort_by(|a, b| {
+            a.0.staleness_rank()
+                .cmp(&b.0.staleness_rank())
+                .reverse()
+                .then_with(|| a.0.name.cmp(&b.0.name))
+        }),
+        _ => matched.sort_by(|a, b| {
+            let a_date = a.0.latest_commit_date();
+            let b_date = b.0.latest_commit_date();
+            match (a_date.is_empty(), b_date.is_empty()) {
+                (true, true) => a.0.name.cmp(&b.0.name),
+                (true, false) => std::cmp::Ordering::Greater,
+                (false, true) => std::cmp::Ordering::Less,
+                (false, false) => b_date.cmp(a_date).then_with(|| a.0.name.cmp(&b.0.name)),
+            }
+        }),
+    }
+}
+
+/// Returns filtered and sorted artifact refs for search surfaces.
+#[must_use]
+pub fn search_results<'a>(
+    view: &'a DashboardView,
+    filters: &SearchFilters,
+) -> Vec<(&'a ArtifactView, &'a str)> {
+    let query_lower = filters.query.to_lowercase();
+    let mut matched: Vec<(&ArtifactView, &str)> = view
+        .modules
+        .iter()
+        .filter(|module| filters.module.is_empty() || module.name == filters.module)
+        .flat_map(|module| {
+            module
+                .artifacts
+                .iter()
+                .map(move |artifact| (artifact, module.name.as_str()))
+        })
+        .filter(|(artifact, _)| {
+            if !filters.kind.is_empty() && artifact.kind != filters.kind {
+                return false;
+            }
+            if !filters.status.is_empty() && !matches_status(artifact, &filters.status) {
+                return false;
+            }
+            query_lower.is_empty() || artifact.matches_query(&query_lower)
+        })
+        .collect();
+    sort_results(&mut matched, &filters.sort);
+    matched
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use commands::view::{StatusSummary, Variant};
+    use crate::view::{StatusSummary, Variant};
+
+    fn artifact(kind: &str, name: &str, lines: &str) -> ArtifactView {
+        ArtifactView {
+            name: name.to_string(),
+            kind: kind.to_string(),
+            relative_path: format!("{kind}/{name}.md"),
+            raw_source: lines.to_string(),
+            ..Default::default()
+        }
+    }
 
     fn variant(qualifier: &str, provider: &str, model: &str, mode: &str) -> Variant {
         Variant {
@@ -275,6 +520,44 @@ mod tests {
         }
     }
 
+    #[test]
+    fn nested_groups_by_kind_with_largest_items_first() {
+        let overview = view(vec![module(
+            "forge-core",
+            vec![
+                artifact("skills", "Small", "one"),
+                artifact("skills", "Large", "one\ntwo\nthree"),
+                artifact("rules", "Rule", "one"),
+            ],
+        )]);
+
+        let nested = build_nested(&overview, "kind");
+
+        assert_eq!(nested[0].label, "skills");
+        assert_eq!(nested[0].count, 2);
+        assert_eq!(nested[0].subgroups[0].label, "forge-core");
+        assert_eq!(nested[0].subgroups[0].items[0].name, "Large");
+        assert_eq!(nested[1].label, "rules");
+    }
+
+    #[test]
+    fn matrix_counts_modules_by_kind() {
+        let matrix = build_matrix(&view(vec![module(
+            "forge-core",
+            vec![
+                artifact("skills", "BuildSkill", "one"),
+                artifact("rules", "Rule", "one"),
+            ],
+        )]));
+
+        assert_eq!(matrix.cols, vec!["skills", "agents", "rules"]);
+        assert_eq!(matrix.rows[0].module, "forge-core");
+        assert_eq!(matrix.rows[0].cells[0].count, 1);
+        assert_eq!(matrix.rows[0].cells[1].count, 0);
+        assert_eq!(matrix.rows[0].cells[2].count, 1);
+        assert_eq!(matrix.total, 2);
+    }
+
     #[test]
     fn coverage_excludes_artifacts_without_variants() {
         let covered = rule_with_variants(
@@ -360,12 +643,11 @@ mod tests {
             vec![with_model, provider_only],
         )]));
 
-        // Columns: ["claude", "claude/claude-opus-4-8"]; HasModel has no "claude" cell.
         let has_model = coverage
             .rows
             .iter()
             .find(|row| row.name == "HasModel")
-            .unwrap();
+            .expect("variant row");
         assert!(has_model.cells[0].mode.is_empty());
         assert!(has_model.cells[0].link.is_empty());
         assert_eq!(has_model.cells[1].mode, "replace");
diff --git a/src/services/files.rs b/src/services/files.rs
new file mode 100644
index 0000000..869e1ec
--- /dev/null
+++ b/src/services/files.rs
@@ -0,0 +1,569 @@
+//! Filesystem-only dashboard file discovery.
+//!
+//! These helpers collect config, settings, hook, schema, and manifest files for
+//! both the web dashboard and the TUI. They do not depend on any web framework
+//! state and only read allowlisted filesystem paths.
+
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+
+/// A read-only config/settings/schema file shown by dashboard surfaces.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConfigFile {
+    pub label: String,
+    pub path: String,
+    pub language: String,
+    pub content: String,
+}
+
+/// One registered hook parsed from a settings.json `hooks` block.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HookEntry {
+    pub event: String,
+    pub matcher: String,
+    pub command: String,
+    pub source: String,
+}
+
+/// Settings/config files found in one harness's target directory.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HarnessFiles {
+    pub harness: String,
+    pub files: Vec<ConfigFile>,
+}
+
+/// Hooks parsed from one harness's settings files.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HarnessHooks {
+    pub harness: String,
+    pub hooks: Vec<HookEntry>,
+}
+
+/// `.mdschema` and `.manifest` files from one source.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SchemaGroup {
+    pub source: String,
+    pub files: Vec<ConfigFile>,
+}
+
+/// File collections backing the TUI's file-browser sections.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct FileSections {
+    pub settings: Vec<HarnessFiles>,
+    pub hooks: Vec<HarnessHooks>,
+    pub config: Vec<ConfigFile>,
+    pub schemas: Vec<SchemaGroup>,
+}
+
+/// Forge-cli's own config files surfaced from `~/.config/forge`.
+const FORGE_CONFIG_FILES: &[&str] = &[
+    "config.yaml",
+    "config.yml",
+    "config.toml",
+    "config.json",
+    "watchlist.yaml",
+];
+
+/// Builds all file-browser collections for a scanned root.
+#[must_use]
+pub fn collect_file_sections(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    settings_filenames: &[String],
+    local_repos: &HashMap<String, PathBuf>,
+    allowed_sources: &HashSet<String>,
+) -> FileSections {
+    let settings = settings_by_harness(root, provider_targets, settings_filenames);
+    let hooks = hooks_from_settings(&settings);
+    let mut config = collect_forge_config_files(root);
+    for group in &settings {
+        for mut file in group.files.clone() {
+            file.label = format!("{} · {}", group.harness, file.label);
+            config.push(file);
+        }
+    }
+    let schemas = schemas_by_source(root, provider_targets, local_repos, allowed_sources);
+    FileSections {
+        settings,
+        hooks,
+        config,
+        schemas,
+    }
+}
+
+/// Forge config files plus each harness's settings files as a flat list.
+#[must_use]
+pub fn collect_dashboard_config_files(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    settings_filenames: &[String],
+) -> Vec<ConfigFile> {
+    collect_dashboard_config_files_with_home(
+        root,
+        provider_targets,
+        settings_filenames,
+        dirs::home_dir().as_deref(),
+    )
+}
+
+/// Full dashboard config list using an explicit home directory, useful for tests.
+#[must_use]
+pub fn collect_dashboard_config_files_with_home(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    settings_filenames: &[String],
+    home: Option<&Path>,
+) -> Vec<ConfigFile> {
+    let mut files = collect_forge_config_files_with_home(root, home);
+    for group in settings_by_harness_with_home(root, provider_targets, settings_filenames, home) {
+        for mut file in group.files {
+            file.label = format!("{} · {}", group.harness, file.label);
+            files.push(file);
+        }
+    }
+    files
+}
+
+/// Forge config files at the scanned root plus allowlisted forge config files.
+#[must_use]
+pub fn collect_forge_config_files(root: &Path) -> Vec<ConfigFile> {
+    collect_forge_config_files_with_home(root, dirs::home_dir().as_deref())
+}
+
+/// Forge config files using an explicit home directory, useful for tests.
+#[must_use]
+pub fn collect_forge_config_files_with_home(root: &Path, home: Option<&Path>) -> Vec<ConfigFile> {
+    let mut files = Vec::new();
+    for (label, name, lang) in [
+        ("Module manifest", "module.yaml", "yaml"),
+        ("Defaults", "defaults.yaml", "yaml"),
+        ("Config override", "config.yaml", "yaml"),
+        ("Consumer manifest", ".forge", "yaml"),
+    ] {
+        if let Some(file) = read_config_file(label, &root.join(name), lang, home) {
+            files.push(file);
+        }
+    }
+    if let Some(home) = home {
+        let forge_dir = home.join(".config/forge");
+        if let Ok(entries) = std::fs::read_dir(&forge_dir) {
+            let mut names: Vec<_> = entries
+                .flatten()
+                .filter(|entry| entry.file_type().is_ok_and(|file_type| file_type.is_file()))
+                .map(|entry| entry.file_name().to_string_lossy().to_string())
+                .filter(|name| {
+                    FORGE_CONFIG_FILES
+                        .iter()
+                        .any(|allowed| name.eq_ignore_ascii_case(allowed))
+                })
+                .collect();
+            names.sort();
+            for name in names {
+                let is_toml = Path::new(&name)
+                    .extension()
+                    .is_some_and(|ext| ext.eq_ignore_ascii_case("toml"));
+                let lang = if is_toml { "toml" } else { "yaml" };
+                if let Some(file) =
+                    read_config_file("~/.config/forge", &forge_dir.join(&name), lang, Some(home))
+                {
+                    files.push(file);
+                }
+            }
+        }
+    }
+    files
+}
+
+/// Settings/config files grouped per harness.
+#[must_use]
+pub fn settings_by_harness(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    allowed: &[String],
+) -> Vec<HarnessFiles> {
+    settings_by_harness_with_home(root, provider_targets, allowed, dirs::home_dir().as_deref())
+}
+
+/// Settings/config files grouped per harness using an explicit home directory.
+#[must_use]
+pub fn settings_by_harness_with_home(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    allowed: &[String],
+    home: Option<&Path>,
+) -> Vec<HarnessFiles> {
+    let mut groups = Vec::new();
+    for (harness, target) in provider_targets {
+        let mut files = Vec::new();
+        if let Some(home) = home {
+            collect_config_files(&home.join(target), allowed, &mut files, Some(home));
+        }
+        collect_config_files(&root.join(target), allowed, &mut files, home);
+        if !files.is_empty() {
+            groups.push(HarnessFiles {
+                harness: harness.clone(),
+                files,
+            });
+        }
+    }
+    groups
+}
+
+/// Hooks grouped per harness, parsed from each harness's JSON settings files.
+#[must_use]
+pub fn hooks_by_harness(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    allowed: &[String],
+) -> Vec<HarnessHooks> {
+    hooks_from_settings(&settings_by_harness(root, provider_targets, allowed))
+}
+
+/// Hooks grouped per harness from a precomputed settings collection.
+#[must_use]
+pub fn hooks_from_settings(settings: &[HarnessFiles]) -> Vec<HarnessHooks> {
+    let mut groups = Vec::new();
+    for harness_files in settings {
+        let mut hooks = Vec::new();
+        for file in &harness_files.files {
+            if file.language == "json" {
+                parse_hooks(&file.content, &file.path, &mut hooks);
+            }
+        }
+        if !hooks.is_empty() {
+            groups.push(HarnessHooks {
+                harness: harness_files.harness.clone(),
+                hooks,
+            });
+        }
+    }
+    groups
+}
+
+/// Collects `.mdschema` and `.manifest` files, grouped by source.
+#[must_use]
+pub fn schemas_by_source(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    local_repos: &HashMap<String, PathBuf>,
+    allowed: &HashSet<String>,
+) -> Vec<SchemaGroup> {
+    let home = dirs::home_dir();
+    schemas_by_source_with_home(
+        root,
+        provider_targets,
+        local_repos,
+        allowed,
+        home.as_deref(),
+    )
+}
+
+/// Collects schemas using an explicit home directory, useful for tests.
+#[must_use]
+pub fn schemas_by_source_with_home(
+    root: &Path,
+    provider_targets: &[(String, String)],
+    local_repos: &HashMap<String, PathBuf>,
+    allowed: &HashSet<String>,
+    home: Option<&Path>,
+) -> Vec<SchemaGroup> {
+    let mut groups = Vec::new();
+    let mut repos: Vec<&PathBuf> = local_repos
+        .values()
+        .filter(|path| {
+            path.file_name()
+                .is_some_and(|name| allowed.contains(name.to_string_lossy().as_ref()))
+        })
+        .collect();
+    repos.sort();
+    for repo_path in repos {
+        let mut files = Vec::new();
+        for kind in ["skills", "agents", "rules"] {
+            if let Some(file) = read_config_file(
+                &format!("{kind}/.mdschema"),
+                &repo_path.join(kind).join(".mdschema"),
+                "yaml",
+                home,
+            ) {
+                files.push(file);
+            }
+        }
+        if let Some(file) = read_config_file(
+            "docs/decisions/.mdschema",
+            &repo_path.join("docs/decisions/.mdschema"),
+            "yaml",
+            home,
+        ) {
+            files.push(file);
+        }
+        if let Some(file) =
+            read_config_file(".manifest", &repo_path.join(".manifest"), "yaml", home)
+        {
+            files.push(file);
+        }
+        if !files.is_empty() {
+            let source = repo_path.file_name().map_or_else(
+                || repo_path.display().to_string(),
+                |name| name.to_string_lossy().to_string(),
+            );
+            groups.push(SchemaGroup { source, files });
+        }
+    }
+    for (_harness, target) in provider_targets {
+        let mut bases: Vec<PathBuf> = Vec::new();
+        if let Some(home) = home {
+            bases.push(home.to_path_buf());
+        }
+        bases.push(root.to_path_buf());
+        for base in bases {
+            let provider_dir = base.join(target);
+            if let Some(file) =
+                read_config_file(".manifest", &provider_dir.join(".manifest"), "yaml", home)
+            {
+                groups.push(SchemaGroup {
+                    source: format!("deployed: {}", display_path(&provider_dir, home)),
+                    files: vec![file],
+                });
+            }
+        }
+    }
+    groups
+}
+
+/// Strips a `sh -c '<script>'` / `bash -c "<script>"` wrapper.
+#[must_use]
+pub fn unwrap_shell(command: &str) -> (String, String) {
+    let trimmed = command.trim();
+    for program in ["sh", "bash", "zsh"] {
+        for quote in ['\'', '"'] {
+            let prefix = format!("{program} -c {quote}");
+            if let Some(rest) = trimmed.strip_prefix(&prefix)
+                && let Some(inner) = rest.strip_suffix(quote)
+            {
+                return (format!("{program} -c"), inner.to_string());
+            }
+        }
+    }
+    (String::new(), command.to_string())
+}
+
+/// Parses a settings.json `hooks` block into flat `HookEntry` rows.
+pub fn parse_hooks(content: &str, source: &str, out: &mut Vec<HookEntry>) {
+    #[derive(serde::Deserialize)]
+    struct Settings {
+        #[serde(default)]
+        hooks: std::collections::BTreeMap<String, Vec<HookMatcher>>,
+    }
+    #[derive(serde::Deserialize)]
+    struct HookMatcher {
+        #[serde(default)]
+        matcher: String,
+        #[serde(default)]
+        hooks: Vec<HookCommand>,
+    }
+    #[derive(serde::Deserialize)]
+    struct HookCommand {
+        #[serde(default)]
+        command: String,
+    }
+    let Ok(settings) = serde_json::from_str::<Settings>(content) else {
+        return;
+    };
+    for (event, matchers) in settings.hooks {
+        for matcher in matchers {
+            for command in matcher.hooks {
+                out.push(HookEntry {
+                    event: event.clone(),
+                    matcher: matcher.matcher.clone(),
+                    command: command.command,
+                    source: source.to_string(),
+                });
+            }
+        }
+    }
+}
+
+/// Hard cap on a browsed config file (2 MiB): config/settings/schema files are
+/// small, and this bounds memory against an oversized or adversarial file.
+const MAX_CONFIG_BYTES: u64 = 2 * 1024 * 1024;
+
+/// Read a file to a string only if it is a regular file (not a symlink) and
+/// within the size cap. `symlink_metadata` does not follow the final component,
+/// so a symlink with an allowlisted name cannot redirect the read to a
+/// sensitive file outside the intended directory (path-boundary validation).
+fn read_regular_file_capped(path: &Path) -> Option<String> {
+    let metadata = std::fs::symlink_metadata(path).ok()?;
+    if !metadata.file_type().is_file() || metadata.len() > MAX_CONFIG_BYTES {
+        return None;
+    }
+    std::fs::read_to_string(path).ok()
+}
+
+/// Reads a file into a `ConfigFile` if it exists, abbreviating the path with `~`.
+#[must_use]
+pub fn read_config_file(
+    label: &str,
+    path: &Path,
+    language: &str,
+    home: Option<&Path>,
+) -> Option<ConfigFile> {
+    let content = read_regular_file_capped(path)?;
+    Some(ConfigFile {
+        label: label.to_string(),
+        path: display_path(path, home),
+        language: language.to_string(),
+        content,
+    })
+}
+
+fn collect_config_files(
+    dir: &Path,
+    allowed: &[String],
+    out: &mut Vec<ConfigFile>,
+    home: Option<&Path>,
+) {
+    let Ok(entries) = std::fs::read_dir(dir) else {
+        return;
+    };
+    let mut names: Vec<String> = entries
+        .flatten()
+        .filter(|entry| entry.file_type().is_ok_and(|file_type| file_type.is_file()))
+        .map(|entry| entry.file_name().to_string_lossy().to_string())
+        .filter(|name| allowed.iter().any(|known| name.eq_ignore_ascii_case(known)))
+        .collect();
+    names.sort();
+    for name in names {
+        if let Some(language) = extension_language(&name)
+            && let Some(file) = read_config_file(&name, &dir.join(&name), language, home)
+        {
+            out.push(file);
+        }
+    }
+}
+
+fn extension_language(name: &str) -> Option<&'static str> {
+    let extension = Path::new(name).extension()?.to_str()?;
+    match extension.to_ascii_lowercase().as_str() {
+        "json" => Some("json"),
+        "toml" => Some("toml"),
+        "yaml" | "yml" => Some("yaml"),
+        _ => None,
+    }
+}
+
+fn display_path(path: &Path, home: Option<&Path>) -> String {
+    if let Some(home) = home
+        && let Ok(rest) = path.strip_prefix(home)
+    {
+        return format!("~/{}", rest.display());
+    }
+    path.display().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[cfg(unix)]
+    #[test]
+    fn read_config_file_rejects_symlink_and_oversized() {
+        let temp = tempfile::tempdir().expect("tempdir");
+        let secret = temp.path().join("secret");
+        std::fs::write(&secret, "TOP SECRET\n").expect("secret");
+        let link = temp.path().join("settings.json");
+        std::os::unix::fs::symlink(&secret, &link).expect("symlink");
+        assert!(
+            read_config_file("settings", &link, "json", None).is_none(),
+            "a symlink with an allowlisted name must not be read through"
+        );
+
+        let real = temp.path().join("real.json");
+        std::fs::write(&real, "{}\n").expect("real");
+        assert!(read_config_file("settings", &real, "json", None).is_some());
+    }
+
+    #[test]
+    fn settings_and_hooks_use_allowlisted_fixture_files() {
+        let temp = tempfile::tempdir().expect("tempdir");
+        let home = temp.path().join("home");
+        let root = temp.path().join("project");
+        let settings_dir = home.join(".claude");
+        std::fs::create_dir_all(&settings_dir).expect("settings dir");
+        std::fs::create_dir_all(&root).expect("root dir");
+        std::fs::write(
+            settings_dir.join("settings.json"),
+            r#"{
+              "hooks": {
+                "PreToolUse": [
+                  {
+                    "matcher": "Write",
+                    "hooks": [
+                      { "command": "bash -c 'echo fixture-hook'" }
+                    ]
+                  }
+                ]
+              }
+            }"#,
+        )
+        .expect("settings file");
+        std::fs::write(settings_dir.join("ignored.env"), "SECRET=ignored").expect("ignored file");
+
+        let providers = vec![("claude".to_string(), ".claude".to_string())];
+        let allowed = vec!["settings.json".to_string()];
+        let settings = settings_by_harness_with_home(&root, &providers, &allowed, Some(&home));
+        assert_eq!(settings.len(), 1);
+        assert_eq!(settings[0].files[0].label, "settings.json");
+        assert!(settings[0].files[0].content.contains("fixture-hook"));
+
+        let hooks = hooks_from_settings(&settings);
+        assert_eq!(hooks.len(), 1);
+        assert_eq!(hooks[0].hooks[0].matcher, "Write");
+        assert!(hooks[0].hooks[0].command.contains("fixture-hook"));
+    }
+
+    #[test]
+    fn config_and_schema_collections_include_fixture_content() {
+        let temp = tempfile::tempdir().expect("tempdir");
+        let home = temp.path().join("home");
+        let root = temp.path().join("project");
+        let repo = temp.path().join("forge-core");
+        std::fs::create_dir_all(home.join(".config/forge")).expect("forge config dir");
+        std::fs::create_dir_all(repo.join("skills")).expect("schema dir");
+        std::fs::create_dir_all(root.join(".claude")).expect("target dir");
+        std::fs::write(root.join("module.yaml"), "name: fixture\n").expect("module");
+        std::fs::write(home.join(".config/forge/config.toml"), "theme = 'dark'\n")
+            .expect("forge config");
+        std::fs::write(repo.join("skills/.mdschema"), "kind: skills\n").expect("schema");
+        std::fs::write(root.join(".claude/.manifest"), "skills: {}\n").expect("manifest");
+
+        let providers = vec![("claude".to_string(), ".claude".to_string())];
+        let settings_filenames = vec!["settings.json".to_string()];
+        let config = collect_dashboard_config_files_with_home(
+            &root,
+            &providers,
+            &settings_filenames,
+            Some(&home),
+        );
+        assert!(config.iter().any(|file| file.path.ends_with("module.yaml")));
+        assert!(config.iter().any(|file| file.content.contains("theme")));
+
+        let mut local_repos = HashMap::new();
+        local_repos.insert("forge-core".to_string(), repo);
+        let allowed = HashSet::from(["forge-core".to_string()]);
+        let schemas =
+            schemas_by_source_with_home(&root, &providers, &local_repos, &allowed, Some(&home));
+        assert!(schemas.iter().any(|group| group.source == "forge-core"));
+        assert!(
+            schemas
+                .iter()
+                .flat_map(|group| &group.files)
+                .any(|file| file.content.contains("kind: skills"))
+        );
+        assert!(
+            schemas
+                .iter()
+                .any(|group| group.source.contains("deployed:")
+                    && group.files[0].content.contains("skills"))
+        );
+    }
+}
diff --git a/src/services/mod.rs b/src/services/mod.rs
index ccfc4af..0a410f9 100644
--- a/src/services/mod.rs
+++ b/src/services/mod.rs
@@ -6,7 +6,9 @@
 //! and groups artifacts by their source module (via provenance `source_uri`).
 
 mod adr;
+pub mod builders;
 mod discovery;
+pub mod files;
 mod history;
 mod provenance;
 mod references;
diff --git a/src/tui/app.rs b/src/tui/app.rs
index 31b7b5c..0a42caa 100644
--- a/src/tui/app.rs
+++ b/src/tui/app.rs
@@ -1,58 +1,367 @@
-use std::path::{Path, PathBuf};
+use std::{
+    path::{Path, PathBuf},
+    sync::mpsc::{self, Receiver},
+    thread,
+};
 
-use crossterm::event::KeyEvent;
+use crossterm::event::{KeyCode, KeyEvent};
 use ratatui::{
     Frame,
-    layout::{Constraint, Direction, Layout},
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Color, Modifier, Style},
+    text::{Line, Span, Text},
+    widgets::{Block, Borders, Clear, List, ListItem, Paragraph, Wrap},
 };
 
-use commands::{error::Error, services, view::DashboardView};
+use commands::{
+    services::{
+        self, builders,
+        files::{self, FileSections},
+    },
+    view::{Adr, ArtifactView, DashboardView, ModuleView, ProvenanceArtifact, StatusSummary},
+};
 
 use crate::cli::{config, watchlist};
 
 use super::components::{
-    Component,
-    artifacts::ArtifactsPane,
     palette::{Palette, PaletteCommand},
     preview::ArtifactPreview,
-    projects::ProjectsPane,
-    provenance::ProvenancePane,
-    sources::SourcesPane,
 };
 
-const PANE_COUNT: usize = 4;
+const SECTION_COUNT: usize = 13;
+const DETAIL_TAB_COUNT: usize = 7;
+
+pub const KEYBINDINGS: &[(&str, &[(&str, &str)])] = &[
+    (
+        "Navigation",
+        &[
+            ("h/j/k/l", "move, drill, and go back"),
+            ("arrows", "move, drill, and go back"),
+            ("Tab", "next column or detail tab"),
+            ("BackTab", "previous column"),
+            ("Enter", "drill or expand detail"),
+            ("Esc", "back, close overlay, or quit"),
+            ("g/G", "top or bottom"),
+            ("PgUp/PgDn", "scroll detail"),
+        ],
+    ),
+    (
+        "Sections",
+        &[
+            ("1", "overview"),
+            ("2", "skills"),
+            ("3", "agents"),
+            ("4", "rules"),
+            ("5", "repositories"),
+            ("6", "ADRs"),
+            ("7", "provenance"),
+            ("8", "variants"),
+            ("9", "search"),
+            ("t", "settings"),
+            ("h", "hooks"),
+            ("c", "config"),
+            ("m", "schemas"),
+        ],
+    ),
+    (
+        "Actions",
+        &[
+            ("/", "search"),
+            (":", "palette"),
+            ("r", "refresh"),
+            ("y", "copy install snippet or path"),
+            ("d", "diff tab"),
+            ("c", "code tab"),
+            ("p", "preview tab"),
+        ],
+    ),
+    ("Global", &[("?", "help"), ("F1", "help"), ("q", "quit")]),
+];
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ColumnFocus {
+    Sections,
+    List,
+    Detail,
+}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Pane {
-    Artifacts = 0,
-    Provenance = 1,
-    Projects = 2,
-    Sources = 3,
+pub enum Section {
+    Overview = 0,
+    Skills = 1,
+    Agents = 2,
+    Rules = 3,
+    Repositories = 4,
+    Adrs = 5,
+    Provenance = 6,
+    Variants = 7,
+    Search = 8,
+    Settings = 9,
+    Hooks = 10,
+    Config = 11,
+    Schemas = 12,
+}
+
+impl Section {
+    const ALL: [Self; SECTION_COUNT] = [
+        Self::Overview,
+        Self::Skills,
+        Self::Agents,
+        Self::Rules,
+        Self::Repositories,
+        Self::Adrs,
+        Self::Provenance,
+        Self::Variants,
+        Self::Search,
+        Self::Settings,
+        Self::Hooks,
+        Self::Config,
+        Self::Schemas,
+    ];
+
+    fn label(self) -> &'static str {
+        match self {
+            Self::Overview => "Overview",
+            Self::Skills => "Skills",
+            Self::Agents => "Agents",
+            Self::Rules => "Rules",
+            Self::Repositories => "Repositories",
+            Self::Adrs => "ADRs",
+            Self::Provenance => "Provenance",
+            Self::Variants => "Variants",
+            Self::Search => "Search",
+            Self::Settings => "Settings",
+            Self::Hooks => "Hooks",
+            Self::Config => "Config",
+            Self::Schemas => "Schemas",
+        }
+    }
+
+    fn from_index(index: usize) -> Self {
+        Self::ALL[index.min(SECTION_COUNT - 1)]
+    }
+
+    fn from_name(name: &str) -> Option<Self> {
+        match name {
+            "overview" | "o" => Some(Self::Overview),
+            "skills" | "skill" | "s" => Some(Self::Skills),
+            "agents" | "agent" | "a" => Some(Self::Agents),
+            "rules" | "rule" => Some(Self::Rules),
+            "repos" | "repositories" | "repository" => Some(Self::Repositories),
+            "adrs" | "adr" => Some(Self::Adrs),
+            "provenance" | "integrity" => Some(Self::Provenance),
+            "variants" | "variant" => Some(Self::Variants),
+            "search" | "find" => Some(Self::Search),
+            "settings" | "setting" => Some(Self::Settings),
+            "hooks" | "hook" => Some(Self::Hooks),
+            "config" | "configuration" => Some(Self::Config),
+            "schemas" | "schema" | "manifests" | "manifest" => Some(Self::Schemas),
+            _ => None,
+        }
+    }
+
+    fn from_shortcut(character: char) -> Option<Self> {
+        match character {
+            '1' => Some(Self::Overview),
+            '2' => Some(Self::Skills),
+            '3' => Some(Self::Agents),
+            '4' => Some(Self::Rules),
+            '5' => Some(Self::Repositories),
+            '6' => Some(Self::Adrs),
+            '7' => Some(Self::Provenance),
+            '8' => Some(Self::Variants),
+            '9' => Some(Self::Search),
+            't' | 'T' => Some(Self::Settings),
+            'h' | 'H' => Some(Self::Hooks),
+            'c' | 'C' => Some(Self::Config),
+            'm' | 'M' => Some(Self::Schemas),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum DetailTab {
+    Preview = 0,
+    Code = 1,
+    Diff = 2,
+    Provenance = 3,
+    Frontmatter = 4,
+    History = 5,
+    Companions = 6,
+}
+
+impl DetailTab {
+    const ALL: [Self; DETAIL_TAB_COUNT] = [
+        Self::Preview,
+        Self::Code,
+        Self::Diff,
+        Self::Provenance,
+        Self::Frontmatter,
+        Self::History,
+        Self::Companions,
+    ];
+
+    fn label(self) -> &'static str {
+        match self {
+            Self::Preview => "Preview",
+            Self::Code => "Code",
+            Self::Diff => "Diff",
+            Self::Provenance => "Provenance",
+            Self::Frontmatter => "Frontmatter",
+            Self::History => "History",
+            Self::Companions => "Companions",
+        }
+    }
+
+    fn from_index(index: usize) -> Self {
+        Self::ALL[index.min(DETAIL_TAB_COUNT - 1)]
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ScanState {
+    Idle,
+    Loading,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum RunState {
+    Running,
+    Quit,
+}
+
+struct ScanResult {
+    providers: Vec<(String, String)>,
+    watched_locations: Vec<PathBuf>,
+    view: DashboardView,
+    file_sections: FileSections,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum OverviewMode {
+    Nested,
+    Matrix,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum HelpState {
+    Closed,
+    Open,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum ListTarget {
+    None,
+    Overview,
+    Artifact {
+        module: String,
+        kind: String,
+        name: String,
+    },
+    Module(String),
+    Adr {
+        repo: String,
+        id: String,
+    },
+    ProvenanceArtifact {
+        module: String,
+        kind: String,
+        name: String,
+    },
+    Variant {
+        module: String,
+        kind: String,
+        name: String,
+        qualifier: String,
+    },
+    SettingsFile {
+        group: usize,
+        index: usize,
+    },
+    Hook {
+        group: usize,
+        index: usize,
+    },
+    ConfigFile(usize),
+    SchemaFile {
+        group: usize,
+        index: usize,
+    },
 }
 
 #[derive(Debug, Clone)]
+struct ListRow {
+    label: String,
+    detail: String,
+    target: ListTarget,
+    header: bool,
+    status: &'static str,
+}
+
+impl ListRow {
+    fn header(label: impl Into<String>) -> Self {
+        Self {
+            label: label.into(),
+            detail: String::new(),
+            target: ListTarget::None,
+            header: true,
+            status: "source",
+        }
+    }
+
+    fn item(
+        label: impl Into<String>,
+        detail: impl Into<String>,
+        target: ListTarget,
+        status: &'static str,
+    ) -> Self {
+        Self {
+            label: label.into(),
+            detail: detail.into(),
+            target,
+            header: false,
+            status,
+        }
+    }
+
+    fn is_selectable(&self) -> bool {
+        !self.header && !matches!(self.target, ListTarget::None)
+    }
+}
+
 pub struct App {
     root: PathBuf,
     providers: Vec<(String, String)>,
     watched_locations: Vec<PathBuf>,
     view: DashboardView,
-    focused: Pane,
-    should_quit: bool,
+    file_sections: FileSections,
+    scan_receiver: Option<Receiver<Result<ScanResult, String>>>,
+    scan_state: ScanState,
+    focused: ColumnFocus,
+    section: Section,
+    cached_rows: Vec<ListRow>,
+    rows_dirty: bool,
+    #[cfg(test)]
+    row_build_count: usize,
+    list_selected: [usize; SECTION_COUNT],
+    detail_tab: DetailTab,
+    detail_scroll: u16,
+    overview_mode: OverviewMode,
+    search: builders::SearchFilters,
+    run_state: RunState,
     pub palette_error: Option<String>,
+    toast: Option<String>,
     preview: Option<ArtifactPreview>,
-    artifacts: ArtifactsPane,
-    provenance: ProvenancePane,
-    projects: ProjectsPane,
-    sources: SourcesPane,
+    help_state: HelpState,
     palette: Palette,
 }
 
 impl App {
-    pub fn load(root: PathBuf) -> Result<Self, Error> {
-        let providers = load_provider_targets(&root);
-        let watched_locations = watchlist::watched_locations();
-        let view = services::build_view(&root, &providers, &watched_locations)?;
-        Ok(Self::from_view(root, providers, watched_locations, view))
+    pub fn load(root: PathBuf) -> Self {
+        let mut app = Self::from_view(root, Vec::new(), Vec::new(), empty_dashboard_view());
+        app.start_scan();
+        app
     }
 
     #[must_use]
@@ -62,34 +371,117 @@ impl App {
         watched_locations: Vec<PathBuf>,
         view: DashboardView,
     ) -> Self {
-        let artifacts = ArtifactsPane::new(view.clone());
-        let provenance = ProvenancePane::new(view.clone());
-        let projects = ProjectsPane::new(view.clone());
-        let sources = SourcesPane::new(view.clone(), watched_locations.clone());
-        let mut app = Self {
+        Self::from_view_with_files(
+            root,
+            providers,
+            watched_locations,
+            view,
+            FileSections::default(),
+        )
+    }
+
+    #[must_use]
+    pub fn from_view_with_files(
+        root: PathBuf,
+        providers: Vec<(String, String)>,
+        watched_locations: Vec<PathBuf>,
+        view: DashboardView,
+        file_sections: FileSections,
+    ) -> Self {
+        Self {
             root,
             providers,
             watched_locations,
             view,
-            focused: Pane::Artifacts,
-            should_quit: false,
+            file_sections,
+            scan_receiver: None,
+            scan_state: ScanState::Idle,
+            focused: ColumnFocus::Sections,
+            section: Section::Overview,
+            cached_rows: Vec::new(),
+            rows_dirty: true,
+            #[cfg(test)]
+            row_build_count: 0,
+            list_selected: [0; SECTION_COUNT],
+            detail_tab: DetailTab::Preview,
+            detail_scroll: 0,
+            overview_mode: OverviewMode::Nested,
+            search: builders::SearchFilters::empty(),
+            run_state: RunState::Running,
             palette_error: None,
+            toast: None,
             preview: None,
-            artifacts,
-            provenance,
-            projects,
-            sources,
+            help_state: HelpState::Closed,
             palette: Palette::new(),
+        }
+    }
+
+    pub fn refresh(&mut self) {
+        self.start_scan();
+    }
+
+    pub fn poll_scan(&mut self) {
+        let Some(receiver) = &self.scan_receiver else {
+            return;
         };
-        app.sync_components();
-        app
+        match receiver.try_recv() {
+            Ok(Ok(scan_result)) => {
+                self.providers = scan_result.providers;
+                self.watched_locations = scan_result.watched_locations;
+                self.view = scan_result.view;
+                self.file_sections = scan_result.file_sections;
+                self.scan_state = ScanState::Idle;
+                self.scan_receiver = None;
+                self.toast = Some("scan complete".to_string());
+                self.invalidate_rows();
+                self.clamp_list_selection();
+            }
+            Ok(Err(error)) => {
+                self.scan_state = ScanState::Idle;
+                self.scan_receiver = None;
+                self.palette_error = Some(error);
+            }
+            Err(mpsc::TryRecvError::Empty) => {}
+            Err(mpsc::TryRecvError::Disconnected) => {
+                self.scan_state = ScanState::Idle;
+                self.scan_receiver = None;
+                self.palette_error = Some("scan worker disconnected".to_string());
+            }
+        }
     }
 
-    pub fn refresh(&mut self) -> Result<(), Error> {
-        self.view = services::build_view(&self.root, &self.providers, &self.watched_locations)?;
-        self.sync_snapshot();
-        self.sync_components();
-        Ok(())
+    fn start_scan(&mut self) {
+        let root = self.root.clone();
+        let (sender, receiver) = mpsc::channel();
+        thread::spawn(move || {
+            let providers = load_provider_targets(&root);
+            let watched_locations = watchlist::watched_locations();
+            let settings_filenames = config::load_settings_filenames(&root);
+            let result = services::build_view(&root, &providers, &watched_locations)
+                .map(|view| {
+                    let local_repos = services::discover_local_repos(&root, &watched_locations);
+                    let allowed_sources = services::active_repo_names(&view.modules, &root);
+                    let file_sections = files::collect_file_sections(
+                        &root,
+                        &providers,
+                        &settings_filenames,
+                        &local_repos,
+                        &allowed_sources,
+                    );
+                    ScanResult {
+                        providers,
+                        watched_locations,
+                        view,
+                        file_sections,
+                    }
+                })
+                .map_err(|error| format!("{error}"));
+            let _ = sender.send(result);
+        });
+        self.scan_receiver = Some(receiver);
+        self.scan_state = ScanState::Loading;
+        self.palette_error = None;
+        self.toast = None;
     }
 
     pub fn render(&mut self, frame: &mut Frame<'_>) {
@@ -97,35 +489,354 @@ impl App {
             preview.render(frame, frame.area());
             return;
         }
-        self.sync_components();
+
+        self.ensure_rows();
+        self.clamp_list_selection();
         let layout = Layout::default()
             .direction(Direction::Vertical)
-            .constraints([Constraint::Min(1), Constraint::Length(3)])
+            .constraints([
+                Constraint::Length(1),
+                Constraint::Min(1),
+                Constraint::Length(1),
+            ])
             .split(frame.area());
+        self.render_status(frame, layout[0]);
+        let columns = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([
+                Constraint::Ratio(1, 3),
+                Constraint::Ratio(1, 3),
+                Constraint::Ratio(1, 3),
+            ])
+            .split(layout[1]);
+        self.render_sections(frame, columns[0]);
+        self.render_list(frame, columns[1]);
+        self.render_detail(frame, columns[2]);
+        self.render_footer(frame, layout[2]);
+
+        if self.help_state == HelpState::Open {
+            render_help(frame, frame.area());
+        }
+    }
+
+    fn render_status(&self, frame: &mut Frame<'_>, area: Rect) {
+        let scan = if self.scan_state == ScanState::Loading {
+            "Scanning modules..."
+        } else {
+            "ready"
+        };
+        let summary = &self.view.summary;
+        let text = format!(
+            " forge tui | {scan} | ok {} stale {} modified {} new {} | {} modules",
+            summary.unchanged,
+            summary.stale,
+            summary.modified,
+            summary.new,
+            self.view.modules.len()
+        );
+        frame.render_widget(
+            Paragraph::new(text).style(Style::default().fg(Color::Gray)),
+            area,
+        );
+    }
+
+    fn render_footer(&self, frame: &mut Frame<'_>, area: Rect) {
+        let text = if self.palette.is_open() || self.palette_error.is_some() {
+            self.palette.display_text(self.palette_error.as_deref())
+        } else if let Some(toast) = &self.toast {
+            format!(" {toast}")
+        } else {
+            hint_row()
+        };
+        frame.render_widget(
+            Paragraph::new(text).style(Style::default().fg(Color::DarkGray)),
+            area,
+        );
+    }
+
+    fn render_sections(&self, frame: &mut Frame<'_>, area: Rect) {
+        let block = column_block(" Sections ", self.focused == ColumnFocus::Sections);
+        let inner = block.inner(area);
+        frame.render_widget(block, area);
+
+        let items: Vec<ListItem<'_>> = Section::ALL
+            .iter()
+            .enumerate()
+            .map(|(index, section)| {
+                let prefix = format!("{} ", index + 1);
+                let style = if *section == self.section {
+                    selected_style(self.focused == ColumnFocus::Sections)
+                } else {
+                    Style::default()
+                };
+                ListItem::new(Line::from(vec![
+                    Span::styled(prefix, Style::default().fg(Color::DarkGray)),
+                    Span::styled(section.label(), style),
+                ]))
+            })
+            .collect();
+        frame.render_widget(List::new(items), inner);
+    }
+
+    fn render_list(&self, frame: &mut Frame<'_>, area: Rect) {
+        let title = format!(" {} ", self.section.label());
+        let block = column_block(&title, self.focused == ColumnFocus::List);
+        let inner = block.inner(area);
+        frame.render_widget(block, area);
 
-        let rows = Layout::default()
+        let rows = self.cached_rows();
+        if self.scan_state == ScanState::Loading && rows.is_empty() {
+            frame.render_widget(
+                Paragraph::new("Scanning modules...").style(Style::default().fg(Color::Gray)),
+                inner,
+            );
+            return;
+        }
+        let selected = self.selected_list_index(rows);
+        let items: Vec<ListItem<'_>> = if rows.is_empty() {
+            vec![ListItem::new("no rows")]
+        } else {
+            rows.iter()
+                .enumerate()
+                .map(|(index, row)| {
+                    if row.header {
+                        return ListItem::new(Line::from(Span::styled(
+                            row.label.clone(),
+                            Style::default()
+                                .fg(Color::Magenta)
+                                .add_modifier(Modifier::BOLD),
+                        )));
+                    }
+                    let base = if index == selected {
+                        selected_style(self.focused == ColumnFocus::List)
+                    } else {
+                        Style::default()
+                    };
+                    ListItem::new(Line::from(vec![
+                        Span::styled(status_dot(row.status), status_style(row.status)),
+                        Span::raw(" "),
+                        Span::styled(row.label.clone(), base),
+                        Span::styled(format!("  {}", row.detail), base.fg(Color::DarkGray)),
+                    ]))
+                })
+                .collect()
+        };
+        frame.render_widget(List::new(items), inner);
+    }
+
+    fn render_detail(&self, frame: &mut Frame<'_>, area: Rect) {
+        let block = column_block(" Detail ", self.focused == ColumnFocus::Detail);
+        let inner = block.inner(area);
+        frame.render_widget(block, area);
+
+        let target = self.selected_target();
+        match target {
+            Some(
+                ListTarget::Artifact { module, kind, name }
+                | ListTarget::ProvenanceArtifact { module, kind, name },
+            ) => {
+                if let Some((module_view, artifact)) = self.find_artifact(&module, &kind, &name) {
+                    self.render_artifact_detail(frame, inner, module_view, artifact);
+                } else {
+                    frame.render_widget(Paragraph::new("artifact not found"), inner);
+                }
+            }
+            Some(ListTarget::Adr { repo, id }) => {
+                if let Some(adr) = self.find_adr(&repo, &id) {
+                    render_adr_detail(frame, inner, adr);
+                } else {
+                    frame.render_widget(Paragraph::new("ADR not found"), inner);
+                }
+            }
+            Some(ListTarget::Module(name)) => {
+                if let Some(module) = self.view.modules.iter().find(|module| module.name == name) {
+                    render_module_detail(frame, inner, module);
+                } else {
+                    frame.render_widget(Paragraph::new("repository not found"), inner);
+                }
+            }
+            Some(ListTarget::Variant {
+                module,
+                kind,
+                name,
+                qualifier,
+            }) => {
+                self.render_variant_detail(frame, inner, &module, &kind, &name, &qualifier);
+            }
+            Some(ListTarget::SettingsFile { group, index }) => {
+                if let Some(file) = self.settings_file(group, index) {
+                    render_file_body(frame, inner, &file.content, self.detail_scroll);
+                } else {
+                    frame.render_widget(Paragraph::new("settings file not found"), inner);
+                }
+            }
+            Some(ListTarget::Hook { group, index }) => {
+                if let Some(hook) = self.hook_entry(group, index) {
+                    render_hook_detail(frame, inner, hook, self.detail_scroll);
+                } else {
+                    frame.render_widget(Paragraph::new("hook not found"), inner);
+                }
+            }
+            Some(ListTarget::ConfigFile(index)) => {
+                if let Some(file) = self.file_sections.config.get(index) {
+                    render_file_body(frame, inner, &file.content, self.detail_scroll);
+                } else {
+                    frame.render_widget(Paragraph::new("config file not found"), inner);
+                }
+            }
+            Some(ListTarget::SchemaFile { group, index }) => {
+                if let Some(file) = self.schema_file(group, index) {
+                    render_file_body(frame, inner, &file.content, self.detail_scroll);
+                } else {
+                    frame.render_widget(Paragraph::new("schema file not found"), inner);
+                }
+            }
+            _ => self.render_overview_detail(frame, inner),
+        }
+    }
+
+    fn render_artifact_detail(
+        &self,
+        frame: &mut Frame<'_>,
+        area: Rect,
+        module: &ModuleView,
+        artifact: &ArtifactView,
+    ) {
+        let chunks = Layout::default()
             .direction(Direction::Vertical)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-            .split(layout[0]);
-        let top = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-            .split(rows[0]);
-        let bottom = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-            .split(rows[1]);
+            .constraints([Constraint::Length(2), Constraint::Min(1)])
+            .split(area);
+        self.render_tabs(frame, chunks[0]);
+        let lines = match self.detail_tab {
+            DetailTab::Preview => preview_lines(artifact),
+            DetailTab::Code => code_lines(&artifact.raw_source),
+            DetailTab::Diff => diff_lines(artifact),
+            DetailTab::Provenance => self.provenance_lines(module, artifact),
+            DetailTab::Frontmatter => frontmatter_lines(artifact),
+            DetailTab::History => history_lines(artifact),
+            DetailTab::Companions => companion_lines(artifact),
+        };
+        frame.render_widget(
+            Paragraph::new(Text::from(lines))
+                .wrap(Wrap { trim: false })
+                .scroll((self.detail_scroll, 0)),
+            chunks[1],
+        );
+    }
+
+    fn render_tabs(&self, frame: &mut Frame<'_>, area: Rect) {
+        let spans = DetailTab::ALL
+            .iter()
+            .enumerate()
+            .flat_map(|(index, tab)| {
+                let style = if *tab == self.detail_tab {
+                    Style::default()
+                        .fg(Color::Black)
+                        .bg(Color::Cyan)
+                        .add_modifier(Modifier::BOLD)
+                } else {
+                    Style::default().fg(Color::DarkGray)
+                };
+                [
+                    Span::raw(" "),
+                    Span::styled(format!("{} {}", index + 1, tab.label()), style),
+                ]
+            })
+            .collect::<Vec<_>>();
+        frame.render_widget(Paragraph::new(Line::from(spans)), area);
+    }
 
-        self.artifacts.render(frame, top[0]);
-        self.provenance.render(frame, top[1]);
-        self.projects.render(frame, bottom[0]);
-        self.sources.render(frame, bottom[1]);
-        self.palette
-            .render_with_error(frame, layout[1], self.palette_error.as_deref());
+    fn render_overview_detail(&self, frame: &mut Frame<'_>, area: Rect) {
+        let mut lines = vec![Line::from(Span::styled(
+            "Status summary",
+            Style::default().add_modifier(Modifier::BOLD),
+        ))];
+        let summary = &self.view.summary;
+        lines.push(Line::from(format!(
+            "unchanged {} · stale {} · modified {} · new {}",
+            summary.unchanged, summary.stale, summary.modified, summary.new
+        )));
+        lines.push(Line::from(""));
+        if self.overview_mode == OverviewMode::Matrix {
+            let matrix = builders::build_matrix(&self.view);
+            lines.push(Line::from(Span::styled(
+                "Matrix",
+                Style::default().fg(Color::Magenta),
+            )));
+            lines.push(Line::from(format!("columns: {}", matrix.cols.join(", "))));
+            for row in matrix.rows {
+                let cells = row
+                    .cells
+                    .iter()
+                    .map(|cell| format!("{}:{}{}", cell.kind, cell.count, status_dot(&cell.status)))
+                    .collect::<Vec<_>>()
+                    .join("  ");
+                lines.push(Line::from(format!("{}  {cells}", row.module)));
+            }
+        } else {
+            lines.push(Line::from(Span::styled(
+                "Nested",
+                Style::default().fg(Color::Magenta),
+            )));
+            for group in builders::build_nested(&self.view, "kind") {
+                lines.push(Line::from(format!("{} ({})", group.label, group.count)));
+                for subgroup in group.subgroups {
+                    lines.push(Line::from(format!(
+                        "  {} ({})",
+                        subgroup.label, subgroup.count
+                    )));
+                }
+            }
+        }
+        frame.render_widget(
+            Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false }),
+            area,
+        );
+    }
+
+    fn render_variant_detail(
+        &self,
+        frame: &mut Frame<'_>,
+        area: Rect,
+        module: &str,
+        kind: &str,
+        name: &str,
+        qualifier: &str,
+    ) {
+        let mut lines = vec![
+            Line::from(Span::styled(
+                format!("{module} / {kind} / {name}"),
+                Style::default().add_modifier(Modifier::BOLD),
+            )),
+            Line::from(format!("qualifier: {qualifier}")),
+            Line::from(""),
+        ];
+        if let Some((_, artifact)) = self.find_artifact(module, kind, name)
+            && let Some(variant) = artifact
+                .variants
+                .iter()
+                .find(|variant| variant.qualifier == qualifier)
+        {
+            lines.push(Line::from(format!("merge mode: {}", variant.mode)));
+            lines.push(Line::from(format!("path: {}", variant.relative_path)));
+            lines.push(Line::from(""));
+            lines.push(Line::from(
+                "effective merge preview is deferred to the dashboard route",
+            ));
+        }
+        frame.render_widget(
+            Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false }),
+            area,
+        );
     }
 
     pub fn request_quit(&mut self) {
-        self.should_quit = true;
+        self.run_state = RunState::Quit;
+    }
+
+    #[must_use]
+    pub fn should_quit(&self) -> bool {
+        self.run_state == RunState::Quit
     }
 
     #[must_use]
@@ -133,10 +844,20 @@ impl App {
         self.preview.is_some()
     }
 
-    pub fn open_preview(&mut self) {
-        if let Some(artifact) = self.artifacts.selected_artifact() {
-            self.preview = Some(ArtifactPreview::from_artifact(artifact));
-        }
+    #[must_use]
+    pub fn is_help_open(&self) -> bool {
+        self.help_state == HelpState::Open
+    }
+
+    pub fn toggle_help(&mut self) {
+        self.help_state = match self.help_state {
+            HelpState::Closed => HelpState::Open,
+            HelpState::Open => HelpState::Closed,
+        };
+    }
+
+    pub fn close_help(&mut self) {
+        self.help_state = HelpState::Closed;
     }
 
     pub fn close_preview(&mut self) {
@@ -167,11 +888,6 @@ impl App {
         }
     }
 
-    #[must_use]
-    pub fn should_quit(&self) -> bool {
-        self.should_quit
-    }
-
     #[must_use]
     pub fn is_palette_open(&self) -> bool {
         self.palette.is_open()
@@ -190,74 +906,847 @@ impl App {
         let _ = self.palette.on_key(key);
     }
 
-    pub fn execute_palette(&mut self) -> Result<(), Error> {
+    pub fn execute_palette(&mut self) {
         let command = self.palette.take_command();
-        self.execute_palette_command(command)
+        self.execute_palette_command(command);
     }
 
-    pub fn execute_palette_command(&mut self, command: PaletteCommand) -> Result<(), Error> {
+    pub fn execute_palette_command(&mut self, command: PaletteCommand) {
         self.palette_error = None;
         match command {
             PaletteCommand::Refresh => self.refresh(),
             PaletteCommand::Quit => {
                 self.request_quit();
-                Ok(())
             }
             PaletteCommand::Find(query) => {
-                self.sources.set_query(query);
-                self.focused = Pane::Sources;
-                Ok(())
+                self.search.query = query;
+                self.set_section(Section::Search);
+                self.focused = ColumnFocus::List;
+                self.list_selected[self.section as usize] = 0;
+                self.invalidate_rows();
+            }
+            PaletteCommand::GoTo(section) => {
+                if let Some(section) = Section::from_name(&section) {
+                    self.set_section(section);
+                } else {
+                    self.palette_error = Some(format!("unknown section: {section}"));
+                }
             }
-            PaletteCommand::Empty => Ok(()),
+            PaletteCommand::Sort(field) => {
+                self.search.sort = field;
+                self.set_section(Section::Search);
+                self.invalidate_rows();
+            }
+            PaletteCommand::Filter(value) => {
+                if matches!(value.as_str(), "skills" | "agents" | "rules") {
+                    self.search.kind = value;
+                } else {
+                    self.search.status = value;
+                }
+                self.set_section(Section::Search);
+                self.invalidate_rows();
+            }
+            PaletteCommand::Empty => {}
             PaletteCommand::Unknown(verb) => {
                 self.palette_error = Some(format!("unknown command: {verb}"));
-                Ok(())
             }
         }
     }
 
     pub fn focus_next(&mut self) {
-        self.focused = pane_from_index((self.focused as usize + 1) % PANE_COUNT);
+        self.focused = match self.focused {
+            ColumnFocus::Sections => ColumnFocus::List,
+            ColumnFocus::List | ColumnFocus::Detail => ColumnFocus::Detail,
+        };
     }
 
     pub fn focus_previous(&mut self) {
-        self.focused = pane_from_index((self.focused as usize + PANE_COUNT - 1) % PANE_COUNT);
+        self.focused = match self.focused {
+            ColumnFocus::Sections | ColumnFocus::List => ColumnFocus::Sections,
+            ColumnFocus::Detail => ColumnFocus::List,
+        };
+    }
+
+    pub fn drill_or_expand(&mut self) {
+        self.ensure_rows();
+        match self.focused {
+            ColumnFocus::Sections => self.focused = ColumnFocus::List,
+            ColumnFocus::List => {
+                if let Some(ListTarget::ProvenanceArtifact { .. }) = self.selected_target() {
+                    self.detail_tab = DetailTab::Provenance;
+                }
+                self.focused = ColumnFocus::Detail;
+                self.detail_scroll = 0;
+            }
+            ColumnFocus::Detail => {
+                if let Some(artifact) = self.selected_artifact().cloned() {
+                    self.preview = Some(ArtifactPreview::from_artifact(&artifact));
+                }
+            }
+        }
+    }
+
+    pub fn move_back(&mut self) {
+        self.focus_previous();
     }
 
     pub fn focused_key(&mut self, key: KeyEvent) {
         match self.focused {
-            Pane::Artifacts => {
-                let _ = self.artifacts.on_key(key);
+            ColumnFocus::Sections => self.section_key(key),
+            ColumnFocus::List => self.list_key(key),
+            ColumnFocus::Detail => self.detail_key(key),
+        }
+    }
+
+    pub fn set_section_by_number(&mut self, number: usize) {
+        if (1..=SECTION_COUNT).contains(&number) {
+            self.set_section(Section::from_index(number - 1));
+        }
+    }
+
+    pub fn set_section_by_shortcut(&mut self, character: char) -> bool {
+        let Some(section) = Section::from_shortcut(character) else {
+            return false;
+        };
+        self.set_section(section);
+        true
+    }
+
+    pub fn set_detail_tab(&mut self, tab: DetailTab) {
+        self.detail_tab = tab;
+        self.detail_scroll = 0;
+    }
+
+    #[cfg(test)]
+    #[must_use]
+    pub fn detail_tab(&self) -> DetailTab {
+        self.detail_tab
+    }
+
+    #[cfg(test)]
+    #[must_use]
+    pub fn section(&self) -> Section {
+        self.section
+    }
+
+    #[cfg(test)]
+    #[must_use]
+    pub fn search_query(&self) -> &str {
+        &self.search.query
+    }
+
+    #[must_use]
+    pub fn has_section_digit_shortcuts(&self) -> bool {
+        self.focused == ColumnFocus::Sections
+    }
+
+    #[must_use]
+    pub fn is_search_input_active(&self) -> bool {
+        self.section == Section::Search && self.focused == ColumnFocus::List
+    }
+
+    pub fn search_input_key(&mut self, key: KeyEvent) {
+        match key.code {
+            KeyCode::Esc => self.focus_previous(),
+            KeyCode::Enter => self.clamp_list_selection(),
+            KeyCode::Backspace => {
+                self.search.query.pop();
+                self.list_selected[self.section as usize] = 0;
+                self.invalidate_rows();
             }
-            Pane::Provenance => {
-                let _ = self.provenance.on_key(key);
+            KeyCode::Char(character) => {
+                self.search.query.push(character);
+                self.list_selected[self.section as usize] = 0;
+                self.invalidate_rows();
             }
-            Pane::Projects => {
-                let _ = self.projects.on_key(key);
+            _ => {}
+        }
+    }
+
+    #[cfg(test)]
+    #[must_use]
+    pub fn row_build_count(&self) -> usize {
+        self.row_build_count
+    }
+
+    pub fn copy_selected(&mut self) {
+        self.ensure_rows();
+        if let Some(artifact) = self.selected_artifact() {
+            self.toast = Some(format!("copied source path: {}", artifact.relative_path));
+        }
+    }
+
+    fn section_key(&mut self, key: KeyEvent) {
+        match key.code {
+            KeyCode::Down | KeyCode::Char('j') => {
+                let next = (self.section as usize + 1).min(SECTION_COUNT - 1);
+                self.set_section(Section::from_index(next));
             }
-            Pane::Sources => {
-                let _ = self.sources.on_key(key);
+            KeyCode::Up | KeyCode::Char('k') => {
+                let next = (self.section as usize).saturating_sub(1);
+                self.set_section(Section::from_index(next));
             }
+            KeyCode::Home | KeyCode::Char('g') => self.set_section(Section::Overview),
+            KeyCode::End | KeyCode::Char('G') => self.set_section(Section::Schemas),
+            _ => {}
         }
     }
 
-    fn sync_components(&mut self) {
-        self.artifacts.set_focused(self.focused == Pane::Artifacts);
-        self.provenance
-            .set_focused(self.focused == Pane::Provenance);
-        self.projects.set_focused(self.focused == Pane::Projects);
-        self.sources.set_focused(self.focused == Pane::Sources);
+    fn list_key(&mut self, key: KeyEvent) {
+        match key.code {
+            KeyCode::Down | KeyCode::Char('j') => self.move_list_selection(1),
+            KeyCode::Up | KeyCode::Char('k') => self.move_list_selection(-1),
+            KeyCode::Home | KeyCode::Char('g') => self.select_first_row(),
+            KeyCode::End | KeyCode::Char('G') => self.select_last_row(),
+            KeyCode::Char('m') if self.section == Section::Overview => {
+                self.overview_mode = match self.overview_mode {
+                    OverviewMode::Nested => OverviewMode::Matrix,
+                    OverviewMode::Matrix => OverviewMode::Nested,
+                };
+                self.invalidate_rows();
+            }
+            _ => {}
+        }
+    }
 
-        let selected = self.artifacts.selected_artifact().cloned();
-        self.provenance.set_selected_artifact(selected);
+    fn detail_key(&mut self, key: KeyEvent) {
+        match key.code {
+            KeyCode::Down | KeyCode::Char('j') => {
+                self.detail_scroll = self.detail_scroll.saturating_add(1);
+            }
+            KeyCode::Up | KeyCode::Char('k') => {
+                self.detail_scroll = self.detail_scroll.saturating_sub(1);
+            }
+            KeyCode::PageDown => {
+                self.detail_scroll = self.detail_scroll.saturating_add(10);
+            }
+            KeyCode::PageUp => {
+                self.detail_scroll = self.detail_scroll.saturating_sub(10);
+            }
+            KeyCode::Home | KeyCode::Char('g') => self.detail_scroll = 0,
+            KeyCode::Char('p' | '1') => self.set_detail_tab(DetailTab::Preview),
+            KeyCode::Char('c' | '2') => self.set_detail_tab(DetailTab::Code),
+            KeyCode::Char('d' | '3') => self.set_detail_tab(DetailTab::Diff),
+            KeyCode::Char('4') => self.set_detail_tab(DetailTab::Provenance),
+            KeyCode::Char('5') => self.set_detail_tab(DetailTab::Frontmatter),
+            KeyCode::Char('6') => self.set_detail_tab(DetailTab::History),
+            KeyCode::Char('7') => self.set_detail_tab(DetailTab::Companions),
+            KeyCode::Tab => self.next_detail_tab(),
+            _ => {}
+        }
+    }
+
+    fn next_detail_tab(&mut self) {
+        let next = (self.detail_tab as usize + 1) % DETAIL_TAB_COUNT;
+        self.set_detail_tab(DetailTab::from_index(next));
+    }
+
+    fn set_section(&mut self, section: Section) {
+        self.section = section;
+        self.detail_scroll = 0;
+        self.invalidate_rows();
+        self.clamp_list_selection();
+    }
+
+    fn ensure_rows(&mut self) {
+        if self.rows_dirty {
+            self.cached_rows = self.build_list_rows();
+            self.rows_dirty = false;
+            #[cfg(test)]
+            {
+                self.row_build_count += 1;
+            }
+        }
+    }
+
+    fn invalidate_rows(&mut self) {
+        self.rows_dirty = true;
+    }
+
+    fn cached_rows(&self) -> &[ListRow] {
+        &self.cached_rows
+    }
+
+    fn build_list_rows(&self) -> Vec<ListRow> {
+        match self.section {
+            Section::Overview => self.overview_rows(),
+            Section::Skills => self.artifact_rows(Some("skills")),
+            Section::Agents => self.artifact_rows(Some("agents")),
+            Section::Rules => self.artifact_rows(Some("rules")),
+            Section::Repositories => self.repository_rows(),
+            Section::Adrs => self.adr_rows(),
+            Section::Provenance => self.provenance_rows(),
+            Section::Variants => self.variant_rows(),
+            Section::Search => self.search_rows(),
+            Section::Settings => self.settings_rows(),
+            Section::Hooks => self.hook_rows(),
+            Section::Config => self.config_rows(),
+            Section::Schemas => self.schema_rows(),
+        }
+    }
+
+    fn overview_rows(&self) -> Vec<ListRow> {
+        vec![
+            ListRow::item("Summary", "status counts", ListTarget::Overview, "ok"),
+            ListRow::item(
+                if self.overview_mode == OverviewMode::Matrix {
+                    "Matrix"
+                } else {
+                    "Nested"
+                },
+                "press m to toggle",
+                ListTarget::Overview,
+                "ok",
+            ),
+        ]
+    }
+
+    fn artifact_rows(&self, kind_filter: Option<&str>) -> Vec<ListRow> {
+        let mut rows = Vec::new();
+        for (kind, artifacts) in self.view.artifacts_by_kind() {
+            if kind_filter.is_some_and(|filter| filter != kind) {
+                continue;
+            }
+            rows.push(ListRow::header(kind));
+            for (artifact, module) in artifacts {
+                rows.push(artifact_row(artifact, module));
+            }
+        }
+        rows
+    }
+
+    fn repository_rows(&self) -> Vec<ListRow> {
+        let mut rows = vec![ListRow::header("Sources")];
+        for module in self.view.source_modules() {
+            rows.push(ListRow::item(
+                module.name.clone(),
+                format!("{} artifacts", module.artifacts.len()),
+                ListTarget::Module(module.name.clone()),
+                "source",
+            ));
+        }
+        rows.push(ListRow::header("Targets"));
+        for module in self.view.target_modules() {
+            rows.push(ListRow::item(
+                module.name.clone(),
+                format!("{} artifacts", module.artifacts.len()),
+                ListTarget::Module(module.name.clone()),
+                "new",
+            ));
+        }
+        rows
+    }
+
+    fn adr_rows(&self) -> Vec<ListRow> {
+        let mut rows = Vec::new();
+        for repo in self.view.adrs_grouped() {
+            rows.push(ListRow::header(format!("{} ({})", repo.repo, repo.total)));
+            for group in repo.prefix_groups {
+                rows.push(ListRow::header(format!("  {}", group.prefix)));
+                for adr in group.adrs {
+                    rows.push(ListRow::item(
+                        format!("{} {}", adr.id, adr.title),
+                        format!("{} · {}", adr.state, adr.summary),
+                        ListTarget::Adr {
+                            repo: adr.repo.clone(),
+                            id: adr.id.clone(),
+                        },
+                        "source",
+                    ));
+                }
+            }
+        }
+        rows
+    }
+
+    fn provenance_rows(&self) -> Vec<ListRow> {
+        let mut rows = vec![ListRow::header("Needs attention")];
+        for module in &self.view.modules {
+            for artifact in &module.artifacts {
+                let status = artifact.overall_status();
+                if matches!(status, "modified" | "stale") || artifact.has_broken_refs() {
+                    rows.push(ListRow::item(
+                        artifact.name.clone(),
+                        format!("{} · {}", artifact.kind, artifact.staleness_label()),
+                        ListTarget::ProvenanceArtifact {
+                            module: module.name.clone(),
+                            kind: artifact.kind.clone(),
+                            name: artifact.name.clone(),
+                        },
+                        status,
+                    ));
+                }
+            }
+        }
+        if rows.len() == 1 {
+            rows.push(ListRow::item(
+                "No attention items",
+                "integrity clean",
+                ListTarget::Overview,
+                "ok",
+            ));
+        }
+        rows
+    }
+
+    fn variant_rows(&self) -> Vec<ListRow> {
+        let coverage = builders::build_variant_coverage(&self.view);
+        let mut rows = Vec::new();
+        rows.push(ListRow::header(format!(
+            "{} qualifiers",
+            coverage.cols.len()
+        )));
+        for row in coverage.rows {
+            for (index, cell) in row.cells.iter().enumerate() {
+                if cell.mode.is_empty() {
+                    continue;
+                }
+                let qualifier = coverage.cols[index].qualifier.clone();
+                rows.push(ListRow::item(
+                    row.name.clone(),
+                    format!("{} · {} · {}", row.kind, qualifier, cell.mode),
+                    ListTarget::Variant {
+                        module: row.module.clone(),
+                        kind: row.kind.clone(),
+                        name: row.name.clone(),
+                        qualifier,
+                    },
+                    "source",
+                ));
+            }
+        }
+        rows
+    }
+
+    fn search_rows(&self) -> Vec<ListRow> {
+        let mut rows = vec![ListRow::header(format!(
+            "query: {}  kind: {}  status: {}  sort: {}",
+            value_or_any(&self.search.query),
+            value_or_any(&self.search.kind),
+            value_or_any(&self.search.status),
+            value_or_any(&self.search.sort)
+        ))];
+        for (artifact, module) in builders::search_results(&self.view, &self.search) {
+            rows.push(artifact_row(artifact, module));
+        }
+        rows
+    }
+
+    fn settings_rows(&self) -> Vec<ListRow> {
+        let mut rows = Vec::new();
+        for (group_index, group) in self.file_sections.settings.iter().enumerate() {
+            rows.push(ListRow::header(group.harness.clone()));
+            for (file_index, file) in group.files.iter().enumerate() {
+                rows.push(ListRow::item(
+                    format!("{} · {}", group.harness, file.label),
+                    file.path.clone(),
+                    ListTarget::SettingsFile {
+                        group: group_index,
+                        index: file_index,
+                    },
+                    "source",
+                ));
+            }
+        }
+        rows
+    }
+
+    fn hook_rows(&self) -> Vec<ListRow> {
+        let mut rows = Vec::new();
+        for (group_index, group) in self.file_sections.hooks.iter().enumerate() {
+            rows.push(ListRow::header(group.harness.clone()));
+            for (hook_index, hook) in group.hooks.iter().enumerate() {
+                let (_, command) = files::unwrap_shell(&hook.command);
+                rows.push(ListRow::item(
+                    format!("{} · {}", hook.event, value_or_any(&hook.matcher)),
+                    command,
+                    ListTarget::Hook {
+                        group: group_index,
+                        index: hook_index,
+                    },
+                    "source",
+                ));
+            }
+        }
+        rows
+    }
+
+    fn config_rows(&self) -> Vec<ListRow> {
+        self.file_sections
+            .config
+            .iter()
+            .enumerate()
+            .map(|(index, file)| {
+                ListRow::item(
+                    file.path.clone(),
+                    file.label.clone(),
+                    ListTarget::ConfigFile(index),
+                    "source",
+                )
+            })
+            .collect()
+    }
+
+    fn schema_rows(&self) -> Vec<ListRow> {
+        let mut rows = Vec::new();
+        for (group_index, group) in self.file_sections.schemas.iter().enumerate() {
+            rows.push(ListRow::header(group.source.clone()));
+            for (file_index, file) in group.files.iter().enumerate() {
+                rows.push(ListRow::item(
+                    format!("{} · {}", file.label, group.source),
+                    file.path.clone(),
+                    ListTarget::SchemaFile {
+                        group: group_index,
+                        index: file_index,
+                    },
+                    "source",
+                ));
+            }
+        }
+        rows
+    }
+
+    fn selected_list_index(&self, rows: &[ListRow]) -> usize {
+        let selected = self.list_selected[self.section as usize];
+        if rows.get(selected).is_some_and(ListRow::is_selectable) {
+            return selected;
+        }
+        rows.iter()
+            .position(ListRow::is_selectable)
+            .unwrap_or_default()
+    }
+
+    fn clamp_list_selection(&mut self) {
+        self.ensure_rows();
+        let rows = self.cached_rows();
+        let index = self.selected_list_index(rows);
+        self.list_selected[self.section as usize] = index;
+    }
+
+    fn move_list_selection(&mut self, delta: isize) {
+        self.ensure_rows();
+        let rows = self.cached_rows();
+        if rows.is_empty() {
+            self.list_selected[self.section as usize] = 0;
+            return;
+        }
+        let mut index = self.selected_list_index(rows);
+        loop {
+            let next = if delta.is_negative() {
+                index.checked_sub(1)
+            } else {
+                (index + 1 < rows.len()).then_some(index + 1)
+            };
+            let Some(next) = next else {
+                break;
+            };
+            index = next;
+            if rows[index].is_selectable() {
+                break;
+            }
+        }
+        self.list_selected[self.section as usize] = index;
     }
 
-    fn sync_snapshot(&mut self) {
-        self.artifacts.set_view(self.view.clone());
-        self.provenance.set_view(self.view.clone());
-        self.projects.set_view(self.view.clone());
-        self.sources
-            .set_view(self.view.clone(), self.watched_locations.clone());
+    fn select_first_row(&mut self) {
+        self.ensure_rows();
+        let rows = self.cached_rows();
+        self.list_selected[self.section as usize] = rows
+            .iter()
+            .position(ListRow::is_selectable)
+            .unwrap_or_default();
+    }
+
+    fn select_last_row(&mut self) {
+        self.ensure_rows();
+        let rows = self.cached_rows();
+        self.list_selected[self.section as usize] = rows
+            .iter()
+            .rposition(ListRow::is_selectable)
+            .unwrap_or_default();
+    }
+
+    fn selected_target(&self) -> Option<ListTarget> {
+        let rows = self.cached_rows();
+        let selected = self.selected_list_index(rows);
+        rows.get(selected).map(|row| row.target.clone())
+    }
+
+    fn selected_artifact(&self) -> Option<&ArtifactView> {
+        match self.selected_target()? {
+            ListTarget::Artifact { module, kind, name }
+            | ListTarget::ProvenanceArtifact { module, kind, name } => self
+                .find_artifact(&module, &kind, &name)
+                .map(|(_, artifact)| artifact),
+            _ => None,
+        }
+    }
+
+    fn find_artifact(
+        &self,
+        module: &str,
+        kind: &str,
+        name: &str,
+    ) -> Option<(&ModuleView, &ArtifactView)> {
+        self.view
+            .modules
+            .iter()
+            .find(|candidate| candidate.name == module)
+            .and_then(|module_view| {
+                module_view
+                    .artifacts
+                    .iter()
+                    .find(|artifact| artifact.kind == kind && artifact.name == name)
+                    .map(|artifact| (module_view, artifact))
+            })
+    }
+
+    fn find_adr(&self, repo: &str, id: &str) -> Option<&Adr> {
+        self.view
+            .adrs
+            .iter()
+            .find(|adr| adr.repo == repo && adr.id == id)
+    }
+
+    fn settings_file(&self, group: usize, index: usize) -> Option<&files::ConfigFile> {
+        self.file_sections
+            .settings
+            .get(group)
+            .and_then(|group| group.files.get(index))
+    }
+
+    fn hook_entry(&self, group: usize, index: usize) -> Option<&files::HookEntry> {
+        self.file_sections
+            .hooks
+            .get(group)
+            .and_then(|group| group.hooks.get(index))
+    }
+
+    fn schema_file(&self, group: usize, index: usize) -> Option<&files::ConfigFile> {
+        self.file_sections
+            .schemas
+            .get(group)
+            .and_then(|group| group.files.get(index))
+    }
+
+    fn provenance_entries<'a>(
+        &'a self,
+        module: &ModuleView,
+        artifact: &ArtifactView,
+    ) -> Vec<&'a ProvenanceArtifact> {
+        self.view
+            .provenance
+            .iter()
+            .filter(|record| {
+                canonical_source(&record.source_uri) == canonical_source(&module.source_uri)
+            })
+            .flat_map(|record| record.artifacts.iter())
+            .filter(|entry| entry.source_path.ends_with(&artifact.relative_path))
+            .collect()
+    }
+
+    fn provenance_lines(&self, module: &ModuleView, artifact: &ArtifactView) -> Vec<Line<'static>> {
+        let mut lines = vec![
+            Line::from(Span::styled(
+                "Provenance chain",
+                Style::default().add_modifier(Modifier::BOLD),
+            )),
+            Line::from(format!(
+                "status: {} · {}",
+                artifact.overall_status(),
+                artifact.staleness_label()
+            )),
+        ];
+        if let Some(adoption) = &artifact.adoption {
+            lines.push(Line::from(format!(
+                "Upstream: {} @ {}",
+                adoption.source_label, adoption.source_sha
+            )));
+            lines.push(Line::from(format!(
+                "adopt/copy: {} · by {}",
+                adoption.kind, adoption.author
+            )));
+            if !adoption.dependencies.is_empty() {
+                let deps = builders::resolve_dep_links(&self.view, artifact.adoption.as_ref())
+                    .iter()
+                    .map(|dep| {
+                        if dep.module.is_empty() {
+                            dep.name.clone()
+                        } else {
+                            format!("{} -> {}", dep.name, dep.module)
+                        }
+                    })
+                    .collect::<Vec<_>>()
+                    .join(", ");
+                lines.push(Line::from(format!("dependencies: {deps}")));
+            }
+            if !adoption.transforms.is_empty() {
+                lines.push(Line::from(format!(
+                    "transforms: {}",
+                    adoption.transforms.join(", ")
+                )));
+            }
+            lines.push(Line::from(format!("license: {}", adoption.license)));
+            lines.push(Line::from(format!("adopted by: {}", adoption.adopted_by)));
+        } else {
+            lines.push(Line::from("Upstream: authored source"));
+        }
+        lines.push(Line::from(format!("source module: {}", module.name)));
+        lines.push(Line::from(
+            "assemble: current binary metadata available in dashboard",
+        ));
+        let entries = self.provenance_entries(module, artifact);
+        let groups = builders::group_deployments(&entries);
+        if groups.is_empty() {
+            lines.push(Line::from("deploy groups: none"));
+        } else {
+            lines.push(Line::from("deploy groups"));
+            for group in groups {
+                lines.push(Line::from(format!(
+                    "  {} {}/{} verified",
+                    group.target, group.verified, group.total
+                )));
+                for harness in group.harnesses {
+                    lines.push(Line::from(format!(
+                        "    {} {} {}",
+                        harness.harness,
+                        if harness.verified { "OK" } else { "DRIFT" },
+                        harness.deployed_path
+                    )));
+                }
+            }
+        }
+        if !artifact.sidecar_warning.is_empty() {
+            lines.push(Line::from(format!("sidecar: {}", artifact.sidecar_warning)));
+        }
+        lines
+    }
+}
+
+fn render_module_detail(frame: &mut Frame<'_>, area: Rect, module: &ModuleView) {
+    let lines = vec![
+        Line::from(Span::styled(
+            module.name.clone(),
+            Style::default().add_modifier(Modifier::BOLD),
+        )),
+        Line::from(format!("version: {}", module.version)),
+        Line::from(format!("source: {}", module.source_uri)),
+        Line::from(format!(
+            "role: {}",
+            if module.is_target { "target" } else { "source" }
+        )),
+        Line::from(""),
+        Line::from(module.description.clone()),
+        Line::from(""),
+        Line::from(format!("artifacts: {}", module.artifacts.len())),
+    ];
+    frame.render_widget(
+        Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false }),
+        area,
+    );
+}
+
+fn render_adr_detail(frame: &mut Frame<'_>, area: Rect, adr: &Adr) {
+    let lines = vec![
+        Line::from(Span::styled(
+            format!("{} {}", adr.id, adr.title),
+            Style::default().add_modifier(Modifier::BOLD),
+        )),
+        Line::from(format!("repo: {}", adr.repo)),
+        Line::from(format!("state: {}", adr.state)),
+        Line::from(format!("status: {}", adr.status)),
+        Line::from(format!("path: {}", adr.relative_path)),
+        Line::from(""),
+        Line::from(adr.summary.clone()),
+    ];
+    frame.render_widget(
+        Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false }),
+        area,
+    );
+}
+
+fn render_file_body(frame: &mut Frame<'_>, area: Rect, content: &str, scroll: u16) {
+    let lines = if content.is_empty() {
+        vec![Line::from("")]
+    } else {
+        content
+            .lines()
+            .map(|line| Line::from(line.to_string()))
+            .collect()
+    };
+    frame.render_widget(
+        Paragraph::new(Text::from(lines))
+            .wrap(Wrap { trim: false })
+            .scroll((scroll, 0)),
+        area,
+    );
+}
+
+fn render_hook_detail(frame: &mut Frame<'_>, area: Rect, hook: &files::HookEntry, scroll: u16) {
+    let (_, command) = files::unwrap_shell(&hook.command);
+    let lines = vec![
+        Line::from(vec![
+            Span::styled("event: ", Style::default().fg(Color::Magenta)),
+            Span::raw(hook.event.clone()),
+        ]),
+        Line::from(vec![
+            Span::styled("matcher: ", Style::default().fg(Color::Magenta)),
+            Span::raw(value_or_any(&hook.matcher).to_string()),
+        ]),
+        Line::from(vec![
+            Span::styled("source: ", Style::default().fg(Color::Magenta)),
+            Span::raw(hook.source.clone()),
+        ]),
+        Line::from(""),
+        Line::from(command),
+    ];
+    frame.render_widget(
+        Paragraph::new(Text::from(lines))
+            .wrap(Wrap { trim: false })
+            .scroll((scroll, 0)),
+        area,
+    );
+}
+
+fn render_help(frame: &mut Frame<'_>, area: Rect) {
+    frame.render_widget(Clear, area);
+    let block = Block::default()
+        .title(" Help ")
+        .borders(Borders::ALL)
+        .border_style(Style::default().fg(Color::Magenta));
+    let inner = block.inner(area);
+    frame.render_widget(block, area);
+
+    let columns = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Ratio(1, 2), Constraint::Ratio(1, 2)])
+        .split(inner);
+    for (column_index, column) in columns.iter().enumerate() {
+        let groups = KEYBINDINGS
+            .iter()
+            .enumerate()
+            .filter(|(index, _)| index % 2 == column_index)
+            .map(|(_, group)| *group);
+        let mut lines = Vec::new();
+        for (group, bindings) in groups {
+            lines.push(Line::from(Span::styled(
+                group,
+                Style::default()
+                    .fg(Color::Magenta)
+                    .add_modifier(Modifier::BOLD),
+            )));
+            for (key, description) in bindings {
+                lines.push(Line::from(vec![
+                    Span::styled(
+                        format!("{key:<12}"),
+                        Style::default().add_modifier(Modifier::BOLD),
+                    ),
+                    Span::styled(*description, Style::default().fg(Color::DarkGray)),
+                ]));
+            }
+            lines.push(Line::from(""));
+        }
+        frame.render_widget(Paragraph::new(Text::from(lines)), *column);
     }
 }
 
@@ -275,11 +1764,262 @@ pub fn load_provider_targets(root: &Path) -> Vec<(String, String)> {
     targets
 }
 
-fn pane_from_index(index: usize) -> Pane {
-    match index {
-        0 => Pane::Artifacts,
-        1 => Pane::Provenance,
-        2 => Pane::Projects,
-        _ => Pane::Sources,
+fn empty_dashboard_view() -> DashboardView {
+    DashboardView {
+        modules: Vec::new(),
+        summary: StatusSummary::default(),
+        provenance: Vec::new(),
+        adrs: Vec::new(),
+    }
+}
+
+fn column_block(title: &str, focused: bool) -> Block<'_> {
+    Block::default()
+        .title(title)
+        .borders(Borders::ALL)
+        .border_style(if focused {
+            Style::default().fg(Color::Cyan)
+        } else {
+            Style::default().fg(Color::DarkGray)
+        })
+}
+
+fn selected_style(focused: bool) -> Style {
+    if focused {
+        Style::default()
+            .fg(Color::Black)
+            .bg(Color::Cyan)
+            .add_modifier(Modifier::BOLD)
+    } else {
+        Style::default()
+            .fg(Color::White)
+            .add_modifier(Modifier::BOLD)
+    }
+}
+
+fn artifact_row(artifact: &ArtifactView, module: &str) -> ListRow {
+    let warning = if artifact.has_broken_refs() || !artifact.sidecar_warning.is_empty() {
+        " ⚠"
+    } else {
+        ""
+    };
+    let age = artifact.age_label();
+    let deploy = if artifact.deployed_count() == 0 {
+        "src".to_string()
+    } else {
+        format!("↗{}", artifact.deployed_count())
+    };
+    ListRow::item(
+        format!("{}{}", artifact.name, warning),
+        format!(
+            "{} · {} · {} · {}",
+            artifact.kind,
+            module,
+            value_or_any(&age),
+            deploy
+        ),
+        ListTarget::Artifact {
+            module: module.to_string(),
+            kind: artifact.kind.clone(),
+            name: artifact.name.clone(),
+        },
+        artifact.overall_status(),
+    )
+}
+
+fn status_dot(status: &str) -> &'static str {
+    match status {
+        "modified" | "stale" | "new" => "●",
+        _ => "·",
+    }
+}
+
+fn status_style(status: &str) -> Style {
+    match status {
+        "modified" => Style::default().fg(Color::Red),
+        "stale" => Style::default().fg(Color::Yellow),
+        "new" => Style::default().fg(Color::Blue),
+        "source" => Style::default().fg(Color::DarkGray),
+        _ => Style::default().fg(Color::Green),
+    }
+}
+
+fn value_or_any(value: &str) -> &str {
+    if value.is_empty() { "any" } else { value }
+}
+
+fn hint_row() -> String {
+    KEYBINDINGS
+        .iter()
+        .flat_map(|(_, bindings)| bindings.iter())
+        .take(8)
+        .map(|(key, description)| format!("{key} {description}"))
+        .collect::<Vec<_>>()
+        .join("  ·  ")
+}
+
+fn preview_lines(artifact: &ArtifactView) -> Vec<Line<'static>> {
+    let mut lines = vec![
+        Line::from(Span::styled(
+            format!(
+                "{} · {} · {}",
+                artifact.kind, artifact.name, artifact.module
+            ),
+            Style::default().add_modifier(Modifier::BOLD),
+        )),
+        Line::from(format!(
+            "{} lines · {} · {} {}",
+            artifact.total_lines(),
+            value_or_any(&artifact.age_label()),
+            if artifact.staleness_rank() == 0 {
+                "✓"
+            } else {
+                "⚠"
+            },
+            artifact.staleness_label()
+        )),
+    ];
+    if !artifact.broken_refs.is_empty() {
+        lines.push(Line::from(format!(
+            "broken refs: {}",
+            artifact.broken_refs.join(", ")
+        )));
+    }
+    if !artifact.description.is_empty() {
+        lines.push(Line::from(artifact.description.clone()));
+    }
+    lines.push(Line::from(""));
+    lines.extend(
+        artifact
+            .content_body
+            .lines()
+            .map(|line| Line::from(line.to_string())),
+    );
+    if artifact.content_body.is_empty() {
+        lines.extend(
+            artifact
+                .content_preview
+                .lines()
+                .map(|line| Line::from(line.to_string())),
+        );
+    }
+    lines
+}
+
+fn code_lines(source: &str) -> Vec<Line<'static>> {
+    if source.is_empty() {
+        return vec![Line::from("no raw source")];
+    }
+    source
+        .lines()
+        .enumerate()
+        .map(|(index, line)| {
+            Line::from(vec![
+                Span::styled(
+                    format!("{:>4} ", index + 1),
+                    Style::default().fg(Color::DarkGray),
+                ),
+                Span::raw(line.to_string()),
+            ])
+        })
+        .collect()
+}
+
+fn diff_lines(artifact: &ArtifactView) -> Vec<Line<'static>> {
+    let mut lines = vec![
+        Line::from(Span::styled(
+            "Diff",
+            Style::default().add_modifier(Modifier::BOLD),
+        )),
+        Line::from("vs deployed and source-at-deploy are computed by the dashboard route today"),
+        Line::from(
+            "TUI keeps this tab lazy and off the scan path; target reads remain a follow-up seam",
+        ),
+        Line::from(""),
+    ];
+    lines.extend(
+        artifact
+            .raw_source
+            .lines()
+            .take(30)
+            .map(|line| Line::from(format!("  {line}"))),
+    );
+    lines
+}
+
+fn frontmatter_lines(artifact: &ArtifactView) -> Vec<Line<'static>> {
+    if artifact.metadata.is_empty() {
+        return vec![Line::from("no frontmatter metadata")];
+    }
+    artifact
+        .metadata
+        .iter()
+        .map(|(key, value)| {
+            Line::from(vec![
+                Span::styled(format!("{key:<18}"), Style::default().fg(Color::Magenta)),
+                Span::raw(value.clone()),
+            ])
+        })
+        .collect()
+}
+
+fn history_lines(artifact: &ArtifactView) -> Vec<Line<'static>> {
+    if artifact.git_log.is_empty() {
+        return vec![Line::from("no git history")];
     }
+    let mut lines = Vec::new();
+    for commit in &artifact.git_log {
+        lines.push(Line::from(Span::styled(
+            commit.message.clone(),
+            Style::default().add_modifier(Modifier::BOLD),
+        )));
+        lines.push(Line::from(format!(
+            "{} · {} · {}",
+            commit.date, commit.author, commit.sha
+        )));
+        if !commit.jj_change.is_empty() {
+            lines.push(Line::from(format!("jj: {}", commit.jj_change)));
+        }
+        if !commit.checkpoint.is_empty() {
+            lines.push(Line::from(format!(
+                "checkpoint {} · {} sessions",
+                commit.checkpoint, commit.session_count
+            )));
+            if !commit.prompt.is_empty() {
+                lines.push(Line::from(format!("intent: {}", commit.prompt)));
+            }
+        }
+        lines.push(Line::from(""));
+    }
+    lines
+}
+
+fn companion_lines(artifact: &ArtifactView) -> Vec<Line<'static>> {
+    if artifact.companions.is_empty() {
+        return vec![Line::from("no companions")];
+    }
+    let mut lines = Vec::new();
+    for companion in &artifact.companions {
+        lines.push(Line::from(Span::styled(
+            companion.name.clone(),
+            Style::default().add_modifier(Modifier::BOLD),
+        )));
+        lines.push(Line::from(format!("path: {}", companion.relative_path)));
+        if !companion.description.is_empty() {
+            lines.push(Line::from(companion.description.clone()));
+        }
+        lines.push(Line::from(""));
+        lines.extend(
+            companion
+                .content_body
+                .lines()
+                .map(|line| Line::from(line.to_string())),
+        );
+        lines.push(Line::from(""));
+    }
+    lines
+}
+
+fn canonical_source(source: &str) -> String {
+    source.trim_end_matches(".git").to_string()
 }
diff --git a/src/tui/components/artifacts.rs b/src/tui/components/artifacts.rs
deleted file mode 100644
index 14caad5..0000000
--- a/src/tui/components/artifacts.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-use crossterm::event::{KeyCode, KeyEvent};
-use ratatui::{
-    Frame,
-    layout::{Constraint, Direction, Layout, Rect},
-    style::{Color, Modifier, Style},
-    text::{Line, Span, Text},
-    widgets::{Block, Borders, List, ListItem, Paragraph, Wrap},
-};
-
-use commands::view::{ArtifactView, DashboardView};
-
-use super::{Component, Outcome};
-
-#[derive(Debug, Clone)]
-pub struct ArtifactsPane {
-    view: DashboardView,
-    selected: usize,
-    focused: bool,
-}
-
-impl ArtifactsPane {
-    #[must_use]
-    pub fn new(view: DashboardView) -> Self {
-        Self {
-            view,
-            selected: 0,
-            focused: false,
-        }
-    }
-
-    pub fn set_view(&mut self, view: DashboardView) {
-        self.view = view;
-        self.clamp_selection();
-    }
-
-    pub fn set_focused(&mut self, focused: bool) {
-        self.focused = focused;
-    }
-
-    #[must_use]
-    pub fn selected_artifact(&self) -> Option<&ArtifactView> {
-        self.artifact_refs()
-            .get(self.selected)
-            .and_then(|(module_index, artifact_index)| {
-                self.view
-                    .modules
-                    .get(*module_index)
-                    .and_then(|module| module.artifacts.get(*artifact_index))
-            })
-    }
-
-    fn artifact_refs(&self) -> Vec<(usize, usize)> {
-        self.view
-            .modules
-            .iter()
-            .enumerate()
-            .flat_map(|(module_index, module)| {
-                module
-                    .artifacts
-                    .iter()
-                    .enumerate()
-                    .map(move |(artifact_index, _)| (module_index, artifact_index))
-            })
-            .collect()
-    }
-
-    fn clamp_selection(&mut self) {
-        let len = self.artifact_refs().len();
-        if len == 0 {
-            self.selected = 0;
-        } else if self.selected >= len {
-            self.selected = len - 1;
-        }
-    }
-
-    fn move_down(&mut self) {
-        let len = self.artifact_refs().len();
-        if self.selected + 1 < len {
-            self.selected += 1;
-        }
-    }
-
-    fn move_up(&mut self) {
-        self.selected = self.selected.saturating_sub(1);
-    }
-
-    fn border_style(&self) -> Style {
-        if self.focused {
-            Style::default().fg(Color::Cyan)
-        } else {
-            Style::default().fg(Color::DarkGray)
-        }
-    }
-}
-
-impl Component for ArtifactsPane {
-    fn render(&self, frame: &mut Frame<'_>, area: Rect) {
-        let outer = Block::default()
-            .title(" Artifacts ")
-            .borders(Borders::ALL)
-            .border_style(self.border_style());
-        let inner = outer.inner(area);
-        frame.render_widget(outer, area);
-
-        let chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Percentage(40), Constraint::Percentage(60)])
-            .split(inner);
-
-        let mut selected_seen = 0usize;
-        let mut items = Vec::new();
-        for module in &self.view.modules {
-            items.push(ListItem::new(Line::from(Span::styled(
-                module.name.clone(),
-                Style::default()
-                    .fg(Color::Yellow)
-                    .add_modifier(Modifier::BOLD),
-            ))));
-            for (kind, artifacts) in module.artifacts_by_kind() {
-                for artifact in artifacts {
-                    let is_selected = selected_seen == self.selected;
-                    selected_seen += 1;
-                    let style = if is_selected {
-                        Style::default()
-                            .fg(Color::Black)
-                            .bg(Color::Cyan)
-                            .add_modifier(Modifier::BOLD)
-                    } else {
-                        Style::default()
-                    };
-                    items.push(ListItem::new(Line::from(vec![
-                        Span::raw("  "),
-                        Span::styled(artifact.name.clone(), style),
-                        Span::styled(format!("  {kind}"), style.fg(Color::Gray)),
-                    ])));
-                }
-            }
-        }
-        if items.is_empty() {
-            items.push(ListItem::new("no artifacts"));
-        }
-
-        frame.render_widget(List::new(items), chunks[0]);
-
-        let detail = match self.selected_artifact() {
-            Some(artifact) => {
-                let body = if artifact.content_body.is_empty() {
-                    artifact.content_preview.as_str()
-                } else {
-                    artifact.content_body.as_str()
-                };
-                Text::from(vec![
-                    Line::from(Span::styled(
-                        artifact.name.clone(),
-                        Style::default().add_modifier(Modifier::BOLD),
-                    )),
-                    Line::from(format!("kind: {}", artifact.kind)),
-                    Line::from(format!("module: {}", artifact.module)),
-                    Line::from(format!("path: {}", artifact.relative_path)),
-                    Line::from(Span::styled(
-                        "↵ open full preview",
-                        Style::default().fg(Color::Cyan),
-                    )),
-                    Line::from(""),
-                    Line::from(artifact.description.clone()),
-                    Line::from(""),
-                    Line::from(body.to_string()),
-                ])
-            }
-            None => Text::from("no artifact selected"),
-        };
-        frame.render_widget(Paragraph::new(detail).wrap(Wrap { trim: false }), chunks[1]);
-    }
-
-    fn on_key(&mut self, key: KeyEvent) -> Outcome {
-        match key.code {
-            KeyCode::Down | KeyCode::Char('j') => {
-                self.move_down();
-                Outcome::Handled
-            }
-            KeyCode::Up | KeyCode::Char('k') => {
-                self.move_up();
-                Outcome::Handled
-            }
-            _ => Outcome::Ignored,
-        }
-    }
-}
diff --git a/src/tui/components/mod.rs b/src/tui/components/mod.rs
index d92b733..9d560d7 100644
--- a/src/tui/components/mod.rs
+++ b/src/tui/components/mod.rs
@@ -1,20 +1,2 @@
-pub mod artifacts;
 pub mod palette;
 pub mod preview;
-pub mod projects;
-pub mod provenance;
-pub mod sources;
-
-use crossterm::event::KeyEvent;
-use ratatui::{Frame, layout::Rect};
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Outcome {
-    Handled,
-    Ignored,
-}
-
-pub trait Component {
-    fn render(&self, frame: &mut Frame<'_>, area: Rect);
-    fn on_key(&mut self, key: KeyEvent) -> Outcome;
-}
diff --git a/src/tui/components/palette.rs b/src/tui/components/palette.rs
index a6ddb55..373b748 100644
--- a/src/tui/components/palette.rs
+++ b/src/tui/components/palette.rs
@@ -1,18 +1,13 @@
 use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-use ratatui::{
-    Frame,
-    layout::Rect,
-    style::{Color, Style},
-    widgets::{Block, Borders, Paragraph},
-};
-
-use super::{Component, Outcome};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum PaletteCommand {
     Refresh,
     Quit,
     Find(String),
+    GoTo(String),
+    Sort(String),
+    Filter(String),
     Empty,
     Unknown(String),
 }
@@ -63,53 +58,38 @@ impl Palette {
             "r" | "refresh" => PaletteCommand::Refresh,
             "q" | "quit" => PaletteCommand::Quit,
             "find" => PaletteCommand::Find(rest.to_string()),
+            "sort" => PaletteCommand::Sort(rest.to_string()),
+            "filter" => PaletteCommand::Filter(rest.to_string()),
+            "overview" | "skills" | "agents" | "rules" | "repos" | "repositories" | "adrs"
+            | "provenance" | "variants" | "search" | "settings" | "hooks" | "config"
+            | "schemas" => PaletteCommand::GoTo(verb.to_string()),
             other => PaletteCommand::Unknown(other.to_string()),
         }
     }
 
-    pub fn render_with_error(&self, frame: &mut Frame<'_>, area: Rect, error: Option<&str>) {
-        let border_style = if self.open {
-            Style::default().fg(Color::Cyan)
-        } else {
-            Style::default().fg(Color::DarkGray)
-        };
-        let text = if let Some(error) = error {
+    pub fn display_text(&self, error: Option<&str>) -> String {
+        if let Some(error) = error {
             format!("error: {error}")
         } else {
             let prefix = if self.open { ":" } else { "" };
             format!("{prefix}{}", self.input)
-        };
-        frame.render_widget(
-            Paragraph::new(text).block(
-                Block::default()
-                    .title(" Command ")
-                    .borders(Borders::ALL)
-                    .border_style(border_style),
-            ),
-            area,
-        );
-    }
-}
-
-impl Component for Palette {
-    fn render(&self, frame: &mut Frame<'_>, area: Rect) {
-        self.render_with_error(frame, area, None);
+        }
     }
 
-    fn on_key(&mut self, key: KeyEvent) -> Outcome {
+    pub fn on_key(&mut self, key: KeyEvent) -> bool {
         match key.code {
             KeyCode::Backspace => {
                 self.input.pop();
-                Outcome::Handled
+                true
             }
             KeyCode::Char(character)
                 if key.modifiers.is_empty() || key.modifiers == KeyModifiers::SHIFT =>
             {
                 self.input.push(character);
-                Outcome::Handled
+                true
             }
             // TODO: numbered selection and 3-level tab-completion for v2.
-            _ => Outcome::Ignored,
+            _ => false,
         }
     }
 }
diff --git a/src/tui/components/projects.rs b/src/tui/components/projects.rs
deleted file mode 100644
index 9a1306b..0000000
--- a/src/tui/components/projects.rs
+++ /dev/null
@@ -1,118 +0,0 @@
-use crossterm::event::{KeyCode, KeyEvent};
-use ratatui::{
-    Frame,
-    layout::Rect,
-    style::{Color, Modifier, Style},
-    text::{Line, Span, Text},
-    widgets::{Block, Borders, Paragraph, Wrap},
-};
-
-use commands::view::DashboardView;
-
-use super::{Component, Outcome};
-
-#[derive(Debug, Clone)]
-pub struct ProjectsPane {
-    view: DashboardView,
-    selected: usize,
-    focused: bool,
-}
-
-impl ProjectsPane {
-    #[must_use]
-    pub fn new(view: DashboardView) -> Self {
-        Self {
-            view,
-            selected: 0,
-            focused: false,
-        }
-    }
-
-    pub fn set_view(&mut self, view: DashboardView) {
-        self.view = view;
-        self.clamp_selection();
-    }
-
-    pub fn set_focused(&mut self, focused: bool) {
-        self.focused = focused;
-    }
-
-    fn clamp_selection(&mut self) {
-        if self.view.modules.is_empty() {
-            self.selected = 0;
-        } else if self.selected >= self.view.modules.len() {
-            self.selected = self.view.modules.len() - 1;
-        }
-    }
-
-    fn border_style(&self) -> Style {
-        if self.focused {
-            Style::default().fg(Color::Cyan)
-        } else {
-            Style::default().fg(Color::DarkGray)
-        }
-    }
-}
-
-impl Component for ProjectsPane {
-    fn render(&self, frame: &mut Frame<'_>, area: Rect) {
-        let block = Block::default()
-            .title(" Projects + ontology ")
-            .borders(Borders::ALL)
-            .border_style(self.border_style());
-        let inner = block.inner(area);
-        frame.render_widget(block, area);
-
-        let mut lines = vec![
-            Line::from(Span::styled(
-                "no ontology configured",
-                Style::default().fg(Color::Yellow),
-            )),
-            Line::from(""),
-            Line::from(Span::styled(
-                "modules",
-                Style::default().add_modifier(Modifier::BOLD),
-            )),
-        ];
-
-        if self.view.modules.is_empty() {
-            lines.push(Line::from("  no modules"));
-        } else {
-            for (index, module) in self.view.modules.iter().enumerate() {
-                let style = if index == self.selected {
-                    Style::default()
-                        .fg(Color::Black)
-                        .bg(Color::Cyan)
-                        .add_modifier(Modifier::BOLD)
-                } else {
-                    Style::default()
-                };
-                lines.push(Line::from(Span::styled(
-                    format!("  {}", module.name),
-                    style,
-                )));
-            }
-        }
-
-        frame.render_widget(
-            Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false }),
-            inner,
-        );
-    }
-
-    fn on_key(&mut self, key: KeyEvent) -> Outcome {
-        match key.code {
-            KeyCode::Down | KeyCode::Char('j') => {
-                if self.selected + 1 < self.view.modules.len() {
-                    self.selected += 1;
-                }
-                Outcome::Handled
-            }
-            KeyCode::Up | KeyCode::Char('k') => {
-                self.selected = self.selected.saturating_sub(1);
-                Outcome::Handled
-            }
-            _ => Outcome::Ignored,
-        }
-    }
-}
diff --git a/src/tui/components/provenance.rs b/src/tui/components/provenance.rs
deleted file mode 100644
index 688c3b2..0000000
--- a/src/tui/components/provenance.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-use crossterm::event::KeyEvent;
-use ratatui::{
-    Frame,
-    layout::Rect,
-    style::{Color, Modifier, Style},
-    text::{Line, Span, Text},
-    widgets::{Block, Borders, Paragraph, Wrap},
-};
-
-use commands::view::{ArtifactView, DashboardView};
-
-use super::{Component, Outcome};
-
-#[derive(Debug, Clone)]
-pub struct ProvenancePane {
-    view: DashboardView,
-    selected_artifact: Option<ArtifactView>,
-    focused: bool,
-}
-
-impl ProvenancePane {
-    #[must_use]
-    pub fn new(view: DashboardView) -> Self {
-        Self {
-            view,
-            selected_artifact: None,
-            focused: false,
-        }
-    }
-
-    pub fn set_view(&mut self, view: DashboardView) {
-        self.view = view;
-    }
-
-    pub fn set_selected_artifact(&mut self, artifact: Option<ArtifactView>) {
-        self.selected_artifact = artifact;
-    }
-
-    pub fn set_focused(&mut self, focused: bool) {
-        self.focused = focused;
-    }
-
-    fn border_style(&self) -> Style {
-        if self.focused {
-            Style::default().fg(Color::Cyan)
-        } else {
-            Style::default().fg(Color::DarkGray)
-        }
-    }
-}
-
-impl Component for ProvenancePane {
-    fn render(&self, frame: &mut Frame<'_>, area: Rect) {
-        let block = Block::default()
-            .title(" Provenance + integrity ")
-            .borders(Borders::ALL)
-            .border_style(self.border_style());
-        let inner = block.inner(area);
-        frame.render_widget(block, area);
-
-        let Some(artifact) = &self.selected_artifact else {
-            frame.render_widget(Paragraph::new("no artifact selected"), inner);
-            return;
-        };
-
-        let mut lines = vec![
-            Line::from(vec![
-                Span::styled("status: ", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw(artifact.overall_status()),
-            ]),
-            Line::from(vec![
-                Span::styled("staleness: ", Style::default().add_modifier(Modifier::BOLD)),
-                Span::raw(artifact.staleness_label()),
-            ]),
-        ];
-
-        if !artifact.broken_refs.is_empty() {
-            lines.push(Line::from(""));
-            lines.push(Line::from(Span::styled(
-                "broken references",
-                Style::default().fg(Color::Red).add_modifier(Modifier::BOLD),
-            )));
-            for broken_ref in &artifact.broken_refs {
-                lines.push(Line::from(format!("  {broken_ref}")));
-            }
-        }
-
-        if !artifact.sidecar_warning.is_empty() {
-            lines.push(Line::from(""));
-            lines.push(Line::from(vec![
-                Span::styled("sidecar: ", Style::default().fg(Color::Yellow)),
-                Span::raw(artifact.sidecar_warning.clone()),
-            ]));
-        }
-
-        if !artifact.providers.is_empty() {
-            lines.push(Line::from(""));
-            lines.push(Line::from(Span::styled(
-                "providers",
-                Style::default().add_modifier(Modifier::BOLD),
-            )));
-            for (provider, status) in &artifact.providers {
-                lines.push(Line::from(format!(
-                    "  {provider} -> {}",
-                    status.status.label()
-                )));
-            }
-        }
-
-        if let Some(adoption) = &artifact.adoption {
-            lines.push(Line::from(""));
-            lines.push(Line::from(Span::styled(
-                "adoption",
-                Style::default().add_modifier(Modifier::BOLD),
-            )));
-            lines.push(Line::from(format!("  source: {}", adoption.source_label)));
-            lines.push(Line::from(format!("  sha: {}", adoption.source_sha)));
-            if !adoption.transforms.is_empty() {
-                lines.push(Line::from(format!(
-                    "  transforms: {}",
-                    adoption.transforms.join(", ")
-                )));
-            }
-        }
-
-        let provenance_rows: Vec<_> = self
-            .view
-            .provenance
-            .iter()
-            .flat_map(|provenance| provenance.artifacts.iter())
-            .filter(|row| row.source_path.ends_with(&artifact.relative_path))
-            .collect();
-        if !provenance_rows.is_empty() {
-            lines.push(Line::from(""));
-            lines.push(Line::from(Span::styled(
-                "deployments",
-                Style::default().add_modifier(Modifier::BOLD),
-            )));
-            for row in provenance_rows {
-                let verified = if row.verified { "verified" } else { "mismatch" };
-                lines.push(Line::from(format!(
-                    "  {} -> {} [{}]",
-                    row.source_path, row.deployed_path, row.harness
-                )));
-                lines.push(Line::from(format!(
-                    "    {verified}; deployed {}; expected {}",
-                    row.deployed_sha, row.expected_sha
-                )));
-            }
-        }
-
-        frame.render_widget(
-            Paragraph::new(Text::from(lines)).wrap(Wrap { trim: false }),
-            inner,
-        );
-    }
-
-    fn on_key(&mut self, _key: KeyEvent) -> Outcome {
-        Outcome::Ignored
-    }
-}
diff --git a/src/tui/components/sources.rs b/src/tui/components/sources.rs
deleted file mode 100644
index 2d6dc7a..0000000
--- a/src/tui/components/sources.rs
+++ /dev/null
@@ -1,172 +0,0 @@
-use std::path::PathBuf;
-
-use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
-use ratatui::{
-    Frame,
-    layout::{Constraint, Direction, Layout, Rect},
-    style::{Color, Modifier, Style},
-    text::{Line, Span, Text},
-    widgets::{Block, Borders, List, ListItem, Paragraph, Wrap},
-};
-
-use commands::view::DashboardView;
-
-use super::{Component, Outcome};
-
-#[derive(Debug, Clone)]
-pub struct SourcesPane {
-    view: DashboardView,
-    watched_locations: Vec<PathBuf>,
-    query: String,
-    selected: usize,
-    focused: bool,
-}
-
-impl SourcesPane {
-    #[must_use]
-    pub fn new(view: DashboardView, watched_locations: Vec<PathBuf>) -> Self {
-        Self {
-            view,
-            watched_locations,
-            query: String::new(),
-            selected: 0,
-            focused: false,
-        }
-    }
-
-    pub fn set_view(&mut self, view: DashboardView, watched_locations: Vec<PathBuf>) {
-        self.view = view;
-        self.watched_locations = watched_locations;
-        self.clamp_selection();
-    }
-
-    pub fn set_focused(&mut self, focused: bool) {
-        self.focused = focused;
-    }
-
-    pub fn set_query(&mut self, query: impl Into<String>) {
-        self.query = query.into();
-        self.selected = 0;
-        self.clamp_selection();
-    }
-
-    fn filtered_matches(&self) -> Vec<String> {
-        let query = self.query.to_lowercase();
-        self.view
-            .all_artifacts()
-            .into_iter()
-            .filter(|(artifact, _module)| query.is_empty() || artifact.matches_query(&query))
-            .map(|(artifact, module)| format!("{module} / {}", artifact.name))
-            .collect()
-    }
-
-    fn clamp_selection(&mut self) {
-        let len = self.filtered_matches().len();
-        if len == 0 {
-            self.selected = 0;
-        } else if self.selected >= len {
-            self.selected = len - 1;
-        }
-    }
-
-    fn border_style(&self) -> Style {
-        if self.focused {
-            Style::default().fg(Color::Cyan)
-        } else {
-            Style::default().fg(Color::DarkGray)
-        }
-    }
-}
-
-impl Component for SourcesPane {
-    fn render(&self, frame: &mut Frame<'_>, area: Rect) {
-        let block = Block::default()
-            .title(" Sources + watch + find ")
-            .borders(Borders::ALL)
-            .border_style(self.border_style());
-        let inner = block.inner(area);
-        frame.render_widget(block, area);
-
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Length(5),
-                Constraint::Length(3),
-                Constraint::Min(1),
-            ])
-            .split(inner);
-
-        let mut watch_lines = Vec::new();
-        for module in self.view.target_modules() {
-            watch_lines.push(Line::from(format!("target: {}", module.name)));
-        }
-        for path in &self.watched_locations {
-            watch_lines.push(Line::from(format!("watch: {}", path.display())));
-        }
-        if watch_lines.is_empty() {
-            watch_lines.push(Line::from("no watched sources"));
-        }
-        frame.render_widget(
-            Paragraph::new(Text::from(watch_lines)).wrap(Wrap { trim: false }),
-            chunks[0],
-        );
-
-        frame.render_widget(
-            Paragraph::new(format!("find: {}", self.query))
-                .block(Block::default().borders(Borders::ALL)),
-            chunks[1],
-        );
-
-        let matches = self.filtered_matches();
-        let items: Vec<ListItem<'_>> = if matches.is_empty() {
-            vec![ListItem::new("no matches")]
-        } else {
-            matches
-                .into_iter()
-                .enumerate()
-                .map(|(index, label)| {
-                    let style = if index == self.selected {
-                        Style::default()
-                            .fg(Color::Black)
-                            .bg(Color::Cyan)
-                            .add_modifier(Modifier::BOLD)
-                    } else {
-                        Style::default()
-                    };
-                    ListItem::new(Line::from(Span::styled(label, style)))
-                })
-                .collect()
-        };
-        frame.render_widget(List::new(items), chunks[2]);
-    }
-
-    fn on_key(&mut self, key: KeyEvent) -> Outcome {
-        match key.code {
-            KeyCode::Down | KeyCode::Char('j') => {
-                let len = self.filtered_matches().len();
-                if self.selected + 1 < len {
-                    self.selected += 1;
-                }
-                Outcome::Handled
-            }
-            KeyCode::Up | KeyCode::Char('k') => {
-                self.selected = self.selected.saturating_sub(1);
-                Outcome::Handled
-            }
-            KeyCode::Backspace => {
-                self.query.pop();
-                self.clamp_selection();
-                Outcome::Handled
-            }
-            KeyCode::Char(character)
-                if key.modifiers.is_empty() || key.modifiers == KeyModifiers::SHIFT =>
-            {
-                self.query.push(character);
-                self.selected = 0;
-                self.clamp_selection();
-                Outcome::Handled
-            }
-            _ => Outcome::Ignored,
-        }
-    }
-}
diff --git a/src/tui/event.rs b/src/tui/event.rs
index 3ae0c8c..f6b456e 100644
--- a/src/tui/event.rs
+++ b/src/tui/event.rs
@@ -1,29 +1,58 @@
 use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 
-use commands::error::Error;
-
 use super::app::App;
 
-pub fn handle_key(app: &mut App, key: KeyEvent) -> Result<(), Error> {
+pub fn handle_key(app: &mut App, key: KeyEvent) {
     if app.is_preview_open() {
         handle_preview_key(app, key);
-        return Ok(());
+        return;
+    }
+    if app.is_help_open() {
+        match key.code {
+            KeyCode::Esc | KeyCode::Char('?') | KeyCode::F(1) => app.close_help(),
+            _ => {}
+        }
+        return;
     }
     if app.is_palette_open() {
-        return handle_palette_key(app, key);
+        handle_palette_key(app, key);
+        return;
+    }
+    if app.is_search_input_active()
+        && matches!(
+            key.code,
+            KeyCode::Char(_) | KeyCode::Backspace | KeyCode::Esc | KeyCode::Enter
+        )
+    {
+        app.search_input_key(key);
+        return;
+    }
+    if app.has_section_digit_shortcuts()
+        && let KeyCode::Char(character) = key.code
+        && app.set_section_by_shortcut(character)
+    {
+        return;
     }
 
     match key.code {
         KeyCode::Esc | KeyCode::Char('q') => app.request_quit(),
+        KeyCode::Char('?') | KeyCode::F(1) => app.toggle_help(),
         KeyCode::Char(':') => app.open_palette(),
-        KeyCode::Char('r') => app.refresh()?,
-        KeyCode::Enter => app.open_preview(),
+        KeyCode::Char('/') => {
+            app.set_section_by_number(9);
+        }
+        KeyCode::Char('r') => app.refresh(),
+        KeyCode::Char('y') => app.copy_selected(),
+        KeyCode::Enter | KeyCode::Right | KeyCode::Char('l') => app.drill_or_expand(),
+        KeyCode::Left | KeyCode::Char('h') => app.move_back(),
         KeyCode::Tab if key.modifiers.contains(KeyModifiers::SHIFT) => app.focus_previous(),
         KeyCode::BackTab => app.focus_previous(),
         KeyCode::Tab => app.focus_next(),
+        KeyCode::Char('p') => app.set_detail_tab(super::app::DetailTab::Preview),
+        KeyCode::Char('c') => app.set_detail_tab(super::app::DetailTab::Code),
+        KeyCode::Char('d') => app.set_detail_tab(super::app::DetailTab::Diff),
         _ => app.focused_key(key),
     }
-    Ok(())
 }
 
 fn handle_preview_key(app: &mut App, key: KeyEvent) {
@@ -39,11 +68,10 @@ fn handle_preview_key(app: &mut App, key: KeyEvent) {
     }
 }
 
-fn handle_palette_key(app: &mut App, key: KeyEvent) -> Result<(), Error> {
+fn handle_palette_key(app: &mut App, key: KeyEvent) {
     match key.code {
         KeyCode::Esc => app.close_palette(),
-        KeyCode::Enter => app.execute_palette()?,
+        KeyCode::Enter => app.execute_palette(),
         _ => app.palette_key(key),
     }
-    Ok(())
 }
diff --git a/src/tui/mod.rs b/src/tui/mod.rs
index 57cd73a..774ff3f 100644
--- a/src/tui/mod.rs
+++ b/src/tui/mod.rs
@@ -33,7 +33,7 @@ pub fn run() -> i32 {
 }
 
 fn launch() -> Result<(), Box<dyn std::error::Error>> {
-    let mut app = App::load(PathBuf::from("."))?;
+    let mut app = App::load(PathBuf::from("."));
     let mut terminal = setup_terminal()?;
     install_panic_hook();
 
@@ -71,11 +71,12 @@ fn install_panic_hook() {
 
 fn event_loop(terminal: &mut TuiTerminal, app: &mut App) -> Result<(), Box<dyn std::error::Error>> {
     while !app.should_quit() {
+        app.poll_scan();
         terminal.draw(|frame| app.render(frame))?;
         if terminal_event::poll(Duration::from_millis(200))?
             && let terminal_event::Event::Key(key) = terminal_event::read()?
         {
-            event::handle_key(app, key)?;
+            event::handle_key(app, key);
         }
     }
     Ok(())
diff --git a/src/tui/tests.rs b/src/tui/tests.rs
index acdbbd0..92398e9 100644
--- a/src/tui/tests.rs
+++ b/src/tui/tests.rs
@@ -1,15 +1,35 @@
 use std::path::PathBuf;
 
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
 use ratatui::{Terminal, backend::TestBackend};
 
-use commands::view::{ArtifactView, DashboardView, ModuleView, StatusSummary};
+use commands::{
+    manifest::FileStatus,
+    services::files::{
+        ConfigFile, FileSections, HarnessFiles, HarnessHooks, HookEntry, SchemaGroup,
+    },
+    view::{
+        Adr, ArtifactView, DashboardView, GitCommit, ModuleView, ProvenanceArtifact,
+        ProvenanceView, ProviderStatus, StatusSummary,
+    },
+};
 
 use super::{
-    app::App,
+    app::{App, DetailTab, KEYBINDINGS, Section},
     components::palette::{Palette, PaletteCommand},
+    event,
 };
 
 fn fixture_view() -> DashboardView {
+    let mut providers = std::collections::BTreeMap::new();
+    providers.insert(
+        "claude".to_string(),
+        ProviderStatus {
+            status: FileStatus::Unchanged,
+            fingerprint: Some("abc123".to_string()),
+        },
+    );
+
     let artifact = ArtifactView {
         name: "BuildSkill".to_string(),
         kind: "skills".to_string(),
@@ -18,87 +38,365 @@ fn fixture_view() -> DashboardView {
         description: "Build forge skills".to_string(),
         content_preview: "preview".to_string(),
         content_body: "full body".to_string(),
+        raw_source: "---\ndescription: Build forge skills\n---\nfull body".to_string(),
+        metadata: vec![("description".to_string(), "Build forge skills".to_string())],
+        providers,
+        git_log: vec![GitCommit {
+            sha: "abcdef1".to_string(),
+            message: "Implement skill".to_string(),
+            date: "2026-01-02".to_string(),
+            author: "N4M3Z".to_string(),
+            checkpoint: "123456789abc".to_string(),
+            prompt: "Make the skill useful".to_string(),
+            session_count: 2,
+            jj_change: "zzzzzzzz".to_string(),
+        }],
         ..ArtifactView::default()
     };
 
     DashboardView {
-        modules: vec![ModuleView {
-            name: "forge-core".to_string(),
-            version: "0.1.0".to_string(),
-            description: "core module".to_string(),
+        modules: vec![
+            ModuleView {
+                name: "forge-core".to_string(),
+                version: "0.1.0".to_string(),
+                description: "core module".to_string(),
+                source_uri: "https://github.com/N4M3Z/forge-core".to_string(),
+                is_target: false,
+                artifacts: vec![artifact],
+            },
+            ModuleView {
+                name: "project-target".to_string(),
+                version: "0.1.0".to_string(),
+                description: "target module".to_string(),
+                source_uri: "https://github.com/N4M3Z/project-target".to_string(),
+                is_target: true,
+                artifacts: Vec::new(),
+            },
+        ],
+        summary: StatusSummary {
+            unchanged: 1,
+            stale: 0,
+            modified: 0,
+            new: 0,
+        },
+        provenance: vec![ProvenanceView {
             source_uri: "https://github.com/N4M3Z/forge-core".to_string(),
-            is_target: false,
-            artifacts: vec![artifact],
+            verified: 1,
+            total: 1,
+            orphans: Vec::new(),
+            artifacts: vec![ProvenanceArtifact {
+                deployed_path: "skills/BuildSkill/SKILL.md".to_string(),
+                source_path: "skills/BuildSkill/SKILL.md".to_string(),
+                harness: "claude".to_string(),
+                target: "target-one".to_string(),
+                verified: true,
+                deployed_sha: "abc123".to_string(),
+                expected_sha: "abc123".to_string(),
+                input_sha: "abc123".to_string(),
+            }],
+        }],
+        adrs: vec![Adr {
+            id: "ADR-0001".to_string(),
+            title: "Use Miller columns".to_string(),
+            status: "accepted".to_string(),
+            repo: "forge-core".to_string(),
+            source_uri: "https://github.com/N4M3Z/forge-core".to_string(),
+            relative_path: "docs/decisions/ADR-0001.md".to_string(),
+            state: "authored".to_string(),
+            source: String::new(),
+            summary: "Context summary".to_string(),
         }],
-        summary: StatusSummary::default(),
-        provenance: Vec::new(),
-        adrs: Vec::new(),
     }
 }
 
 fn fixture_app() -> App {
-    App::from_view(PathBuf::from("."), Vec::new(), Vec::new(), fixture_view())
+    App::from_view_with_files(
+        PathBuf::from("."),
+        Vec::new(),
+        Vec::new(),
+        fixture_view(),
+        fixture_file_sections(),
+    )
 }
 
-#[test]
-fn app_constructs_from_fixture_snapshot() {
-    let app = fixture_app();
-    assert!(!app.should_quit());
+fn fixture_file_sections() -> FileSections {
+    let settings_file = ConfigFile {
+        label: "settings.json".to_string(),
+        path: "~/.claude/settings.json".to_string(),
+        language: "json".to_string(),
+        content: r#"{"hooks":{"PreToolUse":[{"matcher":"Write","hooks":[{"command":"bash -c 'echo fixture-hook'"}]}]}}"#
+            .to_string(),
+    };
+    FileSections {
+        settings: vec![HarnessFiles {
+            harness: "claude".to_string(),
+            files: vec![settings_file.clone()],
+        }],
+        hooks: vec![HarnessHooks {
+            harness: "claude".to_string(),
+            hooks: vec![HookEntry {
+                event: "PreToolUse".to_string(),
+                matcher: "Write".to_string(),
+                command: "bash -c 'echo fixture-hook'".to_string(),
+                source: "~/.claude/settings.json".to_string(),
+            }],
+        }],
+        config: vec![ConfigFile {
+            label: "Module manifest".to_string(),
+            path: "./module.yaml".to_string(),
+            language: "yaml".to_string(),
+            content: "name: forge-fixture\n".to_string(),
+        }],
+        schemas: vec![SchemaGroup {
+            source: "forge-core".to_string(),
+            files: vec![ConfigFile {
+                label: "skills/.mdschema".to_string(),
+                path: "./skills/.mdschema".to_string(),
+                language: "yaml".to_string(),
+                content: "kind: skills\n".to_string(),
+            }],
+        }],
+    }
 }
 
-#[test]
-fn artifacts_pane_renders_artifact_name() {
-    let backend = TestBackend::new(100, 30);
+fn rendered(app: &mut App) -> String {
+    let backend = TestBackend::new(120, 32);
     let mut terminal = Terminal::new(backend).expect("test backend");
-    let mut app = fixture_app();
-
     terminal.draw(|frame| app.render(frame)).expect("render");
-
-    let rendered: String = terminal
+    terminal
         .backend()
         .buffer()
         .content()
         .iter()
         .map(ratatui::buffer::Cell::symbol)
-        .collect();
-    assert!(rendered.contains("BuildSkill"));
+        .collect()
+}
+
+fn key(code: KeyCode) -> KeyEvent {
+    KeyEvent::new(code, KeyModifiers::NONE)
+}
+
+#[test]
+fn app_loads_in_background_and_renders_scanning_shell() {
+    let temp = tempfile::tempdir().expect("tempdir");
+    let mut app = App::load(temp.path().to_path_buf());
+
+    let output = rendered(&mut app);
+
+    assert!(output.contains("Scanning modules"));
+    assert!(output.contains("Sections"));
+    assert!(output.contains("Overview"));
+}
+
+#[test]
+fn miller_sections_and_skills_list_render() {
+    let mut app = fixture_app();
+    app.set_section_by_number(2);
+
+    let output = rendered(&mut app);
+
+    assert!(output.contains("Overview"));
+    assert!(output.contains("Skills"));
+    assert!(output.contains("BuildSkill"));
+}
+
+#[test]
+fn drilling_to_skill_detail_renders_body() {
+    let mut app = fixture_app();
+    app.set_section_by_number(2);
+    app.focus_next();
+    app.drill_or_expand();
+
+    let output = rendered(&mut app);
+
+    assert!(output.contains("full body"));
+    assert!(output.contains("Build forge skills"));
+}
+
+#[test]
+fn provenance_and_history_tabs_render_scanned_data() {
+    let mut app = fixture_app();
+    app.set_section_by_number(2);
+    app.focus_next();
+    app.drill_or_expand();
+    app.set_detail_tab(DetailTab::Provenance);
+
+    let provenance = rendered(&mut app);
+    assert!(provenance.contains("target-one"));
+    assert!(provenance.contains("OK"));
+
+    app.set_detail_tab(DetailTab::History);
+    let history = rendered(&mut app);
+    assert!(history.contains("Implement skill"));
+    assert!(history.contains("Make the skill useful"));
+}
+
+#[test]
+fn adrs_section_lists_fixture_adr() {
+    let mut app = fixture_app();
+    app.set_section_by_number(6);
+
+    let output = rendered(&mut app);
+
+    assert!(output.contains("ADR-0001"));
+    assert!(output.contains("Use Miller columns"));
+}
+
+#[test]
+fn enter_on_repositories_does_not_open_artifact_preview() {
+    let mut app = fixture_app();
+    app.set_section_by_number(5);
+    app.focus_next();
+
+    event::handle_key(&mut app, key(KeyCode::Enter));
+
+    assert!(!app.is_preview_open());
+    let output = rendered(&mut app);
+    assert!(output.contains("project-target"));
+    assert!(!output.contains("full body"));
 }
 
 #[test]
-fn palette_parses_refresh() {
+fn help_overlay_renders_known_binding_and_quit() {
+    let mut app = fixture_app();
+
+    event::handle_key(&mut app, key(KeyCode::Char('?')));
+    let output = rendered(&mut app);
+
+    assert!(output.contains('?'));
+    assert!(output.contains("quit"));
+}
+
+#[test]
+fn keybindings_table_drives_help_and_hint_row() {
+    let binding = KEYBINDINGS
+        .iter()
+        .flat_map(|(_, bindings)| bindings.iter())
+        .find(|(key, _)| *key == "h/j/k/l")
+        .expect("navigation binding");
+    assert_eq!(binding.1, "move, drill, and go back");
+
+    let mut app = fixture_app();
+    let hint = rendered(&mut app);
+    assert!(hint.contains("h/j/k/l move, drill, and go back"));
+
+    event::handle_key(&mut app, key(KeyCode::Char('?')));
+    let help = rendered(&mut app);
+    assert!(help.contains("move, drill, and go back"));
+}
+
+#[test]
+fn palette_parses_dashboard_parity_commands() {
     assert_eq!(Palette::parse_command("refresh"), PaletteCommand::Refresh);
     assert_eq!(Palette::parse_command(" r "), PaletteCommand::Refresh);
+    assert_eq!(
+        Palette::parse_command("find build"),
+        PaletteCommand::Find("build".to_string())
+    );
+    assert_eq!(
+        Palette::parse_command("skills"),
+        PaletteCommand::GoTo("skills".to_string())
+    );
+    assert_eq!(
+        Palette::parse_command("sort staleness"),
+        PaletteCommand::Sort("staleness".to_string())
+    );
+    assert_eq!(
+        Palette::parse_command("filter attention"),
+        PaletteCommand::Filter("attention".to_string())
+    );
+    assert_eq!(
+        Palette::parse_command("settings"),
+        PaletteCommand::GoTo("settings".to_string())
+    );
+    assert_eq!(
+        Palette::parse_command("hooks"),
+        PaletteCommand::GoTo("hooks".to_string())
+    );
+    assert_eq!(
+        Palette::parse_command("config"),
+        PaletteCommand::GoTo("config".to_string())
+    );
+    assert_eq!(
+        Palette::parse_command("schemas"),
+        PaletteCommand::GoTo("schemas".to_string())
+    );
 }
 
 #[test]
 fn unknown_palette_command_sets_error() {
     let mut app = fixture_app();
-    app.execute_palette_command(PaletteCommand::Unknown("wat".to_string()))
-        .expect("unknown command is nonfatal");
+    app.execute_palette_command(PaletteCommand::Unknown("wat".to_string()));
     assert_eq!(app.palette_error.as_deref(), Some("unknown command: wat"));
 }
 
 #[test]
-fn enter_opens_full_preview_rendering_the_body() {
-    let backend = TestBackend::new(80, 24);
-    let mut terminal = Terminal::new(backend).expect("test backend");
+fn search_section_list_focus_types_query_before_global_shortcuts() {
     let mut app = fixture_app();
-    assert!(!app.is_preview_open());
+    app.set_section_by_number(9);
+    app.focus_next();
 
-    app.open_preview();
-    assert!(app.is_preview_open());
+    for character in ['h', 'e', 'l', 'l', 'o'] {
+        event::handle_key(&mut app, key(KeyCode::Char(character)));
+    }
 
-    terminal.draw(|frame| app.render(frame)).expect("render");
-    let rendered: String = terminal
-        .backend()
-        .buffer()
-        .content()
-        .iter()
-        .map(ratatui::buffer::Cell::symbol)
-        .collect();
-    assert!(rendered.contains("full body"));
-    assert!(rendered.contains("SKILL.md"));
+    assert_eq!(app.search_query(), "hello");
+    assert_eq!(app.section(), Section::Search);
+}
 
-    app.close_preview();
-    assert!(!app.is_preview_open());
+#[test]
+fn detail_digit_shortcut_selects_tab_without_changing_section() {
+    let mut app = fixture_app();
+    app.focus_next();
+    app.focus_next();
+
+    event::handle_key(&mut app, key(KeyCode::Char('2')));
+
+    assert_eq!(app.detail_tab(), DetailTab::Code);
+    assert_eq!(app.section(), Section::Overview);
+}
+
+#[test]
+fn render_reuses_cached_list_rows_between_frames() {
+    let mut app = fixture_app();
+
+    let _ = rendered(&mut app);
+    assert_eq!(app.row_build_count(), 1);
+
+    let _ = rendered(&mut app);
+    assert_eq!(app.row_build_count(), 1);
+}
+
+#[test]
+fn settings_section_lists_fixture_file_and_detail_body() {
+    let mut app = fixture_app();
+    app.execute_palette_command(PaletteCommand::GoTo("settings".to_string()));
+
+    let output = rendered(&mut app);
+    assert!(output.contains("claude"));
+    assert!(output.contains("settings.json"));
+
+    app.focus_next();
+    app.drill_or_expand();
+    let detail = rendered(&mut app);
+    assert!(detail.contains("PreToolUse"));
+    assert!(detail.contains("fixture-hook"));
+}
+
+#[test]
+fn hooks_section_lists_fixture_hook_and_detail() {
+    let mut app = fixture_app();
+    app.execute_palette_command(PaletteCommand::GoTo("hooks".to_string()));
+
+    let output = rendered(&mut app);
+    assert!(output.contains("PreToolUse"));
+    assert!(output.contains("Write"));
+    assert!(output.contains("echo fixture-hook"));
+
+    app.focus_next();
+    app.drill_or_expand();
+    let detail = rendered(&mut app);
+    assert!(detail.contains("source:"));
+    assert!(detail.contains("~/.claude/settings.json"));
+    assert!(detail.contains("echo fixture-hook"));
 }