diff --git a/cli/src/cli_schema.rs b/cli/src/cli_schema.rs
index 1b113f67..d1b2ff40 100644
--- a/cli/src/cli_schema.rs
+++ b/cli/src/cli_schema.rs
@@ -47,6 +47,10 @@ pub const COMPLETION_CLAP_ABOUT: &str = "Generate deterministic shell completion
 pub const COMPLETION_TOP_LEVEL_PURPOSE: &str = "Generate deterministic shell completion scripts";
 pub const COMPLETION_SHOW_IN_TOP_LEVEL_HELP: bool = true;
 
+pub const TRACE_CLAP_ABOUT: &str = "Inspect Agent Trace databases and recorded activity";
+pub const TRACE_TOP_LEVEL_PURPOSE: &str = "Inspect Agent Trace databases and recorded activity";
+pub const TRACE_SHOW_IN_TOP_LEVEL_HELP: bool = true;
+
 pub const TOP_LEVEL_COMMANDS: &[TopLevelCommandMetadata] = &[
     TopLevelCommandMetadata {
         name: crate::services::auth_command::NAME,
@@ -88,6 +92,11 @@ pub const TOP_LEVEL_COMMANDS: &[TopLevelCommandMetadata] = &[
         purpose: COMPLETION_TOP_LEVEL_PURPOSE,
         show_in_top_level_help: COMPLETION_SHOW_IN_TOP_LEVEL_HELP,
     },
+    TopLevelCommandMetadata {
+        name: crate::services::trace::NAME,
+        purpose: TRACE_TOP_LEVEL_PURPOSE,
+        show_in_top_level_help: TRACE_SHOW_IN_TOP_LEVEL_HELP,
+    },
 ];
 
 #[derive(Parser, Debug)]
@@ -184,9 +193,6 @@ pub enum Commands {
 
         #[arg(long, value_enum, default_value_t = OutputFormat::Text)]
         format: OutputFormat,
-
-        #[command(subcommand)]
-        subcommand: Option<DoctorSubcommand>,
     },
 
     #[command(about = HOOKS_CLAP_ABOUT, hide = !HOOKS_SHOW_IN_TOP_LEVEL_HELP)]
@@ -212,15 +218,45 @@ pub enum Commands {
         #[arg(long, value_enum)]
         shell: CompletionShell,
     },
+
+    #[command(about = TRACE_CLAP_ABOUT, hide = !TRACE_SHOW_IN_TOP_LEVEL_HELP)]
+    Trace {
+        #[command(subcommand)]
+        subcommand: TraceSubcommand,
+    },
+}
+
+#[derive(Subcommand, Debug, Clone, PartialEq, Eq)]
+pub enum TraceSubcommand {
+    #[command(about = "Inspect discovered Agent Trace databases")]
+    Db {
+        #[command(subcommand)]
+        subcommand: TraceDbSubcommand,
+    },
+
+    #[command(about = "Show Agent Trace activity for the current checkout (or all with --all)")]
+    Status {
+        #[arg(long)]
+        all: bool,
+
+        #[arg(long, value_enum, default_value_t = OutputFormat::Text)]
+        format: OutputFormat,
+    },
 }
 
 #[derive(Subcommand, Debug, Clone, PartialEq, Eq)]
-pub enum DoctorSubcommand {
-    #[command(about = "List registered Agent Trace checkouts and databases")]
-    Dbs {
+pub enum TraceDbSubcommand {
+    #[command(about = "List discovered Agent Trace databases with readiness")]
+    List {
         #[arg(long, value_enum, default_value_t = OutputFormat::Text)]
         format: OutputFormat,
     },
+
+    #[command(about = "Open an embedded SQL shell for a discovered Agent Trace database")]
+    Shell {
+        #[arg(value_name = "uuid-or-alias")]
+        identifier: String,
+    },
 }
 
 #[derive(Subcommand, Debug, Clone, PartialEq, Eq)]
diff --git a/cli/src/services/checkout/mod.rs b/cli/src/services/checkout/mod.rs
index b87f76bb..fb7e23a2 100644
--- a/cli/src/services/checkout/mod.rs
+++ b/cli/src/services/checkout/mod.rs
@@ -5,8 +5,8 @@
 //! string, consistent with the existing `agent_trace_id` convention in this
 //! codebase.
 //!
-//! Checkout databases are now discovered via filesystem scan in `sce doctor dbs`
-//! (see `cli/src/services/doctor/mod.rs`). There is no central registry file.
+//! Checkout databases are discovered via filesystem scan in `sce trace db list`
+//! (see `cli/src/services/trace/`). There is no central registry file.
 
 use std::path::{Path, PathBuf};
 use std::process::Command;
diff --git a/cli/src/services/command_registry.rs b/cli/src/services/command_registry.rs
index b07d50a8..2a43406d 100644
--- a/cli/src/services/command_registry.rs
+++ b/cli/src/services/command_registry.rs
@@ -13,6 +13,7 @@ const DEFAULT_COMMAND_NAMES: &[&str] = &[
     services::hooks::NAME,
     services::bash_policy::NAME,
     services::setup::NAME,
+    services::trace::NAME,
     services::version::NAME,
 ];
 
@@ -32,6 +33,7 @@ pub enum RuntimeCommand {
     Policy(services::bash_policy::command::PolicyCommand),
     Version(services::version::command::VersionCommand),
     Completion(services::completion::command::CompletionCommand),
+    Trace(services::trace::command::TraceCommand),
 }
 
 impl RuntimeCommand {
@@ -47,6 +49,7 @@ impl RuntimeCommand {
             Self::Policy(_) => Cow::Borrowed(services::bash_policy::NAME),
             Self::Version(_) => Cow::Borrowed(services::version::NAME),
             Self::Completion(_) => Cow::Borrowed(services::completion::NAME),
+            Self::Trace(_) => Cow::Borrowed(services::trace::NAME),
         }
     }
 
@@ -65,6 +68,7 @@ impl RuntimeCommand {
             Self::Policy(command) => command.execute(),
             Self::Version(command) => command.execute(context),
             Self::Completion(command) => Ok(command.execute(context)),
+            Self::Trace(command) => command.execute(context),
         }
     }
 }
@@ -139,7 +143,6 @@ pub fn default_runtime_command(name: &str) -> Option<RuntimeCommand> {
         services::doctor::NAME => Some(RuntimeCommand::Doctor(
             services::doctor::command::DoctorCommand {
                 request: services::doctor::DoctorRequest {
-                    action: services::doctor::DoctorAction::Report,
                     mode: services::doctor::DoctorMode::Diagnose,
                     format: services::doctor::DoctorFormat::Text,
                 },
@@ -172,6 +175,15 @@ pub fn default_runtime_command(name: &str) -> Option<RuntimeCommand> {
                 },
             },
         )),
+        services::trace::NAME => Some(RuntimeCommand::Trace(
+            services::trace::command::TraceCommand {
+                request: services::trace::TraceRequest {
+                    subcommand: services::trace::TraceSubcommandRequest::DbList {
+                        format: services::output_format::OutputFormat::Text,
+                    },
+                },
+            },
+        )),
         _ => None,
     }
 }
@@ -195,6 +207,7 @@ mod tests {
                 "hooks",
                 "policy",
                 "setup",
+                "trace",
                 "version"
             ]
         );
diff --git a/cli/src/services/db/mod.rs b/cli/src/services/db/mod.rs
index 59849e0f..df37e607 100644
--- a/cli/src/services/db/mod.rs
+++ b/cli/src/services/db/mod.rs
@@ -11,6 +11,7 @@ use std::{
 };
 
 use anyhow::{Context, Result};
+use turso::Value as TursoValue;
 
 use crate::services::lifecycle::{
     HealthCategory, HealthFixability, HealthProblem, HealthProblemKind, HealthSeverity,
@@ -312,6 +313,15 @@ pub struct TursoDb<M: DbSpec> {
     core: TursoConnectionCore<M>,
 }
 
+/// Fully fetched SQL query result for deterministic rendering outside the
+/// async Turso row iterator lifetime.
+#[derive(Clone, Debug, PartialEq)]
+#[allow(dead_code)]
+pub struct QueryRows {
+    pub columns: Vec<String>,
+    pub rows: Vec<Vec<TursoValue>>,
+}
+
 /// Generic encrypted Turso database adapter.
 ///
 /// Mirrors the structural seams of [`TursoDb`] while reserving encrypted local
@@ -469,6 +479,57 @@ impl<M: DbSpec> TursoDb<M> {
         )
     }
 
+    /// Execute a SQL query and synchronously fetch column names plus raw values.
+    #[allow(dead_code)]
+    pub fn query_values(
+        &self,
+        sql: &str,
+        params: impl turso::params::IntoParams,
+    ) -> Result<QueryRows> {
+        let params = turso::params::IntoParams::into_params(params).map_err(|e| {
+            anyhow::anyhow!("{} parameter conversion failed: {sql}: {e}", M::db_name())
+        })?;
+        let operation_name = format!("query and fetch {} database values", M::db_name());
+
+        run_with_retry_sync(
+            resolve_query_retry_policy::<M>(),
+            &operation_name,
+            QUERY_RETRY_HINT,
+            |_| {
+                self.core.runtime.block_on(async {
+                    let mut rows =
+                        self.core
+                            .conn
+                            .query(sql, params.clone())
+                            .await
+                            .map_err(|e| {
+                                anyhow::anyhow!("{} query failed: {sql}: {e}", M::db_name())
+                            })?;
+                    let columns = rows.column_names();
+                    let column_count = rows.column_count();
+                    let mut fetched_rows = Vec::new();
+
+                    while let Some(row) = rows.next().await.map_err(|e| {
+                        anyhow::anyhow!("{} row fetch failed: {sql}: {e}", M::db_name())
+                    })? {
+                        let mut values = Vec::with_capacity(column_count);
+                        for column_index in 0..column_count {
+                            values.push(row.get_value(column_index).map_err(|e| {
+                                anyhow::anyhow!("{} value fetch failed: {sql}: {e}", M::db_name())
+                            })?);
+                        }
+                        fetched_rows.push(values);
+                    }
+
+                    Ok(QueryRows {
+                        columns,
+                        rows: fetched_rows,
+                    })
+                })
+            },
+        )
+    }
+
     /// Execute a SQL query and synchronously map all returned rows.
     pub fn query_map<T, F>(
         &self,
diff --git a/cli/src/services/doctor/mod.rs b/cli/src/services/doctor/mod.rs
index 4c5d8de0..4ad657c6 100644
--- a/cli/src/services/doctor/mod.rs
+++ b/cli/src/services/doctor/mod.rs
@@ -3,8 +3,6 @@ use std::path::{Path, PathBuf};
 use std::process::Command;
 
 use anyhow::{Context, Result};
-use chrono::{DateTime, Utc};
-use serde_json::json;
 
 use crate::app::{ContextWithRepoRoot, HasRepoRoot};
 use crate::services::default_paths::{resolve_sce_default_locations, resolve_state_data_root};
@@ -42,15 +40,8 @@ pub enum DoctorMode {
     Fix,
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum DoctorAction {
-    Report,
-    Dbs,
-}
-
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub struct DoctorRequest {
-    pub action: DoctorAction,
     pub mode: DoctorMode,
     pub format: DoctorFormat,
 }
@@ -68,17 +59,6 @@ struct DoctorExecution {
     fix_results: Vec<DoctorFixResultRecord>,
 }
 
-/// A checkout discovered from agent-trace-*.db files on disk.
-#[derive(Clone, Debug)]
-struct DiscoveredCheckout {
-    /// Stable `UUIDv7` checkout identity extracted from the filename.
-    checkout_id: String,
-    /// Absolute path to the per-checkout database file.
-    database_path: String,
-    /// ISO 8601 timestamp from file mtime.
-    last_seen: String,
-}
-
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct ProviderDoctorProblem {
     provider_id: LifecycleProviderId,
@@ -89,10 +69,6 @@ pub fn run_doctor_with_context<C>(request: DoctorRequest, context: &C) -> Result
 where
     C: ContextWithRepoRoot,
 {
-    if request.action == DoctorAction::Dbs {
-        return run_doctor_dbs(request.format);
-    }
-
     let repository_root = if let Some(path) = context.repo_root() {
         path.to_path_buf()
     } else {
@@ -105,122 +81,6 @@ where
     render_report(request, &execution)
 }
 
-fn run_doctor_dbs(format: DoctorFormat) -> Result<String> {
-    let mut checkouts = discover_checkouts_from_filesystem()
-        .context("failed to discover checkouts from filesystem")?;
-    sort_checkouts_by_last_seen_desc(&mut checkouts);
-
-    match format {
-        DoctorFormat::Text => Ok(render_doctor_dbs_text(&checkouts)),
-        DoctorFormat::Json => render_doctor_dbs_json(&checkouts),
-    }
-}
-
-/// Scans `<state_root>/sce/` for `agent-trace-*.db` files and derives checkout
-/// metadata from each discovered file.
-fn discover_checkouts_from_filesystem() -> Result<Vec<DiscoveredCheckout>> {
-    let state_root = resolve_state_data_root().context("failed to resolve state data root")?;
-    let sce_dir = state_root.join("sce");
-
-    if !sce_dir.is_dir() {
-        return Ok(Vec::new());
-    }
-
-    let mut checkouts: Vec<DiscoveredCheckout> = Vec::new();
-
-    for entry in fs::read_dir(&sce_dir)
-        .with_context(|| format!("failed to read sce directory '{}'", sce_dir.display()))?
-    {
-        let entry = entry.with_context(|| {
-            format!("failed to read directory entry in '{}'", sce_dir.display())
-        })?;
-
-        let file_name = entry.file_name();
-        let file_name_str = file_name.to_string_lossy();
-
-        // Match agent-trace-{id}.db
-        let Some(stripped) = file_name_str.strip_prefix("agent-trace-") else {
-            continue;
-        };
-        let Some(checkout_id) = stripped.strip_suffix(".db") else {
-            continue;
-        };
-        if checkout_id.is_empty() {
-            continue;
-        }
-
-        let metadata = entry
-            .metadata()
-            .with_context(|| format!("failed to read metadata for '{}'", entry.path().display()))?;
-
-        if !metadata.is_file() {
-            continue;
-        }
-
-        let last_seen: String = metadata.modified().ok().map_or_else(
-            || String::from("unknown"),
-            |mtime| {
-                let dt: DateTime<Utc> = mtime.into();
-                dt.to_rfc3339()
-            },
-        );
-
-        let database_path = entry
-            .path()
-            .to_str()
-            .map_or_else(|| String::from("unknown"), String::from);
-
-        checkouts.push(DiscoveredCheckout {
-            checkout_id: checkout_id.to_string(),
-            database_path,
-            last_seen,
-        });
-    }
-
-    Ok(checkouts)
-}
-
-fn sort_checkouts_by_last_seen_desc(checkouts: &mut [DiscoveredCheckout]) {
-    checkouts.sort_by(|left, right| {
-        right
-            .last_seen
-            .cmp(&left.last_seen)
-            .then_with(|| left.checkout_id.cmp(&right.checkout_id))
-    });
-}
-
-fn render_doctor_dbs_text(checkouts: &[DiscoveredCheckout]) -> String {
-    let mut lines = vec![String::from("SCE doctor dbs")];
-
-    if checkouts.is_empty() {
-        lines.push(String::from("no registered checkouts"));
-        return lines.join("\n");
-    }
-
-    for checkout in checkouts {
-        lines.push(format!("checkout_id: {}", checkout.checkout_id));
-        lines.push(format!("  database_path: {}", checkout.database_path));
-        lines.push(format!("  last_seen: {}", checkout.last_seen));
-    }
-
-    lines.join("\n")
-}
-
-fn render_doctor_dbs_json(checkouts: &[DiscoveredCheckout]) -> Result<String> {
-    let payload = json!({
-        "status": "ok",
-        "command": NAME,
-        "subcommand": "dbs",
-        "checkouts": checkouts.iter().map(|checkout| json!({
-            "checkout_id": checkout.checkout_id,
-            "database_path": checkout.database_path,
-            "last_seen": checkout.last_seen,
-        })).collect::<Vec<_>>(),
-    });
-
-    serde_json::to_string_pretty(&payload).context("failed to serialize doctor dbs report to JSON")
-}
-
 fn execute_doctor_with_context(
     request: DoctorRequest,
     repository_root: &Path,
diff --git a/cli/src/services/mod.rs b/cli/src/services/mod.rs
index f7ca8fcd..d4fafa2a 100644
--- a/cli/src/services/mod.rs
+++ b/cli/src/services/mod.rs
@@ -29,4 +29,5 @@ pub mod setup;
 pub mod structured_patch;
 pub mod style;
 pub mod token_storage;
+pub mod trace;
 pub mod version;
diff --git a/cli/src/services/parse/command_runtime.rs b/cli/src/services/parse/command_runtime.rs
index 0d9bfe57..e2ea8b60 100644
--- a/cli/src/services/parse/command_runtime.rs
+++ b/cli/src/services/parse/command_runtime.rs
@@ -222,11 +222,7 @@ fn convert_clap_command(command: cli_schema::Commands) -> Result<RuntimeCommand,
             hooks,
             repo,
         } => convert_setup_command(opencode, claude, both, non_interactive, hooks, repo),
-        cli_schema::Commands::Doctor {
-            fix,
-            format,
-            subcommand,
-        } => convert_doctor_command(fix, format, subcommand.as_ref()),
+        cli_schema::Commands::Doctor { fix, format } => Ok(convert_doctor_command(fix, format)),
         cli_schema::Commands::Hooks { subcommand } => convert_hooks_subcommand(subcommand),
         cli_schema::Commands::Policy { subcommand } => Ok(convert_policy_subcommand(&subcommand)),
         cli_schema::Commands::Version { format } => Ok(RuntimeCommand::Version(
@@ -241,41 +237,43 @@ fn convert_clap_command(command: cli_schema::Commands) -> Result<RuntimeCommand,
                 },
             },
         )),
+        cli_schema::Commands::Trace { subcommand } => Ok(convert_trace_subcommand(subcommand)),
     }
 }
 
+#[allow(clippy::needless_pass_by_value)]
+fn convert_trace_subcommand(subcommand: cli_schema::TraceSubcommand) -> RuntimeCommand {
+    let request = match subcommand {
+        cli_schema::TraceSubcommand::Db { subcommand } => match subcommand {
+            cli_schema::TraceDbSubcommand::List { format } => services::trace::TraceRequest {
+                subcommand: services::trace::TraceSubcommandRequest::DbList { format },
+            },
+            cli_schema::TraceDbSubcommand::Shell { identifier } => services::trace::TraceRequest {
+                subcommand: services::trace::TraceSubcommandRequest::DbShell { identifier },
+            },
+        },
+        cli_schema::TraceSubcommand::Status { all, format } => services::trace::TraceRequest {
+            subcommand: services::trace::TraceSubcommandRequest::Status { all, format },
+        },
+    };
+
+    RuntimeCommand::Trace(services::trace::command::TraceCommand { request })
+}
+
 fn convert_doctor_command(
     fix: bool,
     format: services::output_format::OutputFormat,
-    subcommand: Option<&cli_schema::DoctorSubcommand>,
-) -> Result<RuntimeCommand, ClassifiedError> {
-    let request = match subcommand {
-        Some(cli_schema::DoctorSubcommand::Dbs { format }) => {
-            if fix {
-                return Err(ClassifiedError::validation(
-                    "'sce doctor dbs' cannot be used with '--fix'. Try: run 'sce doctor dbs --format text' or 'sce doctor --fix'.",
-                ));
-            }
-            services::doctor::DoctorRequest {
-                action: services::doctor::DoctorAction::Dbs,
-                mode: services::doctor::DoctorMode::Diagnose,
-                format: *format,
-            }
-        }
-        None => services::doctor::DoctorRequest {
-            action: services::doctor::DoctorAction::Report,
-            mode: if fix {
-                services::doctor::DoctorMode::Fix
-            } else {
-                services::doctor::DoctorMode::Diagnose
-            },
-            format,
+) -> RuntimeCommand {
+    let request = services::doctor::DoctorRequest {
+        mode: if fix {
+            services::doctor::DoctorMode::Fix
+        } else {
+            services::doctor::DoctorMode::Diagnose
         },
+        format,
     };
 
-    Ok(RuntimeCommand::Doctor(
-        services::doctor::command::DoctorCommand { request },
-    ))
+    RuntimeCommand::Doctor(services::doctor::command::DoctorCommand { request })
 }
 
 fn convert_policy_subcommand(subcommand: &cli_schema::PolicySubcommand) -> RuntimeCommand {
@@ -489,3 +487,47 @@ fn parse_optional_hook_remote_url(remote_url: Option<String>) -> Result<String,
         _ => Err("Missing required option '--remote-url' for 'sce hooks post-commit'.".to_string()),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn parse(args: &[&str]) -> RuntimeCommand {
+        parse_runtime_command(
+            args.iter().map(|arg| (*arg).to_string()),
+            &CommandRegistry::default(),
+            None,
+        )
+        .expect("command should parse")
+    }
+
+    #[test]
+    fn trace_db_shell_parses_to_trace_shell_request() {
+        let command = parse(&["sce", "trace", "db", "shell", "agent_trace_0"]);
+
+        let RuntimeCommand::Trace(command) = command else {
+            panic!("expected trace command");
+        };
+
+        assert_eq!(
+            command.request.subcommand,
+            services::trace::TraceSubcommandRequest::DbShell {
+                identifier: String::from("agent_trace_0"),
+            }
+        );
+    }
+
+    #[test]
+    fn trace_db_help_lists_shell_subcommand() {
+        let command = parse(&["sce", "trace", "db", "--help"]);
+
+        let RuntimeCommand::HelpText(command) = command else {
+            panic!("expected help text command");
+        };
+
+        assert!(command.text.contains("shell"));
+        assert!(command
+            .text
+            .contains("Open an embedded SQL shell for a discovered Agent Trace database"));
+    }
+}
diff --git a/cli/src/services/trace/command.rs b/cli/src/services/trace/command.rs
new file mode 100644
index 00000000..6685baa3
--- /dev/null
+++ b/cli/src/services/trace/command.rs
@@ -0,0 +1,78 @@
+use crate::app::ContextWithRepoRoot;
+use crate::services::error::ClassifiedError;
+use crate::services::trace::discovery::discover_agent_trace_dbs;
+use crate::services::trace::render_list;
+use crate::services::trace::render_status;
+use crate::services::trace::render_status_all;
+use crate::services::trace::shell::{run_agent_trace_db_shell, ShellTarget};
+use crate::services::trace::status::{resolve_current_status, StatusErrorOrRuntime};
+use crate::services::trace::status_all::aggregate_current_status_all;
+use crate::services::trace::{
+    resolve_agent_trace_db_identifier, TraceRequest, TraceSubcommandRequest,
+};
+
+pub struct TraceCommand {
+    pub request: TraceRequest,
+}
+
+impl TraceCommand {
+    pub fn execute<C>(&self, context: &C) -> Result<String, ClassifiedError>
+    where
+        C: ContextWithRepoRoot,
+    {
+        match &self.request.subcommand {
+            TraceSubcommandRequest::DbList { format } => {
+                let databases = discover_agent_trace_dbs()
+                    .map_err(|error| ClassifiedError::runtime(format!("{error:#}")))?;
+                render_list::render(&databases, *format)
+                    .map_err(|error| ClassifiedError::runtime(format!("{error:#}")))
+            }
+            TraceSubcommandRequest::DbShell { identifier } => {
+                let databases = discover_agent_trace_dbs()
+                    .map_err(|error| ClassifiedError::runtime(format!("{error:#}")))?;
+                let database = resolve_agent_trace_db_identifier(&databases, identifier)
+                    .map_err(|error| ClassifiedError::validation(error.user_message()))?;
+                let target = ShellTarget {
+                    alias: database.alias,
+                    checkout_id: database.checkout_id,
+                    path: database.path,
+                };
+
+                let stdin = std::io::stdin();
+                let stdout = std::io::stdout();
+                run_agent_trace_db_shell(&target, stdin.lock(), stdout.lock())
+                    .map_err(|error| ClassifiedError::runtime(format!("{error:#}")))?;
+                Ok(String::new())
+            }
+            TraceSubcommandRequest::Status { all: true, format } => {
+                let report = aggregate_current_status_all()
+                    .map_err(|error| ClassifiedError::runtime(format!("{error:#}")))?;
+                render_status_all::render(&report, *format)
+                    .map_err(|error| ClassifiedError::runtime(format!("{error:#}")))
+            }
+            TraceSubcommandRequest::Status { all: false, format } => {
+                let repo_root = if let Some(path) = context.repo_root() {
+                    path.to_path_buf()
+                } else {
+                    std::env::current_dir().map_err(|err| {
+                        ClassifiedError::runtime(format!(
+                            "failed to determine current directory: {err}"
+                        ))
+                    })?
+                };
+
+                let report = resolve_current_status(&repo_root).map_err(|err| match err {
+                    StatusErrorOrRuntime::Status(status_err) => {
+                        ClassifiedError::validation(status_err.user_message())
+                    }
+                    StatusErrorOrRuntime::Runtime(runtime_err) => {
+                        ClassifiedError::runtime(format!("{runtime_err:#}"))
+                    }
+                })?;
+
+                render_status::render(&report, *format)
+                    .map_err(|error| ClassifiedError::runtime(format!("{error:#}")))
+            }
+        }
+    }
+}
diff --git a/cli/src/services/trace/discovery.rs b/cli/src/services/trace/discovery.rs
new file mode 100644
index 00000000..e60ddeee
--- /dev/null
+++ b/cli/src/services/trace/discovery.rs
@@ -0,0 +1,354 @@
+//! Deterministic discovery of per-checkout Agent Trace databases.
+//!
+//! Scans `<state_root>/sce/agent-trace-{checkout_id}.db`, sorts by file mtime
+//! descending with ties broken by `checkout_id` ascending, assigns positional
+//! aliases `agent_trace_{i}`, and probes each file for the required schema.
+
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::time::SystemTime;
+
+use anyhow::{Context, Result};
+
+use crate::services::agent_trace_db::AgentTraceDb;
+use crate::services::default_paths::resolve_state_data_root;
+
+const LIST_GUIDANCE: &str = "Run `sce trace db list` to see available Agent Trace databases.";
+
+/// Tables that must exist for an Agent Trace DB to be considered `ready`.
+///
+/// Order is significant: the first missing table is reported as the skip
+/// reason.
+const REQUIRED_TABLES: &[&str] = &[
+    "diff_traces",
+    "post_commit_patch_intersections",
+    "agent_traces",
+    "messages",
+    "parts",
+    "session_models",
+];
+
+/// Schema-readiness verdict for a discovered Agent Trace DB.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum Readiness {
+    Ready,
+    Skipped { missing_table: String },
+}
+
+/// A discovered per-checkout Agent Trace database with its readiness verdict.
+#[derive(Clone, Debug)]
+#[allow(dead_code)]
+pub struct DiscoveredAgentTraceDb {
+    pub alias: String,
+    pub checkout_id: String,
+    pub path: PathBuf,
+    pub mtime: SystemTime,
+    pub readiness: Readiness,
+}
+
+/// User-actionable failures while resolving an Agent Trace DB identifier.
+#[derive(Clone, Debug, Eq, PartialEq)]
+#[allow(dead_code)]
+pub enum ResolveAgentTraceDbError {
+    UnknownIdentifier {
+        identifier: String,
+    },
+    AmbiguousIdentifier {
+        identifier: String,
+    },
+    SkippedDatabase {
+        identifier: String,
+        alias: String,
+        checkout_id: String,
+        missing_table: String,
+    },
+}
+
+impl ResolveAgentTraceDbError {
+    pub fn user_message(&self) -> String {
+        match self {
+            Self::UnknownIdentifier { identifier } => format!(
+                "sce trace db shell: no agent-trace database matches '{identifier}'. {LIST_GUIDANCE}"
+            ),
+            Self::AmbiguousIdentifier { identifier } => format!(
+                "sce trace db shell: identifier '{identifier}' matches more than one agent-trace database. {LIST_GUIDANCE}"
+            ),
+            Self::SkippedDatabase {
+                identifier,
+                alias,
+                checkout_id,
+                missing_table,
+            } => format!(
+                "sce trace db shell: database '{identifier}' ({alias}, checkout {checkout_id}) is not schema-ready: missing table '{missing_table}'. Run `sce setup` or inspect `sce trace db list` before opening a shell."
+            ),
+        }
+    }
+}
+
+impl std::fmt::Display for ResolveAgentTraceDbError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.user_message())
+    }
+}
+
+impl std::error::Error for ResolveAgentTraceDbError {}
+
+/// Resolve an alias or checkout ID to one ready discovered Agent Trace DB.
+#[allow(dead_code)]
+pub fn resolve_agent_trace_db_identifier(
+    databases: &[DiscoveredAgentTraceDb],
+    identifier: &str,
+) -> Result<DiscoveredAgentTraceDb, ResolveAgentTraceDbError> {
+    let matches: Vec<&DiscoveredAgentTraceDb> = databases
+        .iter()
+        .filter(|db| db.alias == identifier || db.checkout_id == identifier)
+        .collect();
+
+    let db = match matches.as_slice() {
+        [] => {
+            return Err(ResolveAgentTraceDbError::UnknownIdentifier {
+                identifier: identifier.to_string(),
+            });
+        }
+        [db] => *db,
+        _ => {
+            return Err(ResolveAgentTraceDbError::AmbiguousIdentifier {
+                identifier: identifier.to_string(),
+            });
+        }
+    };
+
+    match &db.readiness {
+        Readiness::Ready => Ok(db.clone()),
+        Readiness::Skipped { missing_table } => Err(ResolveAgentTraceDbError::SkippedDatabase {
+            identifier: identifier.to_string(),
+            alias: db.alias.clone(),
+            checkout_id: db.checkout_id.clone(),
+            missing_table: missing_table.clone(),
+        }),
+    }
+}
+
+/// Discover Agent Trace DBs under the resolved state-data root.
+#[allow(dead_code)]
+pub fn discover_agent_trace_dbs() -> Result<Vec<DiscoveredAgentTraceDb>> {
+    let state_root = resolve_state_data_root().context("failed to resolve state data root")?;
+    let sce_dir = state_root.join("sce");
+    discover_agent_trace_dbs_in(&sce_dir)
+}
+
+/// Discover Agent Trace DBs in an explicit `sce` directory.
+///
+/// Returns an empty Vec when the directory does not exist. Otherwise scans for
+/// `agent-trace-{checkout_id}.db` files, sorts by mtime descending (ties broken
+/// by `checkout_id` ascending), assigns positional aliases, and probes each
+/// file for the required schema.
+pub fn discover_agent_trace_dbs_in(sce_dir: &Path) -> Result<Vec<DiscoveredAgentTraceDb>> {
+    if !sce_dir.is_dir() {
+        return Ok(Vec::new());
+    }
+
+    let mut entries: Vec<(String, PathBuf, SystemTime)> = Vec::new();
+
+    for entry in fs::read_dir(sce_dir)
+        .with_context(|| format!("failed to read sce directory '{}'", sce_dir.display()))?
+    {
+        let entry = entry.with_context(|| {
+            format!("failed to read directory entry in '{}'", sce_dir.display())
+        })?;
+
+        let file_name = entry.file_name();
+        let file_name_str = file_name.to_string_lossy();
+
+        let Some(stripped) = file_name_str.strip_prefix("agent-trace-") else {
+            continue;
+        };
+        let Some(checkout_id) = stripped.strip_suffix(".db") else {
+            continue;
+        };
+        if checkout_id.is_empty() {
+            continue;
+        }
+
+        let metadata = entry
+            .metadata()
+            .with_context(|| format!("failed to read metadata for '{}'", entry.path().display()))?;
+        if !metadata.is_file() {
+            continue;
+        }
+        let mtime = metadata
+            .modified()
+            .with_context(|| format!("failed to read mtime for '{}'", entry.path().display()))?;
+
+        entries.push((checkout_id.to_string(), entry.path(), mtime));
+    }
+
+    entries.sort_by(|left, right| right.2.cmp(&left.2).then_with(|| left.0.cmp(&right.0)));
+
+    let mut discovered = Vec::with_capacity(entries.len());
+    for (index, (checkout_id, path, mtime)) in entries.into_iter().enumerate() {
+        let readiness = probe_readiness(&path)?;
+        discovered.push(DiscoveredAgentTraceDb {
+            alias: format!("agent_trace_{index}"),
+            checkout_id,
+            path,
+            mtime,
+            readiness,
+        });
+    }
+
+    Ok(discovered)
+}
+
+/// Probe an Agent Trace DB file for required schema readiness.
+///
+/// Opens the database without running migrations and queries `sqlite_master`
+/// for each required table in declared order. Returns `Skipped` with the first
+/// missing table reported; otherwise `Ready`.
+pub(super) fn probe_readiness(path: &Path) -> Result<Readiness> {
+    let db = AgentTraceDb::open_for_hooks_without_migrations_at(path)
+        .with_context(|| format!("failed to open agent trace DB '{}'", path.display()))?;
+
+    for table in REQUIRED_TABLES {
+        let rows = db
+            .query_map(
+                "SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?1 LIMIT 1",
+                (*table,),
+                |row| row.get::<String>(0).map_err(Into::into),
+            )
+            .with_context(|| format!("failed to probe table '{table}' in '{}'", path.display()))?;
+
+        if rows.is_empty() {
+            return Ok(Readiness::Skipped {
+                missing_table: (*table).to_string(),
+            });
+        }
+    }
+
+    Ok(Readiness::Ready)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::fs::OpenOptions;
+    use std::time::{Duration, UNIX_EPOCH};
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after Unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "sce-trace-discovery-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn create_full_schema_db(path: &Path) {
+        let db = AgentTraceDb::open_at(path).expect("agent trace DB should open with migrations");
+        drop(db);
+    }
+
+    fn touch_mtime(path: &Path, mtime: SystemTime) {
+        let file = OpenOptions::new()
+            .write(true)
+            .open(path)
+            .expect("open db file for mtime update");
+        file.set_modified(mtime).expect("set mtime");
+    }
+
+    #[test]
+    fn full_schema_db_reports_ready() {
+        let dir = unique_temp_dir("ready");
+        let db_path = dir.join("agent-trace-aaaa.db");
+        create_full_schema_db(&db_path);
+
+        let discovered = discover_agent_trace_dbs_in(&dir).expect("discovery should succeed");
+
+        assert_eq!(discovered.len(), 1);
+        assert_eq!(discovered[0].checkout_id, "aaaa");
+        assert_eq!(discovered[0].alias, "agent_trace_0");
+        assert_eq!(discovered[0].readiness, Readiness::Ready);
+        assert_eq!(discovered[0].path, db_path);
+    }
+
+    #[test]
+    fn missing_required_table_reports_skipped_with_first_missing() {
+        let dir = unique_temp_dir("skipped");
+        let db_path = dir.join("agent-trace-bbbb.db");
+
+        let db = AgentTraceDb::open_for_hooks_without_migrations_at(&db_path)
+            .expect("agent trace DB should open without migrations");
+        db.execute(
+            "CREATE TABLE IF NOT EXISTS diff_traces (id INTEGER PRIMARY KEY)",
+            (),
+        )
+        .expect("create diff_traces");
+        db.execute(
+            "CREATE TABLE post_commit_patch_intersections (id INTEGER PRIMARY KEY)",
+            (),
+        )
+        .expect("create post_commit_patch_intersections");
+        // Intentionally skip `agent_traces` to exercise the first-missing-table report.
+        db.execute("CREATE TABLE messages (id INTEGER PRIMARY KEY)", ())
+            .expect("create messages");
+        db.execute("CREATE TABLE parts (id INTEGER PRIMARY KEY)", ())
+            .expect("create parts");
+        db.execute("CREATE TABLE session_models (id INTEGER PRIMARY KEY)", ())
+            .expect("create session_models");
+        drop(db);
+
+        let discovered = discover_agent_trace_dbs_in(&dir).expect("discovery should succeed");
+
+        assert_eq!(discovered.len(), 1);
+        assert_eq!(
+            discovered[0].readiness,
+            Readiness::Skipped {
+                missing_table: String::from("agent_traces"),
+            }
+        );
+    }
+
+    #[test]
+    fn aliases_assigned_in_mtime_desc_order_with_checkout_id_tiebreak() {
+        let dir = unique_temp_dir("ordering");
+
+        let old_path = dir.join("agent-trace-old.db");
+        let mid_path = dir.join("agent-trace-mid.db");
+        let new_path = dir.join("agent-trace-new.db");
+        let tie_a_path = dir.join("agent-trace-tie-a.db");
+        let tie_b_path = dir.join("agent-trace-tie-b.db");
+
+        create_full_schema_db(&old_path);
+        create_full_schema_db(&mid_path);
+        create_full_schema_db(&new_path);
+        create_full_schema_db(&tie_a_path);
+        create_full_schema_db(&tie_b_path);
+
+        let base = SystemTime::now();
+        touch_mtime(&old_path, base - Duration::from_secs(7));
+        touch_mtime(&mid_path, base - Duration::from_secs(3));
+        touch_mtime(&new_path, base);
+        let tie_time = base - Duration::from_secs(5);
+        touch_mtime(&tie_a_path, tie_time);
+        touch_mtime(&tie_b_path, tie_time);
+
+        let discovered = discover_agent_trace_dbs_in(&dir).expect("discovery should succeed");
+
+        assert_eq!(discovered.len(), 5);
+        assert_eq!(discovered[0].alias, "agent_trace_0");
+        assert_eq!(discovered[0].checkout_id, "new");
+        assert_eq!(discovered[1].alias, "agent_trace_1");
+        assert_eq!(discovered[1].checkout_id, "mid");
+        assert_eq!(discovered[2].alias, "agent_trace_2");
+        assert_eq!(discovered[2].checkout_id, "tie-a");
+        assert_eq!(discovered[3].alias, "agent_trace_3");
+        assert_eq!(discovered[3].checkout_id, "tie-b");
+        assert_eq!(discovered[4].alias, "agent_trace_4");
+        assert_eq!(discovered[4].checkout_id, "old");
+    }
+}
diff --git a/cli/src/services/trace/mod.rs b/cli/src/services/trace/mod.rs
new file mode 100644
index 00000000..35177c6b
--- /dev/null
+++ b/cli/src/services/trace/mod.rs
@@ -0,0 +1,33 @@
+//! Agent Trace database discovery, readiness probing, and stats services.
+
+pub mod command;
+pub mod discovery;
+pub mod render_list;
+pub mod render_status;
+pub mod render_status_all;
+pub mod shell;
+pub mod stats;
+pub mod status;
+pub mod status_all;
+
+pub const NAME: &str = "trace";
+
+#[allow(unused_imports)]
+pub use discovery::{
+    discover_agent_trace_dbs, resolve_agent_trace_db_identifier, DiscoveredAgentTraceDb, Readiness,
+    ResolveAgentTraceDbError,
+};
+
+use crate::services::output_format::OutputFormat;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum TraceSubcommandRequest {
+    DbList { format: OutputFormat },
+    DbShell { identifier: String },
+    Status { all: bool, format: OutputFormat },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct TraceRequest {
+    pub subcommand: TraceSubcommandRequest,
+}
diff --git a/cli/src/services/trace/render_list.rs b/cli/src/services/trace/render_list.rs
new file mode 100644
index 00000000..5b9e24bf
--- /dev/null
+++ b/cli/src/services/trace/render_list.rs
@@ -0,0 +1,264 @@
+//! Renderers for `sce trace db list` (text and JSON).
+
+use std::time::SystemTime;
+
+use anyhow::{Context, Result};
+use chrono::{DateTime, Utc};
+use serde_json::json;
+
+use crate::services::output_format::OutputFormat;
+use crate::services::style;
+use crate::services::trace::discovery::{DiscoveredAgentTraceDb, Readiness};
+use crate::services::trace::NAME;
+
+const HEADING: &str = "SCE trace db list";
+const EMPTY_MESSAGE: &str = "no agent-trace databases discovered";
+
+const COL_ALIAS: &str = "Alias";
+const COL_STATUS: &str = "Status";
+const COL_UPDATED_AT: &str = "Updated at";
+const COL_PATH: &str = "Path";
+
+pub fn render(databases: &[DiscoveredAgentTraceDb], format: OutputFormat) -> Result<String> {
+    match format {
+        OutputFormat::Text => Ok(render_text(databases)),
+        OutputFormat::Json => render_json(databases),
+    }
+}
+
+fn render_text(databases: &[DiscoveredAgentTraceDb]) -> String {
+    let mut lines = vec![style::heading(HEADING)];
+
+    if databases.is_empty() {
+        lines.push(EMPTY_MESSAGE.to_string());
+        return lines.join("\n");
+    }
+
+    let rows: Vec<(String, String, String, String)> = databases
+        .iter()
+        .map(|db| {
+            (
+                db.alias.clone(),
+                status_label(&db.readiness),
+                mtime_to_human_readable(db.mtime),
+                db.path.display().to_string(),
+            )
+        })
+        .collect();
+
+    let alias_width = column_width(COL_ALIAS, rows.iter().map(|(a, _, _, _)| a.as_str()));
+    let status_width = column_width(COL_STATUS, rows.iter().map(|(_, s, _, _)| s.as_str()));
+    let updated_at_width = column_width(COL_UPDATED_AT, rows.iter().map(|(_, _, u, _)| u.as_str()));
+
+    lines.push(format!(
+        "{COL_ALIAS:<alias_width$}  {COL_STATUS:<status_width$}  {COL_UPDATED_AT:<updated_at_width$}  {COL_PATH}"
+    ));
+
+    for (alias, status, updated_at, path) in &rows {
+        lines.push(format!(
+            "{alias:<alias_width$}  {status:<status_width$}  {updated_at:<updated_at_width$}  {path}"
+        ));
+    }
+
+    lines.join("\n")
+}
+
+fn render_json(databases: &[DiscoveredAgentTraceDb]) -> Result<String> {
+    let entries: Vec<serde_json::Value> = databases
+        .iter()
+        .map(|db| {
+            let (status, skip_reason) = match &db.readiness {
+                Readiness::Ready => ("ready", None),
+                Readiness::Skipped { missing_table } => {
+                    ("skipped", Some(format!("missing table: {missing_table}")))
+                }
+            };
+            let mut entry = json!({
+                "alias": db.alias,
+                "checkout_id": db.checkout_id,
+                "path": db.path.display().to_string(),
+                "status": status,
+                "updated_at": mtime_to_rfc3339(db.mtime),
+            });
+            if let Some(reason) = skip_reason {
+                entry
+                    .as_object_mut()
+                    .expect("json object")
+                    .insert("skip_reason".to_string(), json!(reason));
+            }
+            entry
+        })
+        .collect();
+
+    let payload = json!({
+        "status": "ok",
+        "command": NAME,
+        "subcommand": "db.list",
+        "databases": entries,
+    });
+
+    serde_json::to_string_pretty(&payload)
+        .context("failed to serialize trace db list report to JSON")
+}
+
+fn status_label(readiness: &Readiness) -> String {
+    match readiness {
+        Readiness::Ready => "ready".to_string(),
+        Readiness::Skipped { missing_table } => {
+            format!("skipped: missing table '{missing_table}'")
+        }
+    }
+}
+
+fn mtime_to_rfc3339(mtime: SystemTime) -> String {
+    let dt: DateTime<Utc> = mtime.into();
+    dt.to_rfc3339()
+}
+
+fn mtime_to_human_readable(mtime: SystemTime) -> String {
+    let dt: DateTime<Utc> = mtime.into();
+    dt.format("%Y-%m-%d %H:%M:%S UTC").to_string()
+}
+
+fn column_width<'a, I: Iterator<Item = &'a str>>(header: &str, values: I) -> usize {
+    values.map(str::len).max().unwrap_or(0).max(header.len())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::path::PathBuf;
+    use std::time::{Duration, UNIX_EPOCH};
+
+    use crate::services::agent_trace_db::AgentTraceDb;
+    use crate::services::trace::discovery::discover_agent_trace_dbs_in;
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after Unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "sce-trace-render-list-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn create_full_schema_db(path: &std::path::Path) {
+        let db = AgentTraceDb::open_at(path).expect("agent trace DB should open with migrations");
+        drop(db);
+    }
+
+    fn create_partial_schema_db(path: &std::path::Path) {
+        let db = AgentTraceDb::open_for_hooks_without_migrations_at(path)
+            .expect("agent trace DB should open without migrations");
+        db.execute(
+            "CREATE TABLE IF NOT EXISTS diff_traces (id INTEGER PRIMARY KEY)",
+            (),
+        )
+        .expect("create diff_traces");
+        // Intentionally missing post_commit_patch_intersections.
+        drop(db);
+    }
+
+    fn touch_mtime(path: &std::path::Path, mtime: SystemTime) {
+        let file = std::fs::OpenOptions::new()
+            .write(true)
+            .open(path)
+            .expect("open db file for mtime update");
+        file.set_modified(mtime).expect("set mtime");
+    }
+
+    #[test]
+    fn empty_discovery_renders_empty_message_text() {
+        let dir = unique_temp_dir("empty-text");
+        let rendered = render_text(&[]);
+        assert!(rendered.contains(EMPTY_MESSAGE));
+        // Avoid unused dir warning.
+        let _ = dir;
+    }
+
+    #[test]
+    fn empty_discovery_renders_empty_databases_json() {
+        let payload = render_json(&[]).expect("json render");
+        let value: serde_json::Value = serde_json::from_str(&payload).expect("valid json");
+        assert_eq!(value["status"], "ok");
+        assert_eq!(value["command"], "trace");
+        assert_eq!(value["subcommand"], "db.list");
+        assert_eq!(value["databases"].as_array().unwrap().len(), 0);
+    }
+
+    #[test]
+    fn mixed_fixture_renders_text_table_with_ready_and_skipped_rows() {
+        let dir = unique_temp_dir("text-table");
+        let ready_a = dir.join("agent-trace-aaaa.db");
+        let ready_b = dir.join("agent-trace-bbbb.db");
+        let skipped = dir.join("agent-trace-cccc.db");
+
+        create_full_schema_db(&ready_a);
+        create_full_schema_db(&ready_b);
+        create_partial_schema_db(&skipped);
+
+        let base = SystemTime::now();
+        touch_mtime(&ready_a, base);
+        touch_mtime(&ready_b, base - Duration::from_secs(5));
+        touch_mtime(&skipped, base - Duration::from_secs(10));
+
+        let discovered = discover_agent_trace_dbs_in(&dir).expect("discovery");
+        let rendered = render_text(&discovered);
+
+        assert!(rendered.contains("Alias"));
+        assert!(rendered.contains("Status"));
+        assert!(rendered.contains("Path"));
+        assert!(rendered.contains("Updated at"));
+        assert!(rendered.contains("agent_trace_0"));
+        assert!(rendered.contains("agent_trace_1"));
+        assert!(rendered.contains("agent_trace_2"));
+        assert!(rendered.contains("ready"));
+        assert!(rendered.contains("skipped: missing table 'post_commit_patch_intersections'"));
+        assert!(rendered.contains(&ready_a.display().to_string()));
+        assert!(rendered.contains(&skipped.display().to_string()));
+    }
+
+    #[test]
+    fn mixed_fixture_renders_json_shape() {
+        let dir = unique_temp_dir("json-shape");
+        let ready = dir.join("agent-trace-aaaa.db");
+        let skipped = dir.join("agent-trace-bbbb.db");
+
+        create_full_schema_db(&ready);
+        create_partial_schema_db(&skipped);
+
+        let base = SystemTime::now();
+        touch_mtime(&ready, base);
+        touch_mtime(&skipped, base - Duration::from_secs(5));
+
+        let discovered = discover_agent_trace_dbs_in(&dir).expect("discovery");
+        let payload = render_json(&discovered).expect("json render");
+        let value: serde_json::Value = serde_json::from_str(&payload).expect("valid json");
+
+        assert_eq!(value["status"], "ok");
+        assert_eq!(value["command"], "trace");
+        assert_eq!(value["subcommand"], "db.list");
+        let databases = value["databases"].as_array().expect("databases array");
+        assert_eq!(databases.len(), 2);
+
+        assert_eq!(databases[0]["alias"], "agent_trace_0");
+        assert_eq!(databases[0]["checkout_id"], "aaaa");
+        assert_eq!(databases[0]["status"], "ready");
+        assert!(databases[0].get("skip_reason").is_none());
+        assert_eq!(databases[0]["path"], ready.display().to_string());
+        assert!(databases[0]["updated_at"].is_string());
+
+        assert_eq!(databases[1]["alias"], "agent_trace_1");
+        assert_eq!(databases[1]["checkout_id"], "bbbb");
+        assert_eq!(databases[1]["status"], "skipped");
+        assert_eq!(
+            databases[1]["skip_reason"],
+            "missing table: post_commit_patch_intersections"
+        );
+    }
+}
diff --git a/cli/src/services/trace/render_status.rs b/cli/src/services/trace/render_status.rs
new file mode 100644
index 00000000..b2700c99
--- /dev/null
+++ b/cli/src/services/trace/render_status.rs
@@ -0,0 +1,204 @@
+//! Renderers for `sce trace status` (text and JSON).
+
+use anyhow::{Context, Result};
+use serde_json::json;
+
+use crate::services::output_format::OutputFormat;
+use crate::services::style;
+use crate::services::trace::status::{DbStatus, StatusReport};
+use crate::services::trace::NAME;
+
+const HEADING: &str = "SCE trace status";
+
+pub fn render(report: &StatusReport, format: OutputFormat) -> Result<String> {
+    match format {
+        OutputFormat::Text => Ok(render_text(report)),
+        OutputFormat::Json => render_json(report),
+    }
+}
+
+fn render_text(report: &StatusReport) -> String {
+    let mut lines = vec![style::heading(HEADING)];
+    lines.push(format!("Checkout: {}", report.checkout_id));
+    lines.push(format!("Database: {}", report.database_path.display()));
+
+    match &report.db_status {
+        DbStatus::Ready {
+            stats,
+            last_activity,
+        } => {
+            lines.push(String::from("Status: ready"));
+            lines.push(format!("Diff traces: {}", stats.diff_traces));
+            lines.push(format!("Messages: {}", stats.messages));
+            lines.push(format!("Parts: {}", stats.parts));
+            lines.push(format!("Session models: {}", stats.session_models));
+            lines.push(format!("Agent traces: {}", stats.agent_traces));
+            lines.push(format!(
+                "Post-commit intersections: {}",
+                stats.post_commit_patch_intersections
+            ));
+            lines.push(format!(
+                "Last activity: {}",
+                last_activity.map_or_else(|| String::from("never"), |dt| dt.to_rfc3339())
+            ));
+        }
+        DbStatus::Skipped { missing_table } => {
+            lines.push(format!("Status: skipped: missing table '{missing_table}'"));
+        }
+    }
+
+    lines.join("\n")
+}
+
+fn render_json(report: &StatusReport) -> Result<String> {
+    let mut payload = json!({
+        "status": "ok",
+        "command": NAME,
+        "subcommand": "status",
+        "checkout_id": report.checkout_id,
+        "database_path": report.database_path.display().to_string(),
+    });
+
+    let object = payload.as_object_mut().expect("payload is object");
+    match &report.db_status {
+        DbStatus::Ready {
+            stats,
+            last_activity,
+        } => {
+            object.insert("db_status".to_string(), json!("ready"));
+            object.insert(
+                "stats".to_string(),
+                json!({
+                    "diff_traces": stats.diff_traces,
+                    "messages": stats.messages,
+                    "parts": stats.parts,
+                    "session_models": stats.session_models,
+                    "agent_traces": stats.agent_traces,
+                    "post_commit_patch_intersections": stats.post_commit_patch_intersections,
+                }),
+            );
+            object.insert(
+                "last_activity".to_string(),
+                last_activity.map_or(serde_json::Value::Null, |dt| json!(dt.to_rfc3339())),
+            );
+        }
+        DbStatus::Skipped { missing_table } => {
+            object.insert("db_status".to_string(), json!("skipped"));
+            object.insert(
+                "skip_reason".to_string(),
+                json!(format!("missing table: {missing_table}")),
+            );
+        }
+    }
+
+    serde_json::to_string_pretty(&payload)
+        .context("failed to serialize trace status report to JSON")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::path::PathBuf;
+
+    use chrono::{DateTime, Utc};
+
+    use crate::services::trace::stats::AgentTraceDbStats;
+
+    fn ready_report() -> StatusReport {
+        let last =
+            DateTime::<Utc>::from_timestamp_millis(1_782_650_096_789).expect("timestamp parses");
+        StatusReport {
+            checkout_id: String::from("01900000-0000-7000-8000-000000000abc"),
+            database_path: PathBuf::from("/tmp/agent-trace-abc.db"),
+            db_status: DbStatus::Ready {
+                stats: AgentTraceDbStats {
+                    diff_traces: 7,
+                    messages: 4,
+                    parts: 11,
+                    session_models: 2,
+                    agent_traces: 3,
+                    post_commit_patch_intersections: 1,
+                    last_activity: Some(last),
+                },
+                last_activity: Some(last),
+            },
+        }
+    }
+
+    fn skipped_report() -> StatusReport {
+        StatusReport {
+            checkout_id: String::from("01900000-0000-7000-8000-000000000def"),
+            database_path: PathBuf::from("/tmp/agent-trace-def.db"),
+            db_status: DbStatus::Skipped {
+                missing_table: String::from("agent_traces"),
+            },
+        }
+    }
+
+    #[test]
+    fn ready_text_renders_all_counts_and_last_activity() {
+        let rendered = render_text(&ready_report());
+        assert!(rendered.contains("SCE trace status"));
+        assert!(rendered.contains("Checkout: 01900000-0000-7000-8000-000000000abc"));
+        assert!(rendered.contains("Database: /tmp/agent-trace-abc.db"));
+        assert!(rendered.contains("Status: ready"));
+        assert!(rendered.contains("Diff traces: 7"));
+        assert!(rendered.contains("Messages: 4"));
+        assert!(rendered.contains("Parts: 11"));
+        assert!(rendered.contains("Session models: 2"));
+        assert!(rendered.contains("Agent traces: 3"));
+        assert!(rendered.contains("Post-commit intersections: 1"));
+        assert!(rendered.contains("Last activity: 2026-06-28T"));
+    }
+
+    #[test]
+    fn ready_text_renders_never_when_last_activity_absent() {
+        let mut report = ready_report();
+        if let DbStatus::Ready {
+            ref mut stats,
+            ref mut last_activity,
+        } = report.db_status
+        {
+            stats.last_activity = None;
+            *last_activity = None;
+        }
+        let rendered = render_text(&report);
+        assert!(rendered.contains("Last activity: never"));
+    }
+
+    #[test]
+    fn skipped_text_renders_skip_reason() {
+        let rendered = render_text(&skipped_report());
+        assert!(rendered.contains("Status: skipped: missing table 'agent_traces'"));
+        assert!(!rendered.contains("Diff traces:"));
+    }
+
+    #[test]
+    fn ready_json_shape_matches_contract() {
+        let payload = render_json(&ready_report()).expect("json render");
+        let value: serde_json::Value = serde_json::from_str(&payload).expect("valid json");
+        assert_eq!(value["status"], "ok");
+        assert_eq!(value["command"], "trace");
+        assert_eq!(value["subcommand"], "status");
+        assert_eq!(value["db_status"], "ready");
+        assert!(value.get("skip_reason").is_none());
+        assert_eq!(value["stats"]["diff_traces"], 7);
+        assert_eq!(value["stats"]["messages"], 4);
+        assert_eq!(value["stats"]["parts"], 11);
+        assert_eq!(value["stats"]["session_models"], 2);
+        assert_eq!(value["stats"]["agent_traces"], 3);
+        assert_eq!(value["stats"]["post_commit_patch_intersections"], 1);
+        assert!(value["last_activity"].is_string());
+    }
+
+    #[test]
+    fn skipped_json_shape_matches_contract() {
+        let payload = render_json(&skipped_report()).expect("json render");
+        let value: serde_json::Value = serde_json::from_str(&payload).expect("valid json");
+        assert_eq!(value["db_status"], "skipped");
+        assert_eq!(value["skip_reason"], "missing table: agent_traces");
+        assert!(value.get("stats").is_none());
+        assert!(value.get("last_activity").is_none());
+    }
+}
diff --git a/cli/src/services/trace/render_status_all.rs b/cli/src/services/trace/render_status_all.rs
new file mode 100644
index 00000000..b64e4486
--- /dev/null
+++ b/cli/src/services/trace/render_status_all.rs
@@ -0,0 +1,355 @@
+//! Renderers for `sce trace status --all` (text and JSON).
+
+use anyhow::{Context, Result};
+use serde_json::json;
+
+use crate::services::output_format::OutputFormat;
+use crate::services::style;
+use crate::services::trace::status_all::{DatabaseRow, DatabaseRowStatus, StatusAllReport};
+use crate::services::trace::NAME;
+
+const HEADING: &str = "SCE trace status (all)";
+const TOTALS_HEADING: &str = "Totals";
+const BY_DATABASE_HEADING: &str = "By database";
+
+const COL_ALIAS: &str = "Alias";
+const COL_STATUS: &str = "Status";
+const COL_DIFFS: &str = "Diffs";
+const COL_MESSAGES: &str = "Messages";
+const COL_PARTS: &str = "Parts";
+const COL_MODELS: &str = "Models";
+const COL_TRACES: &str = "Traces";
+const COL_INTERSECTIONS: &str = "Intersections";
+const SKIPPED_PLACEHOLDER: &str = "-";
+
+pub fn render(report: &StatusAllReport, format: OutputFormat) -> Result<String> {
+    match format {
+        OutputFormat::Text => Ok(render_text(report)),
+        OutputFormat::Json => render_json(report),
+    }
+}
+
+fn render_text(report: &StatusAllReport) -> String {
+    let mut lines = vec![style::heading(HEADING)];
+    lines.push(format!(
+        "Databases: {} discovered, {} ready, {} skipped",
+        report.discovery.discovered, report.discovery.ready, report.discovery.skipped
+    ));
+
+    lines.push(String::new());
+    lines.push(style::heading(TOTALS_HEADING));
+    lines.push(format!("Diff traces: {}", report.totals.diff_traces));
+    lines.push(format!("Messages: {}", report.totals.messages));
+    lines.push(format!("Parts: {}", report.totals.parts));
+    lines.push(format!("Session models: {}", report.totals.session_models));
+    lines.push(format!("Agent traces: {}", report.totals.agent_traces));
+    lines.push(format!(
+        "Post-commit intersections: {}",
+        report.totals.post_commit_patch_intersections
+    ));
+    lines.push(format!(
+        "Last activity: {}",
+        report
+            .totals
+            .last_activity
+            .map_or_else(|| String::from("never"), |dt| dt.to_rfc3339())
+    ));
+
+    if !report.databases.is_empty() {
+        lines.push(String::new());
+        lines.push(style::heading(BY_DATABASE_HEADING));
+
+        let headers = [
+            COL_ALIAS,
+            COL_STATUS,
+            COL_DIFFS,
+            COL_MESSAGES,
+            COL_PARTS,
+            COL_MODELS,
+            COL_TRACES,
+            COL_INTERSECTIONS,
+        ];
+        let rows: Vec<[String; 8]> = report.databases.iter().map(format_row).collect();
+
+        let widths: Vec<usize> = (0..headers.len())
+            .map(|col| {
+                rows.iter()
+                    .map(|row| row[col].len())
+                    .max()
+                    .unwrap_or(0)
+                    .max(headers[col].len())
+            })
+            .collect();
+
+        lines.push(join_row(&headers.map(str::to_string), &widths));
+        for row in &rows {
+            lines.push(join_row(row, &widths));
+        }
+    }
+
+    lines.join("\n")
+}
+
+fn join_row(cells: &[String; 8], widths: &[usize]) -> String {
+    cells
+        .iter()
+        .enumerate()
+        .map(|(i, cell)| format!("{cell:<width$}", width = widths[i]))
+        .collect::<Vec<_>>()
+        .join("  ")
+        .trim_end()
+        .to_string()
+}
+
+fn format_row(row: &DatabaseRow) -> [String; 8] {
+    match &row.status {
+        DatabaseRowStatus::Ready { stats } => [
+            row.alias.clone(),
+            "ready".to_string(),
+            stats.diff_traces.to_string(),
+            stats.messages.to_string(),
+            stats.parts.to_string(),
+            stats.session_models.to_string(),
+            stats.agent_traces.to_string(),
+            stats.post_commit_patch_intersections.to_string(),
+        ],
+        DatabaseRowStatus::Skipped { missing_table } => [
+            row.alias.clone(),
+            format!("skipped: missing '{missing_table}'"),
+            SKIPPED_PLACEHOLDER.to_string(),
+            SKIPPED_PLACEHOLDER.to_string(),
+            SKIPPED_PLACEHOLDER.to_string(),
+            SKIPPED_PLACEHOLDER.to_string(),
+            SKIPPED_PLACEHOLDER.to_string(),
+            SKIPPED_PLACEHOLDER.to_string(),
+        ],
+    }
+}
+
+fn render_json(report: &StatusAllReport) -> Result<String> {
+    let databases: Vec<serde_json::Value> = report
+        .databases
+        .iter()
+        .map(|row| match &row.status {
+            DatabaseRowStatus::Ready { stats } => json!({
+                "alias": row.alias,
+                "checkout_id": row.checkout_id,
+                "path": row.path.display().to_string(),
+                "status": "ready",
+                "diff_traces": stats.diff_traces,
+                "messages": stats.messages,
+                "parts": stats.parts,
+                "session_models": stats.session_models,
+                "agent_traces": stats.agent_traces,
+                "post_commit_patch_intersections": stats.post_commit_patch_intersections,
+                "last_activity": stats
+                    .last_activity
+                    .map_or(serde_json::Value::Null, |dt| json!(dt.to_rfc3339())),
+            }),
+            DatabaseRowStatus::Skipped { missing_table } => json!({
+                "alias": row.alias,
+                "checkout_id": row.checkout_id,
+                "path": row.path.display().to_string(),
+                "status": "skipped",
+                "skip_reason": format!("missing table: {missing_table}"),
+            }),
+        })
+        .collect();
+
+    let payload = json!({
+        "status": "ok",
+        "command": NAME,
+        "subcommand": "status.all",
+        "discovery": {
+            "discovered": report.discovery.discovered,
+            "ready": report.discovery.ready,
+            "skipped": report.discovery.skipped,
+        },
+        "totals": {
+            "diff_traces": report.totals.diff_traces,
+            "messages": report.totals.messages,
+            "parts": report.totals.parts,
+            "session_models": report.totals.session_models,
+            "agent_traces": report.totals.agent_traces,
+            "post_commit_patch_intersections": report.totals.post_commit_patch_intersections,
+            "last_activity": report
+                .totals
+                .last_activity
+                .map_or(serde_json::Value::Null, |dt| json!(dt.to_rfc3339())),
+        },
+        "databases": databases,
+    });
+
+    serde_json::to_string_pretty(&payload)
+        .context("failed to serialize trace status.all report to JSON")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::path::PathBuf;
+    use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+    use crate::services::agent_trace_db::{
+        AgentTraceDb, DiffTraceInsert, InsertMessageInsert, MessageRole,
+    };
+    use crate::services::trace::status_all::aggregate_status_all_in;
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after Unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "sce-trace-render-status-all-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn touch_mtime(path: &std::path::Path, mtime: SystemTime) {
+        let file = std::fs::OpenOptions::new()
+            .write(true)
+            .open(path)
+            .expect("open db file for mtime update");
+        file.set_modified(mtime).expect("set mtime");
+    }
+
+    fn seed_ready_db(path: &std::path::Path, diffs: u64, msgs: u64) {
+        let db = AgentTraceDb::open_at(path).expect("migrated DB should open");
+        for i in 0..diffs {
+            db.insert_diff_trace(DiffTraceInsert {
+                time_ms: 1_000 + i64::try_from(i).expect("idx fits"),
+                session_id: "s1",
+                patch: "p",
+                model_id: Some("m1"),
+                tool_name: "claude",
+                tool_version: Some("1"),
+                payload_type: "patch",
+            })
+            .expect("diff");
+        }
+        for i in 0..msgs {
+            db.insert_message(InsertMessageInsert {
+                session_id: "s1".into(),
+                message_id: format!("m{i}"),
+                role: MessageRole::User,
+                generated_at_unix_ms: 1_000 + i64::try_from(i).expect("idx fits"),
+            })
+            .expect("msg");
+        }
+    }
+
+    fn seed_partial_db(path: &std::path::Path) {
+        let db = AgentTraceDb::open_for_hooks_without_migrations_at(path)
+            .expect("open without migrations");
+        db.execute(
+            "CREATE TABLE IF NOT EXISTS diff_traces (id INTEGER PRIMARY KEY)",
+            (),
+        )
+        .expect("create diff_traces");
+        drop(db);
+    }
+
+    #[test]
+    fn empty_renders_text_with_zeroed_summary_and_totals() {
+        let dir = unique_temp_dir("empty-text");
+        let report = aggregate_status_all_in(&dir).expect("aggregate");
+        let rendered = render_text(&report);
+        assert!(rendered.contains("Databases: 0 discovered, 0 ready, 0 skipped"));
+        assert!(rendered.contains("Diff traces: 0"));
+        assert!(rendered.contains("Last activity: never"));
+        assert!(!rendered.contains(BY_DATABASE_HEADING));
+    }
+
+    #[test]
+    fn empty_renders_json_with_zeroed_shape() {
+        let dir = unique_temp_dir("empty-json");
+        let report = aggregate_status_all_in(&dir).expect("aggregate");
+        let payload = render_json(&report).expect("json render");
+        let value: serde_json::Value = serde_json::from_str(&payload).expect("valid json");
+        assert_eq!(value["status"], "ok");
+        assert_eq!(value["command"], "trace");
+        assert_eq!(value["subcommand"], "status.all");
+        assert_eq!(value["discovery"]["discovered"], 0);
+        assert_eq!(value["discovery"]["ready"], 0);
+        assert_eq!(value["discovery"]["skipped"], 0);
+        assert_eq!(value["totals"]["diff_traces"], 0);
+        assert!(value["totals"]["last_activity"].is_null());
+        assert_eq!(value["databases"].as_array().unwrap().len(), 0);
+    }
+
+    #[test]
+    fn mixed_fixture_renders_text_blocks_with_per_database_rows() {
+        let dir = unique_temp_dir("mixed-text");
+        let ready_newest = dir.join("agent-trace-aaaa.db");
+        let ready_older = dir.join("agent-trace-bbbb.db");
+        let skipped = dir.join("agent-trace-cccc.db");
+
+        seed_ready_db(&ready_newest, 3, 2);
+        seed_ready_db(&ready_older, 1, 1);
+        seed_partial_db(&skipped);
+
+        let base = SystemTime::now();
+        touch_mtime(&ready_newest, base);
+        touch_mtime(&ready_older, base - Duration::from_secs(5));
+        touch_mtime(&skipped, base - Duration::from_secs(10));
+
+        let report = aggregate_status_all_in(&dir).expect("aggregate");
+        let rendered = render_text(&report);
+
+        assert!(rendered.contains("Databases: 3 discovered, 2 ready, 1 skipped"));
+        assert!(rendered.contains("Diff traces: 4"));
+        assert!(rendered.contains("Messages: 3"));
+        assert!(rendered.contains(BY_DATABASE_HEADING));
+        assert!(rendered.contains("agent_trace_0"));
+        assert!(rendered.contains("agent_trace_1"));
+        assert!(rendered.contains("agent_trace_2"));
+        assert!(rendered.contains("ready"));
+        assert!(rendered.contains("skipped: missing 'post_commit_patch_intersections'"));
+    }
+
+    #[test]
+    fn mixed_fixture_renders_json_aggregate_and_breakdown() {
+        let dir = unique_temp_dir("mixed-json");
+        let ready_newest = dir.join("agent-trace-aaaa.db");
+        let ready_older = dir.join("agent-trace-bbbb.db");
+        let skipped = dir.join("agent-trace-cccc.db");
+
+        seed_ready_db(&ready_newest, 2, 1);
+        seed_ready_db(&ready_older, 1, 0);
+        seed_partial_db(&skipped);
+
+        let base = SystemTime::now();
+        touch_mtime(&ready_newest, base);
+        touch_mtime(&ready_older, base - Duration::from_secs(5));
+        touch_mtime(&skipped, base - Duration::from_secs(10));
+
+        let report = aggregate_status_all_in(&dir).expect("aggregate");
+        let payload = render_json(&report).expect("json render");
+        let value: serde_json::Value = serde_json::from_str(&payload).expect("valid json");
+
+        assert_eq!(value["discovery"]["discovered"], 3);
+        assert_eq!(value["discovery"]["ready"], 2);
+        assert_eq!(value["discovery"]["skipped"], 1);
+        assert_eq!(value["totals"]["diff_traces"], 3);
+        assert_eq!(value["totals"]["messages"], 1);
+
+        let databases = value["databases"].as_array().expect("databases array");
+        assert_eq!(databases.len(), 3);
+        assert_eq!(databases[0]["alias"], "agent_trace_0");
+        assert_eq!(databases[0]["status"], "ready");
+        assert_eq!(databases[0]["diff_traces"], 2);
+        assert_eq!(databases[1]["alias"], "agent_trace_1");
+        assert_eq!(databases[1]["status"], "ready");
+        assert_eq!(databases[1]["diff_traces"], 1);
+        assert_eq!(databases[2]["alias"], "agent_trace_2");
+        assert_eq!(databases[2]["status"], "skipped");
+        assert_eq!(
+            databases[2]["skip_reason"],
+            "missing table: post_commit_patch_intersections"
+        );
+    }
+}
diff --git a/cli/src/services/trace/shell.rs b/cli/src/services/trace/shell.rs
new file mode 100644
index 00000000..5aac9c7c
--- /dev/null
+++ b/cli/src/services/trace/shell.rs
@@ -0,0 +1,328 @@
+//! Embedded Agent Trace DB SQL shell core.
+
+#![allow(dead_code)]
+
+use std::io::{BufRead, Write};
+use std::path::PathBuf;
+
+use anyhow::{Context, Result};
+use turso::Value as TursoValue;
+
+use crate::services::agent_trace_db::AgentTraceDb;
+use crate::services::db::QueryRows;
+
+const HELP_TEXT: &str = "Commands:\n  .help    Show this help\n  .tables  List tables\n  .exit    Exit the shell\n  .quit    Exit the shell\nSQL statements execute against the resolved Agent Trace DB.\n";
+const TABLES_SQL: &str = "SELECT name FROM sqlite_schema WHERE type = 'table' ORDER BY name";
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ShellTarget {
+    pub alias: String,
+    pub checkout_id: String,
+    pub path: PathBuf,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum ShellExit {
+    EndOfInput,
+    DotCommand,
+}
+
+pub fn run_agent_trace_db_shell(
+    target: &ShellTarget,
+    input: impl BufRead,
+    mut output: impl Write,
+) -> Result<ShellExit> {
+    let db = AgentTraceDb::open_for_hooks_without_migrations_at(&target.path)
+        .with_context(|| format!("failed to open Agent Trace DB '{}'", target.path.display()))?;
+    db.ensure_schema_ready_for_hooks().with_context(|| {
+        format!(
+            "Agent Trace DB '{}' is not schema-ready",
+            target.path.display()
+        )
+    })?;
+
+    run_agent_trace_db_shell_with_db(&db, target, input, &mut output)
+}
+
+pub fn run_agent_trace_db_shell_with_db(
+    db: &AgentTraceDb,
+    target: &ShellTarget,
+    input: impl BufRead,
+    mut output: impl Write,
+) -> Result<ShellExit> {
+    writeln!(output, "Agent Trace DB shell")?;
+    writeln!(output, "alias: {}", target.alias)?;
+    writeln!(output, "checkout_id: {}", target.checkout_id)?;
+    writeln!(output, "path: {}", target.path.display())?;
+    writeln!(output, "Type .help for commands; .exit or .quit to exit.")?;
+
+    for line in input.lines() {
+        let line = line.context("failed to read Agent Trace DB shell input")?;
+        let trimmed = line.trim();
+
+        if trimmed.is_empty() {
+            continue;
+        }
+
+        if trimmed.starts_with('.') {
+            match trimmed {
+                ".help" => {
+                    write!(output, "{HELP_TEXT}")?;
+                    continue;
+                }
+                ".tables" => {
+                    render_tables(db, &mut output)?;
+                    continue;
+                }
+                ".exit" | ".quit" => return Ok(ShellExit::DotCommand),
+                _ => {
+                    writeln!(
+                        output,
+                        "Unknown command: {trimmed}. Run .help for supported commands."
+                    )?;
+                    continue;
+                }
+            }
+        }
+
+        for statement in split_sql_line(trimmed) {
+            if statement.is_empty() {
+                continue;
+            }
+            render_sql_result(db, statement, &mut output)?;
+        }
+    }
+
+    Ok(ShellExit::EndOfInput)
+}
+
+fn split_sql_line(line: &str) -> impl Iterator<Item = &str> {
+    line.split(';').map(str::trim)
+}
+
+fn render_sql_result(db: &AgentTraceDb, sql: &str, output: &mut impl Write) -> Result<()> {
+    match execute_sql(db, sql) {
+        Ok(ShellSqlResult::Query(rows)) => render_query_rows(&rows, output),
+        Ok(ShellSqlResult::Statement { rows_affected }) => {
+            writeln!(output, "OK ({rows_affected} rows affected)").map_err(Into::into)
+        }
+        Err(error) => writeln!(output, "SQL error: {error}").map_err(Into::into),
+    }
+}
+
+fn render_tables(db: &AgentTraceDb, output: &mut impl Write) -> Result<()> {
+    match db.query_values(TABLES_SQL, ()) {
+        Ok(rows) => {
+            for row in rows.rows {
+                if let Some(TursoValue::Text(name)) = row.first() {
+                    writeln!(output, "{name}")?;
+                }
+            }
+            Ok(())
+        }
+        Err(error) => {
+            writeln!(output, "SQL error: failed to list tables: {error}").map_err(Into::into)
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum ShellSqlResult {
+    Query(QueryRows),
+    Statement { rows_affected: u64 },
+}
+
+fn execute_sql(db: &AgentTraceDb, sql: &str) -> Result<ShellSqlResult> {
+    if is_query_sql(sql) {
+        db.query_values(sql, ())
+            .map(ShellSqlResult::Query)
+            .with_context(|| format!("failed to query SQL: {sql}"))
+    } else {
+        db.execute(sql, ())
+            .map(|rows_affected| ShellSqlResult::Statement { rows_affected })
+            .with_context(|| format!("failed to execute SQL: {sql}"))
+    }
+}
+
+fn is_query_sql(sql: &str) -> bool {
+    let first_token = sql
+        .trim_start()
+        .split(|character: char| character.is_whitespace() || character == '(')
+        .next()
+        .unwrap_or_default();
+    matches!(
+        first_token.to_ascii_uppercase().as_str(),
+        "SELECT" | "WITH" | "PRAGMA" | "EXPLAIN"
+    )
+}
+
+fn render_query_rows(rows: &QueryRows, output: &mut impl Write) -> Result<()> {
+    if rows.columns.is_empty() {
+        writeln!(output, "OK (0 rows affected)")?;
+        return Ok(());
+    }
+
+    writeln!(output, "{}", rows.columns.join(" | "))?;
+    writeln!(
+        output,
+        "{}",
+        rows.columns
+            .iter()
+            .map(|_| "---")
+            .collect::<Vec<_>>()
+            .join(" | ")
+    )?;
+
+    for row in &rows.rows {
+        let rendered = row.iter().map(render_value).collect::<Vec<_>>().join(" | ");
+        writeln!(output, "{rendered}")?;
+    }
+
+    writeln!(output, "({} rows)", rows.rows.len())?;
+    Ok(())
+}
+
+fn render_value(value: &TursoValue) -> String {
+    match value {
+        TursoValue::Null => String::from("NULL"),
+        TursoValue::Integer(value) => value.to_string(),
+        TursoValue::Real(value) => value.to_string(),
+        TursoValue::Text(value) => value.clone(),
+        TursoValue::Blob(value) => format!("x'{}'", encode_lower_hex(value)),
+    }
+}
+
+fn encode_lower_hex(bytes: &[u8]) -> String {
+    const HEX: &[u8; 16] = b"0123456789abcdef";
+    let mut output = String::with_capacity(bytes.len() * 2);
+    for byte in bytes {
+        output.push(HEX[(byte >> 4) as usize] as char);
+        output.push(HEX[(byte & 0x0f) as usize] as char);
+    }
+    output
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::path::Path;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn unique_temp_db(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after Unix epoch")
+            .as_nanos();
+        std::env::temp_dir().join(format!(
+            "sce-trace-shell-{label}-{}-{nonce}.db",
+            std::process::id()
+        ))
+    }
+
+    fn shell_target(path: &Path) -> ShellTarget {
+        ShellTarget {
+            alias: String::from("agent_trace_0"),
+            checkout_id: String::from("018f2d7d-0000-7000-8000-000000000000"),
+            path: path.to_path_buf(),
+        }
+    }
+
+    fn run_shell(input: &str) -> String {
+        let path = unique_temp_db("core");
+        let db = AgentTraceDb::open_at(&path).expect("test DB should open");
+        let mut output = Vec::new();
+        run_agent_trace_db_shell_with_db(&db, &shell_target(&path), input.as_bytes(), &mut output)
+            .expect("shell should run");
+        String::from_utf8(output).expect("shell output should be UTF-8")
+    }
+
+    fn output_after_startup(output: &str) -> &str {
+        output
+            .split_once("Type .help for commands; .exit or .quit to exit.\n")
+            .expect("shell startup prompt should be present")
+            .1
+    }
+
+    #[test]
+    fn shell_runs_query_and_exit_from_piped_input() {
+        let output = run_shell("SELECT COUNT(*) AS diff_trace_count FROM diff_traces;\n.exit\n");
+
+        assert!(output.contains("Agent Trace DB shell\n"));
+        assert!(output.contains("alias: agent_trace_0\n"));
+        assert!(output.contains("diff_trace_count\n---\n0\n(1 rows)\n"));
+    }
+
+    #[test]
+    fn shell_renders_help_and_quit() {
+        let output = run_shell(".help\n.quit\n");
+
+        assert!(output.contains("Commands:\n  .help    Show this help\n  .tables  List tables\n  .exit    Exit the shell\n  .quit    Exit the shell\n"));
+    }
+
+    #[test]
+    fn shell_tables_lists_table_names_in_deterministic_order() {
+        let output = run_shell("CREATE TABLE z_shell_smoke (id INTEGER);\n.tables\n.exit\n");
+        let table_lines = output_after_startup(&output)
+            .lines()
+            .skip_while(|line| !line.starts_with("OK ("))
+            .skip(1)
+            .collect::<Vec<_>>();
+
+        assert!(table_lines.contains(&"__sce_migrations"));
+        assert!(table_lines.contains(&"diff_traces"));
+        assert!(table_lines.contains(&"z_shell_smoke"));
+
+        let migrations_index = table_lines
+            .iter()
+            .position(|line| *line == "__sce_migrations")
+            .expect("migration table should be listed");
+        let diff_traces_index = table_lines
+            .iter()
+            .position(|line| *line == "diff_traces")
+            .expect("diff traces table should be listed");
+        let smoke_index = table_lines
+            .iter()
+            .position(|line| *line == "z_shell_smoke")
+            .expect("test table should be listed");
+
+        assert!(migrations_index < diff_traces_index);
+        assert!(diff_traces_index < smoke_index);
+        assert!(!table_lines.iter().any(|line| line.contains(" | ")));
+        assert!(!table_lines.iter().any(|line| line.starts_with('(')));
+    }
+
+    #[test]
+    fn shell_renders_malformed_sql_diagnostic_and_continues() {
+        let output = run_shell("SELECT FROM;\nSELECT 1 AS ok;\n.exit\n");
+
+        assert!(output.contains("SQL error: failed to query SQL: SELECT FROM"));
+        assert!(output.contains("ok\n---\n1\n(1 rows)\n"));
+    }
+
+    #[test]
+    fn shell_renders_non_query_statement_success() {
+        let output = run_shell("CREATE TABLE shell_smoke (id INTEGER);\nINSERT INTO shell_smoke (id) VALUES (7);\nSELECT id FROM shell_smoke;\n.exit\n");
+
+        assert!(output.contains("OK (0 rows affected)\n"));
+        assert!(output.contains("OK (1 rows affected)\n"));
+        assert!(output.contains("id\n---\n7\n(1 rows)\n"));
+    }
+
+    #[test]
+    fn shell_opens_path_and_checks_schema_readiness() {
+        let path = unique_temp_db("open-path");
+        let db = AgentTraceDb::open_at(&path).expect("test DB should open");
+        drop(db);
+
+        let mut output = Vec::new();
+        let exit =
+            run_agent_trace_db_shell(&shell_target(&path), ".exit\n".as_bytes(), &mut output)
+                .expect("shell should open ready DB");
+
+        assert_eq!(exit, ShellExit::DotCommand);
+        assert!(String::from_utf8(output)
+            .expect("shell output should be UTF-8")
+            .contains("path: "));
+    }
+}
diff --git a/cli/src/services/trace/stats.rs b/cli/src/services/trace/stats.rs
new file mode 100644
index 00000000..23f65d77
--- /dev/null
+++ b/cli/src/services/trace/stats.rs
@@ -0,0 +1,296 @@
+//! Per-checkout Agent Trace DB row-count and last-activity stats.
+//!
+//! Issues read-only `COUNT(*)` and `MAX(...)` queries against a single
+//! Agent Trace DB and returns the aggregated counts plus the most recent
+//! activity timestamp derived from `diff_traces.time_ms`,
+//! `messages.updated_at`, and `agent_traces.created_at`.
+
+use std::path::Path;
+
+use anyhow::{Context, Result};
+use chrono::{DateTime, TimeZone, Utc};
+
+use crate::services::agent_trace_db::AgentTraceDb;
+
+/// Aggregated per-checkout Agent Trace DB row counts and last activity.
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+#[allow(dead_code)]
+pub struct AgentTraceDbStats {
+    pub diff_traces: u64,
+    pub messages: u64,
+    pub parts: u64,
+    pub session_models: u64,
+    pub agent_traces: u64,
+    pub post_commit_patch_intersections: u64,
+    pub last_activity: Option<DateTime<Utc>>,
+}
+
+/// Collect row counts and last activity for a single Agent Trace DB.
+///
+/// Opens the DB read-only (without running migrations) and issues one
+/// `SELECT COUNT(*)` per required table plus three `MAX(...)` queries to
+/// compute the last activity timestamp. The caller is expected to have
+/// already verified schema readiness via `discover_agent_trace_dbs`.
+#[allow(dead_code)]
+pub fn collect_agent_trace_db_stats(path: &Path) -> Result<AgentTraceDbStats> {
+    let db = AgentTraceDb::open_for_hooks_without_migrations_at(path)
+        .with_context(|| format!("failed to open agent trace DB '{}'", path.display()))?;
+
+    let diff_traces = count_rows(&db, "diff_traces", path)?;
+    let messages = count_rows(&db, "messages", path)?;
+    let parts = count_rows(&db, "parts", path)?;
+    let session_models = count_rows(&db, "session_models", path)?;
+    let agent_traces = count_rows(&db, "agent_traces", path)?;
+    let post_commit_patch_intersections = count_rows(&db, "post_commit_patch_intersections", path)?;
+
+    let diff_max_ms = query_optional_i64(&db, "SELECT MAX(time_ms) FROM diff_traces", path)
+        .context("failed to query MAX(diff_traces.time_ms)")?;
+    let messages_max_iso = query_optional_string(&db, "SELECT MAX(updated_at) FROM messages", path)
+        .context("failed to query MAX(messages.updated_at)")?;
+    let agent_traces_max_iso =
+        query_optional_string(&db, "SELECT MAX(created_at) FROM agent_traces", path)
+            .context("failed to query MAX(agent_traces.created_at)")?;
+
+    let mut last_activity: Option<DateTime<Utc>> = None;
+    if let Some(ms) = diff_max_ms {
+        if let Some(dt) = DateTime::<Utc>::from_timestamp_millis(ms) {
+            last_activity = Some(last_activity.map_or(dt, |prev| prev.max(dt)));
+        }
+    }
+    for iso in [messages_max_iso, agent_traces_max_iso]
+        .into_iter()
+        .flatten()
+    {
+        if let Some(dt) = parse_iso_millis(&iso) {
+            last_activity = Some(last_activity.map_or(dt, |prev| prev.max(dt)));
+        }
+    }
+
+    Ok(AgentTraceDbStats {
+        diff_traces,
+        messages,
+        parts,
+        session_models,
+        agent_traces,
+        post_commit_patch_intersections,
+        last_activity,
+    })
+}
+
+fn count_rows(db: &AgentTraceDb, table: &str, path: &Path) -> Result<u64> {
+    let sql = format!("SELECT COUNT(*) FROM {table}");
+    let rows = db
+        .query_map(sql.as_str(), (), |row| {
+            row.get::<i64>(0).map_err(Into::into)
+        })
+        .with_context(|| {
+            format!(
+                "failed to count rows in '{table}' for agent trace DB '{}'",
+                path.display()
+            )
+        })?;
+    let count = rows.into_iter().next().unwrap_or(0);
+    Ok(u64::try_from(count).unwrap_or(0))
+}
+
+fn query_optional_i64(db: &AgentTraceDb, sql: &str, path: &Path) -> Result<Option<i64>> {
+    let rows = db
+        .query_map(sql, (), |row| row.get::<Option<i64>>(0).map_err(Into::into))
+        .with_context(|| {
+            format!(
+                "failed to query '{sql}' on agent trace DB '{}'",
+                path.display()
+            )
+        })?;
+    Ok(rows.into_iter().next().flatten())
+}
+
+fn query_optional_string(db: &AgentTraceDb, sql: &str, path: &Path) -> Result<Option<String>> {
+    let rows = db
+        .query_map(sql, (), |row| {
+            row.get::<Option<String>>(0).map_err(Into::into)
+        })
+        .with_context(|| {
+            format!(
+                "failed to query '{sql}' on agent trace DB '{}'",
+                path.display()
+            )
+        })?;
+    Ok(rows.into_iter().next().flatten())
+}
+
+/// Parse the `SQLite` `strftime('%Y-%m-%dT%H:%M:%fZ', ...)` format into UTC.
+fn parse_iso_millis(text: &str) -> Option<DateTime<Utc>> {
+    if let Ok(dt) = DateTime::parse_from_rfc3339(text) {
+        return Some(dt.with_timezone(&Utc));
+    }
+    // SQLite emits `YYYY-MM-DDTHH:MM:SS.sssZ`; fall back to a naive parse if
+    // the upstream format ever drops the timezone designator.
+    let naive = chrono::NaiveDateTime::parse_from_str(text, "%Y-%m-%dT%H:%M:%S%.fZ").ok()?;
+    Some(Utc.from_utc_datetime(&naive))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::path::PathBuf;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    use crate::services::agent_trace_db::{
+        AgentTraceDb, AgentTraceInsert, DiffTraceInsert, InsertMessageInsert, InsertPartInsert,
+        MessageRole, PartType, PostCommitPatchIntersectionInsert, SessionModelUpsert,
+    };
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after Unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "sce-trace-stats-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn seed_db(path: &Path) -> i64 {
+        let db = AgentTraceDb::open_at(path).expect("migrated DB should open");
+
+        // 2 diff traces
+        db.insert_diff_trace(DiffTraceInsert {
+            time_ms: 1_000,
+            session_id: "s1",
+            patch: "diff1",
+            model_id: Some("m1"),
+            tool_name: "claude",
+            tool_version: Some("1"),
+            payload_type: "patch",
+        })
+        .expect("diff trace 1");
+        let latest_diff_ms = 2_500;
+        db.insert_diff_trace(DiffTraceInsert {
+            time_ms: latest_diff_ms,
+            session_id: "s1",
+            patch: "diff2",
+            model_id: Some("m1"),
+            tool_name: "claude",
+            tool_version: Some("1"),
+            payload_type: "patch",
+        })
+        .expect("diff trace 2");
+
+        // 1 post_commit_patch_intersection
+        db.insert_post_commit_patch_intersection(PostCommitPatchIntersectionInsert {
+            commit_id: "c1",
+            post_commit_time_ms: 3_000,
+            recent_window_cutoff_ms: 0,
+            recent_window_end_ms: 3_000,
+            loaded_diff_trace_count: 2,
+            skipped_diff_trace_count: 0,
+            intersection_patch: "patch",
+        })
+        .expect("intersection");
+
+        // 1 agent trace
+        db.insert_agent_trace(AgentTraceInsert {
+            commit_id: "c1",
+            commit_time_ms: 3_000,
+            trace_json: "{}",
+            agent_trace_id: "at1",
+            url: "https://example.test/at1",
+            remote_url: "https://example.test/repo",
+        })
+        .expect("agent trace");
+
+        // 2 messages, 3 parts
+        db.insert_message(InsertMessageInsert {
+            session_id: "s1".into(),
+            message_id: "m1".into(),
+            role: MessageRole::User,
+            generated_at_unix_ms: 1_000,
+        })
+        .expect("message 1");
+        db.insert_message(InsertMessageInsert {
+            session_id: "s1".into(),
+            message_id: "m2".into(),
+            role: MessageRole::Assistant,
+            generated_at_unix_ms: 1_100,
+        })
+        .expect("message 2");
+        let parts = ["p1", "p2", "p3"]
+            .iter()
+            .enumerate()
+            .map(|(i, part_id)| InsertPartInsert {
+                part_type: PartType::Text,
+                text: format!("part {part_id}"),
+                session_id: "s1".into(),
+                message_id: if i < 2 { "m1".into() } else { "m2".into() },
+                generated_at_unix_ms: 1_000 + i64::try_from(i).expect("part index fits in i64"),
+            })
+            .collect();
+        db.insert_parts(parts).expect("parts");
+
+        // 1 session_model
+        db.upsert_session_model(SessionModelUpsert {
+            tool_name: "claude",
+            session_id: "s1",
+            model_id: "m1",
+            tool_version: Some("1"),
+            session_start_time_ms: 500,
+        })
+        .expect("session model");
+
+        latest_diff_ms
+    }
+
+    #[test]
+    fn collect_stats_returns_counts_and_last_activity() {
+        let dir = unique_temp_dir("counts");
+        let db_path = dir.join("agent-trace-aaaa.db");
+        let latest_diff_ms = seed_db(&db_path);
+
+        let stats =
+            collect_agent_trace_db_stats(&db_path).expect("stats collection should succeed");
+
+        assert_eq!(stats.diff_traces, 2);
+        assert_eq!(stats.messages, 2);
+        assert_eq!(stats.parts, 3);
+        assert_eq!(stats.session_models, 1);
+        assert_eq!(stats.agent_traces, 1);
+        assert_eq!(stats.post_commit_patch_intersections, 1);
+
+        let last = stats.last_activity.expect("last activity should be set");
+        let diff_dt = DateTime::<Utc>::from_timestamp_millis(latest_diff_ms)
+            .expect("latest diff time should convert");
+        assert!(
+            last >= diff_dt,
+            "last_activity {last} should be >= latest diff trace {diff_dt}"
+        );
+    }
+
+    #[test]
+    fn collect_stats_on_empty_db_returns_zero_counts_and_no_activity() {
+        let dir = unique_temp_dir("empty");
+        let db_path = dir.join("agent-trace-bbbb.db");
+        drop(AgentTraceDb::open_at(&db_path).expect("migrated DB should open"));
+
+        let stats =
+            collect_agent_trace_db_stats(&db_path).expect("stats collection should succeed");
+
+        assert_eq!(stats.diff_traces, 0);
+        assert_eq!(stats.messages, 0);
+        assert_eq!(stats.parts, 0);
+        assert_eq!(stats.session_models, 0);
+        assert_eq!(stats.agent_traces, 0);
+        assert_eq!(stats.post_commit_patch_intersections, 0);
+        assert!(stats.last_activity.is_none());
+    }
+
+    #[test]
+    fn parse_iso_millis_handles_sqlite_strftime_output() {
+        let parsed = parse_iso_millis("2026-06-28T12:34:56.789Z").expect("parse strftime output");
+        assert_eq!(parsed.timestamp_millis(), 1_782_650_096_789);
+    }
+}
diff --git a/cli/src/services/trace/status.rs b/cli/src/services/trace/status.rs
new file mode 100644
index 00000000..84ee479a
--- /dev/null
+++ b/cli/src/services/trace/status.rs
@@ -0,0 +1,298 @@
+//! Per-checkout `sce trace status` resolution.
+//!
+//! Resolves the cwd's checkout via `services::checkout`, locates its
+//! `agent-trace-{id}.db`, probes schema readiness, and (when ready) collects
+//! row counts plus the last-activity timestamp.
+
+use std::path::{Path, PathBuf};
+
+use anyhow::Result;
+use chrono::{DateTime, Utc};
+
+use crate::services::checkout::{read_checkout_id, resolve_git_dir};
+use crate::services::default_paths::resolve_state_data_root;
+use crate::services::trace::discovery::{probe_readiness, Readiness};
+use crate::services::trace::stats::{collect_agent_trace_db_stats, AgentTraceDbStats};
+
+/// Errors that map directly to user-facing `sce trace status` guidance.
+#[derive(Debug)]
+pub enum StatusError {
+    NotInGitRepo { repo_root: PathBuf, detail: String },
+    NoCheckoutId { git_dir: PathBuf },
+    DbMissing { checkout_id: String, path: PathBuf },
+}
+
+impl StatusError {
+    pub fn user_message(&self) -> String {
+        match self {
+            Self::NotInGitRepo { repo_root, detail } => format!(
+                "sce trace status: '{}' is not inside a git repository ({detail}); cd into a git repository and retry",
+                repo_root.display()
+            ),
+            Self::NoCheckoutId { git_dir } => format!(
+                "sce trace status: no checkout id found at '{}'; run `sce setup` to initialize this repository",
+                git_dir.join("sce").join("checkout-id").display()
+            ),
+            Self::DbMissing { checkout_id, path } => format!(
+                "sce trace status: no agent-trace database for checkout {checkout_id} at '{}'; no traces have been recorded yet (the SCE Claude Code hook records traces on commits)",
+                path.display()
+            ),
+        }
+    }
+}
+
+impl std::fmt::Display for StatusError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.user_message())
+    }
+}
+
+impl std::error::Error for StatusError {}
+
+/// Verdict for a resolved checkout's Agent Trace DB.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum DbStatus {
+    Ready {
+        stats: AgentTraceDbStats,
+        last_activity: Option<DateTime<Utc>>,
+    },
+    Skipped {
+        missing_table: String,
+    },
+}
+
+/// Resolved per-checkout status report ready for rendering.
+#[derive(Clone, Debug)]
+pub struct StatusReport {
+    pub checkout_id: String,
+    pub database_path: PathBuf,
+    pub db_status: DbStatus,
+}
+
+/// Resolve `sce trace status` for the current working repository using the
+/// default state-data root.
+pub fn resolve_current_status(repo_root: &Path) -> Result<StatusReport, StatusErrorOrRuntime> {
+    let state_root = resolve_state_data_root().map_err(StatusErrorOrRuntime::Runtime)?;
+    let sce_dir = state_root.join("sce");
+    resolve_current_status_in(repo_root, &sce_dir)
+}
+
+/// Testable variant taking the `sce` directory explicitly.
+pub fn resolve_current_status_in(
+    repo_root: &Path,
+    sce_dir: &Path,
+) -> Result<StatusReport, StatusErrorOrRuntime> {
+    let git_dir = resolve_git_dir(repo_root).map_err(|err| {
+        StatusErrorOrRuntime::Status(StatusError::NotInGitRepo {
+            repo_root: repo_root.to_path_buf(),
+            detail: format!("{err:#}"),
+        })
+    })?;
+
+    let Some(checkout_id) = read_checkout_id(&git_dir).map_err(StatusErrorOrRuntime::Runtime)?
+    else {
+        return Err(StatusErrorOrRuntime::Status(StatusError::NoCheckoutId {
+            git_dir,
+        }));
+    };
+
+    let database_path = sce_dir.join(format!("agent-trace-{checkout_id}.db"));
+    if !database_path.exists() {
+        return Err(StatusErrorOrRuntime::Status(StatusError::DbMissing {
+            checkout_id,
+            path: database_path,
+        }));
+    }
+
+    let readiness = probe_readiness(&database_path).map_err(StatusErrorOrRuntime::Runtime)?;
+    let db_status = match readiness {
+        Readiness::Ready => {
+            let stats = collect_agent_trace_db_stats(&database_path)
+                .map_err(StatusErrorOrRuntime::Runtime)?;
+            let last_activity = stats.last_activity;
+            DbStatus::Ready {
+                stats,
+                last_activity,
+            }
+        }
+        Readiness::Skipped { missing_table } => DbStatus::Skipped { missing_table },
+    };
+
+    Ok(StatusReport {
+        checkout_id,
+        database_path,
+        db_status,
+    })
+}
+
+/// Distinguishes user-actionable status errors from internal runtime failures.
+#[derive(Debug)]
+pub enum StatusErrorOrRuntime {
+    Status(StatusError),
+    Runtime(anyhow::Error),
+}
+
+impl std::fmt::Display for StatusErrorOrRuntime {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Status(err) => write!(f, "{err}"),
+            Self::Runtime(err) => write!(f, "{err:#}"),
+        }
+    }
+}
+
+impl std::error::Error for StatusErrorOrRuntime {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::process::Command;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    use crate::services::agent_trace_db::AgentTraceDb;
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after Unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "sce-trace-status-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn init_git_repo(repo_root: &Path) {
+        let output = Command::new("git")
+            .args(["init", "-q"])
+            .current_dir(repo_root)
+            .output()
+            .expect("git init");
+        assert!(output.status.success(), "git init failed");
+    }
+
+    fn write_checkout_id(repo_root: &Path, id: &str) -> PathBuf {
+        let git_dir = repo_root.join(".git");
+        let sce = git_dir.join("sce");
+        std::fs::create_dir_all(&sce).expect("create .git/sce");
+        let id_path = sce.join("checkout-id");
+        std::fs::write(&id_path, id).expect("write checkout-id");
+        id_path
+    }
+
+    fn create_full_schema_db(path: &Path) {
+        let db = AgentTraceDb::open_at(path).expect("migrated DB should open");
+        drop(db);
+    }
+
+    #[test]
+    fn missing_git_repo_reports_not_in_git_repo() {
+        let repo = unique_temp_dir("not-git");
+        let sce_dir = unique_temp_dir("not-git-sce");
+
+        let err = resolve_current_status_in(&repo, &sce_dir).expect_err("should error");
+        match err {
+            StatusErrorOrRuntime::Status(StatusError::NotInGitRepo { .. }) => {}
+            other => panic!("expected NotInGitRepo, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn missing_checkout_id_reports_no_checkout_id() {
+        let repo = unique_temp_dir("no-id");
+        init_git_repo(&repo);
+        let sce_dir = unique_temp_dir("no-id-sce");
+
+        let err = resolve_current_status_in(&repo, &sce_dir).expect_err("should error");
+        match err {
+            StatusErrorOrRuntime::Status(StatusError::NoCheckoutId { .. }) => {}
+            other => panic!("expected NoCheckoutId, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn missing_db_file_reports_db_missing() {
+        let repo = unique_temp_dir("no-db");
+        init_git_repo(&repo);
+        let id = "01900000-0000-7000-8000-000000000001";
+        write_checkout_id(&repo, id);
+        let sce_dir = unique_temp_dir("no-db-sce");
+        std::fs::create_dir_all(&sce_dir).expect("create sce dir");
+
+        let err = resolve_current_status_in(&repo, &sce_dir).expect_err("should error");
+        match err {
+            StatusErrorOrRuntime::Status(StatusError::DbMissing { checkout_id, .. }) => {
+                assert_eq!(checkout_id, id);
+            }
+            other => panic!("expected DbMissing, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn ready_db_returns_stats_report() {
+        let repo = unique_temp_dir("ready");
+        init_git_repo(&repo);
+        let id = "01900000-0000-7000-8000-000000000002";
+        write_checkout_id(&repo, id);
+        let sce_dir = unique_temp_dir("ready-sce");
+        std::fs::create_dir_all(&sce_dir).expect("create sce dir");
+        let db_path = sce_dir.join(format!("agent-trace-{id}.db"));
+        create_full_schema_db(&db_path);
+
+        let report =
+            resolve_current_status_in(&repo, &sce_dir).expect("ready report should resolve");
+
+        assert_eq!(report.checkout_id, id);
+        assert_eq!(report.database_path, db_path);
+        match report.db_status {
+            DbStatus::Ready {
+                stats,
+                last_activity,
+            } => {
+                assert_eq!(stats.diff_traces, 0);
+                assert_eq!(stats.messages, 0);
+                assert_eq!(stats.parts, 0);
+                assert_eq!(stats.session_models, 0);
+                assert_eq!(stats.agent_traces, 0);
+                assert_eq!(stats.post_commit_patch_intersections, 0);
+                assert!(last_activity.is_none());
+            }
+            DbStatus::Skipped { missing_table } => {
+                panic!("expected Ready, got Skipped (missing_table={missing_table})")
+            }
+        }
+    }
+
+    #[test]
+    fn partial_schema_db_returns_skipped_status() {
+        let repo = unique_temp_dir("skipped");
+        init_git_repo(&repo);
+        let id = "01900000-0000-7000-8000-000000000003";
+        write_checkout_id(&repo, id);
+        let sce_dir = unique_temp_dir("skipped-sce");
+        std::fs::create_dir_all(&sce_dir).expect("create sce dir");
+        let db_path = sce_dir.join(format!("agent-trace-{id}.db"));
+
+        let db = AgentTraceDb::open_for_hooks_without_migrations_at(&db_path)
+            .expect("open without migrations");
+        db.execute(
+            "CREATE TABLE IF NOT EXISTS diff_traces (id INTEGER PRIMARY KEY)",
+            (),
+        )
+        .expect("create diff_traces");
+        drop(db);
+
+        let report =
+            resolve_current_status_in(&repo, &sce_dir).expect("skipped report should resolve");
+
+        match report.db_status {
+            DbStatus::Skipped { missing_table } => {
+                assert_eq!(missing_table, "post_commit_patch_intersections");
+            }
+            DbStatus::Ready { .. } => panic!("expected Skipped, got Ready"),
+        }
+    }
+}
diff --git a/cli/src/services/trace/status_all.rs b/cli/src/services/trace/status_all.rs
new file mode 100644
index 00000000..456390f7
--- /dev/null
+++ b/cli/src/services/trace/status_all.rs
@@ -0,0 +1,254 @@
+//! Aggregation for `sce trace status --all` across every discovered DB.
+//!
+//! Walks the `services::trace::discovery` output, runs
+//! `collect_agent_trace_db_stats` over each `Ready` DB, and aggregates totals
+//! plus a per-database breakdown for downstream renderers. `Skipped` DBs are
+//! counted in the discovery summary but excluded from totals.
+
+use std::path::{Path, PathBuf};
+
+use anyhow::{Context, Result};
+
+use crate::services::default_paths::resolve_state_data_root;
+use crate::services::trace::discovery::{discover_agent_trace_dbs_in, Readiness};
+use crate::services::trace::stats::{collect_agent_trace_db_stats, AgentTraceDbStats};
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DiscoverySummary {
+    pub discovered: usize,
+    pub ready: usize,
+    pub skipped: usize,
+}
+
+/// Aggregated totals across all discovered Agent Trace DBs.
+pub type Totals = AgentTraceDbStats;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum DatabaseRowStatus {
+    Ready { stats: AgentTraceDbStats },
+    Skipped { missing_table: String },
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct DatabaseRow {
+    pub alias: String,
+    pub checkout_id: String,
+    pub path: PathBuf,
+    pub status: DatabaseRowStatus,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct StatusAllReport {
+    pub discovery: DiscoverySummary,
+    pub totals: Totals,
+    pub databases: Vec<DatabaseRow>,
+}
+
+/// Aggregate `sce trace status --all` using the default state-data root.
+pub fn aggregate_current_status_all() -> Result<StatusAllReport> {
+    let state_root = resolve_state_data_root().context("failed to resolve state data root")?;
+    let sce_dir = state_root.join("sce");
+    aggregate_status_all_in(&sce_dir)
+}
+
+/// Aggregate `sce trace status --all` against an explicit `sce` directory.
+pub fn aggregate_status_all_in(sce_dir: &Path) -> Result<StatusAllReport> {
+    let discovered = discover_agent_trace_dbs_in(sce_dir)?;
+
+    let mut discovery = DiscoverySummary {
+        discovered: discovered.len(),
+        ready: 0,
+        skipped: 0,
+    };
+    let mut totals = Totals::default();
+    let mut databases: Vec<DatabaseRow> = Vec::with_capacity(discovered.len());
+
+    for db in discovered {
+        match db.readiness {
+            Readiness::Ready => {
+                discovery.ready += 1;
+                let stats = collect_agent_trace_db_stats(&db.path)?;
+                totals.diff_traces += stats.diff_traces;
+                totals.messages += stats.messages;
+                totals.parts += stats.parts;
+                totals.session_models += stats.session_models;
+                totals.agent_traces += stats.agent_traces;
+                totals.post_commit_patch_intersections += stats.post_commit_patch_intersections;
+                if let Some(dt) = stats.last_activity {
+                    totals.last_activity =
+                        Some(totals.last_activity.map_or(dt, |prev| prev.max(dt)));
+                }
+                databases.push(DatabaseRow {
+                    alias: db.alias,
+                    checkout_id: db.checkout_id,
+                    path: db.path,
+                    status: DatabaseRowStatus::Ready { stats },
+                });
+            }
+            Readiness::Skipped { missing_table } => {
+                discovery.skipped += 1;
+                databases.push(DatabaseRow {
+                    alias: db.alias,
+                    checkout_id: db.checkout_id,
+                    path: db.path,
+                    status: DatabaseRowStatus::Skipped { missing_table },
+                });
+            }
+        }
+    }
+
+    Ok(StatusAllReport {
+        discovery,
+        totals,
+        databases,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::fs::OpenOptions;
+    use std::path::PathBuf;
+    use std::time::{Duration, SystemTime, UNIX_EPOCH};
+
+    use crate::services::agent_trace_db::{
+        AgentTraceDb, DiffTraceInsert, InsertMessageInsert, InsertPartInsert, MessageRole, PartType,
+    };
+
+    fn unique_temp_dir(label: &str) -> PathBuf {
+        let nonce = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("system time should be after Unix epoch")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "sce-trace-status-all-{label}-{}-{nonce}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn touch_mtime(path: &Path, mtime: SystemTime) {
+        let file = OpenOptions::new()
+            .write(true)
+            .open(path)
+            .expect("open db file for mtime update");
+        file.set_modified(mtime).expect("set mtime");
+    }
+
+    fn seed_ready_db(path: &Path, diff_count: u64, message_count: u64, parts_per_message: u64) {
+        let db = AgentTraceDb::open_at(path).expect("migrated DB should open");
+        for i in 0..diff_count {
+            db.insert_diff_trace(DiffTraceInsert {
+                time_ms: 1_000 + i64::try_from(i).expect("diff index fits in i64"),
+                session_id: "s1",
+                patch: "diff",
+                model_id: Some("m1"),
+                tool_name: "claude",
+                tool_version: Some("1"),
+                payload_type: "patch",
+            })
+            .expect("diff trace");
+        }
+        for i in 0..message_count {
+            let mid = format!("m{i}");
+            db.insert_message(InsertMessageInsert {
+                session_id: "s1".into(),
+                message_id: mid.clone(),
+                role: MessageRole::User,
+                generated_at_unix_ms: 1_000 + i64::try_from(i).expect("msg index fits in i64"),
+            })
+            .expect("message");
+            let parts = (0..parts_per_message)
+                .map(|j| InsertPartInsert {
+                    part_type: PartType::Text,
+                    text: format!("p{i}{j}"),
+                    session_id: "s1".into(),
+                    message_id: mid.clone(),
+                    generated_at_unix_ms: 1_000
+                        + i64::try_from(i * parts_per_message + j).expect("part index fits in i64"),
+                })
+                .collect();
+            db.insert_parts(parts).expect("parts");
+        }
+    }
+
+    fn seed_partial_db(path: &Path) {
+        let db = AgentTraceDb::open_for_hooks_without_migrations_at(path)
+            .expect("open without migrations");
+        db.execute(
+            "CREATE TABLE IF NOT EXISTS diff_traces (id INTEGER PRIMARY KEY)",
+            (),
+        )
+        .expect("create diff_traces");
+        // Intentionally missing post_commit_patch_intersections so readiness
+        // probe reports skipped with the first missing table.
+        drop(db);
+    }
+
+    #[test]
+    fn empty_sce_dir_reports_zero_discovery_and_totals() {
+        let dir = unique_temp_dir("empty");
+        let report = aggregate_status_all_in(&dir).expect("empty aggregation should succeed");
+        assert_eq!(report.discovery.discovered, 0);
+        assert_eq!(report.discovery.ready, 0);
+        assert_eq!(report.discovery.skipped, 0);
+        assert_eq!(report.totals, Totals::default());
+        assert!(report.databases.is_empty());
+    }
+
+    #[test]
+    fn mixed_fixture_aggregates_ready_and_lists_skipped() {
+        let dir = unique_temp_dir("mixed");
+
+        let ready_newest = dir.join("agent-trace-aaaa.db");
+        let ready_older = dir.join("agent-trace-bbbb.db");
+        let skipped = dir.join("agent-trace-cccc.db");
+
+        seed_ready_db(&ready_newest, 3, 2, 2); // diffs=3, msgs=2, parts=4
+        seed_ready_db(&ready_older, 1, 1, 1); // diffs=1, msgs=1, parts=1
+        seed_partial_db(&skipped);
+
+        let base = SystemTime::now();
+        touch_mtime(&ready_newest, base);
+        touch_mtime(&ready_older, base - Duration::from_secs(10));
+        touch_mtime(&skipped, base - Duration::from_secs(20));
+
+        let report = aggregate_status_all_in(&dir).expect("aggregation should succeed");
+
+        assert_eq!(report.discovery.discovered, 3);
+        assert_eq!(report.discovery.ready, 2);
+        assert_eq!(report.discovery.skipped, 1);
+
+        assert_eq!(report.totals.diff_traces, 4);
+        assert_eq!(report.totals.messages, 3);
+        assert_eq!(report.totals.parts, 5);
+        assert_eq!(report.totals.session_models, 0);
+        assert_eq!(report.totals.agent_traces, 0);
+        assert_eq!(report.totals.post_commit_patch_intersections, 0);
+
+        assert_eq!(report.databases.len(), 3);
+        // Discovery is mtime-desc, so newest ready first, then older ready, then skipped.
+        assert_eq!(report.databases[0].alias, "agent_trace_0");
+        assert_eq!(report.databases[0].checkout_id, "aaaa");
+        match &report.databases[0].status {
+            DatabaseRowStatus::Ready { stats } => assert_eq!(stats.diff_traces, 3),
+            DatabaseRowStatus::Skipped { .. } => panic!("expected ready row"),
+        }
+        assert_eq!(report.databases[1].alias, "agent_trace_1");
+        assert_eq!(report.databases[1].checkout_id, "bbbb");
+        match &report.databases[1].status {
+            DatabaseRowStatus::Ready { stats } => assert_eq!(stats.diff_traces, 1),
+            DatabaseRowStatus::Skipped { .. } => panic!("expected ready row"),
+        }
+        assert_eq!(report.databases[2].alias, "agent_trace_2");
+        assert_eq!(report.databases[2].checkout_id, "cccc");
+        match &report.databases[2].status {
+            DatabaseRowStatus::Skipped { missing_table } => {
+                assert_eq!(missing_table, "post_commit_patch_intersections");
+            }
+            DatabaseRowStatus::Ready { .. } => panic!("expected skipped row"),
+        }
+    }
+}
diff --git a/context/architecture.md b/context/architecture.md
index 1c58c66e..daf4c6e9 100644
--- a/context/architecture.md
+++ b/context/architecture.md
@@ -95,11 +95,11 @@ The repository includes a new placeholder Rust binary crate at `cli/`.
 - The npm distribution implementation lives under `npm/`: `package.json` defines the `sce` package surface, `bin/sce.js` launches the package-local native binary, `lib/install.js` resolves the current package version against the release manifest, verifies `sce-v<version>-release-manifest.json.sig` with the bundled public key before trusting manifest contents, and then installs the checksum-verified native archive for supported macOS/Linux targets, while `test/platform.test.js` and `test/install.test.js` cover platform selection plus signed-manifest installer behavior.
 
 - `cli/src/main.rs` is the executable entrypoint (`sce`) and delegates to `app::run`.
-- `cli/src/cli_schema.rs` defines the clap-based CLI schema using derive macros for all top-level commands and subcommands, and renders command-local help text for the `auth` command tree (`auth`, `auth login`, `auth logout`, `auth status`).
+- `cli/src/cli_schema.rs` defines the clap-based CLI schema using derive macros for all top-level commands and subcommands, including the `trace db shell <uuid-or-alias>` surface, and renders command-local help text for the `auth` command tree (`auth`, `auth login`, `auth logout`, `auth status`).
 - `cli/src/app.rs` provides the clap-based argument dispatch loop with deterministic help/setup execution, bare-command help routing for `sce auth` and `sce config`, centralized stream routing (`stdout` success payloads, `stderr` redacted diagnostics), stable class-based exit-code mapping (`2` parse, `3` validation, `4` runtime, `5` dependency), and stable class-based stderr diagnostic codes (`SCE-ERR-PARSE`, `SCE-ERR-VALIDATION`, `SCE-ERR-RUNTIME`, `SCE-ERR-DEPENDENCY`) with default `Try:` remediation injection when missing.
 - The app runtime now moves through explicit startup phases in `cli/src/app.rs`: dependency bootstrapping (`perform_dependency_check`), startup context construction (`build_startup_context`), runtime initialization (`initialize_runtime`), command parse/execute inside telemetry subscriber context (`run_command_lifecycle`, `parse_command_phase` plus `services::app_support::execute_command_phase`), and final output rendering through `services::app_support::render_run_outcome`. `AppRuntime` owns the concrete production logger, no-op telemetry runtime, filesystem ops, git ops, static `CommandRegistry`, and startup-diagnostic state across those phases; `RunOutcome<L>` carries final render data with an optional generic logger implementing `services::observability::traits::Logger`, so render support can log classified errors without production-logger type coupling. If a telemetry implementation attempts to invoke the command action more than once, dispatch returns a runtime-classified error instead of panicking or reusing consumed arguments.
 - `AppContext` is the CLI's borrowed dependency view in `cli/src/app.rs`: it is generic over logger, telemetry, filesystem, and git capability implementations and stores references plus an optional `repo_root: Option<PathBuf>` instead of owning `Arc<dyn ...>` trait objects. Because it borrows from `AppRuntime`, `AppContext` is a lightweight, short-lived view and must not be stored long-term (e.g., in structs or across await points). Startup creates a context view over `AppRuntime`'s concrete production dependencies with `repo_root` set to `None`; command paths can derive repo-root-scoped context views through the `ContextWithRepoRoot` accessor trait / `AppContext::with_repo_root(...)`, which reuses the same borrowed dependencies while attaching the resolved root. Narrow accessor traits expose associated concrete capability types for logger, telemetry, fs, and git (`&Self::...`) plus repo-root access, so call sites can express capability requirements without erasing the borrowed dependencies back to trait objects; lifecycle providers consume the repo-root accessor rather than the full context type.
-- Command parse-time conversion and run-time handling are separated by an internal static `RuntimeCommand` seam. `cli/src/services/command_registry.rs` defines the `RuntimeCommand` enum with variants for help/help-text, version, completion, auth, config, setup, doctor, and hooks, plus a deterministic `CommandRegistry` name catalog populated by `build_default_registry()`. `parse_command_phase` in `cli/src/app.rs` delegates clap-output conversion to `cli/src/services/parse/command_runtime.rs`, which owns clap error classification, help rendering bridges, and parsed-request-to-enum conversion while returning concrete enum values. Service-owned `command.rs` modules define command payload structs and generic execution methods with narrow context requirements: context-free commands accept any context, hooks requires logger access, setup/doctor require repo-root scoping, and central dispatch requires the union of logger plus repo-root-scoping capabilities. `services::app_support::execute_command_phase` emits lifecycle logs around `RuntimeCommand::execute(...)`; the enum performs the only central dispatch match and delegates business behavior to the service-owned command structs.
+- Command parse-time conversion and run-time handling are separated by an internal static `RuntimeCommand` seam. `cli/src/services/command_registry.rs` defines the `RuntimeCommand` enum with variants for help/help-text, version, completion, auth, config, setup, doctor, hooks, policy, and trace, plus a deterministic `CommandRegistry` name catalog populated by `build_default_registry()`. `parse_command_phase` in `cli/src/app.rs` delegates clap-output conversion to `cli/src/services/parse/command_runtime.rs`, which owns clap error classification, help rendering bridges, and parsed-request-to-enum conversion while returning concrete enum values. Service-owned `command.rs` modules define command payload structs and generic execution methods with narrow context requirements: context-free commands accept any context, hooks requires logger access, setup/doctor require repo-root scoping, and central dispatch requires the union of logger plus repo-root-scoping capabilities. `services::app_support::execute_command_phase` emits lifecycle logs around `RuntimeCommand::execute(...)`; the enum performs the only central dispatch match and delegates business behavior to the service-owned command structs.
 - Startup observability bootstrapping in `cli/src/app.rs` still tolerates invalid default-discovered config files by continuing with degraded defaults plus `sce.config.invalid_config` warn-level logs, but the warning/logging work is now isolated behind the startup-context and runtime-initialization phases rather than one inline startup function.
 - `cli/src/services/observability.rs` provides deterministic runtime observability controls and rendering for app lifecycle logs, including shared config-resolved threshold/format and file-sink inputs with precedence `env > config file > defaults` for non-flag observability keys, optional file sink controls (`SCE_LOG_FILE`, `SCE_LOG_FILE_MODE` with deterministic truncate-or-append policy), stable event identifiers, severity filtering, the forced-emission warning path used for invalid discovered config startup diagnostics, stderr-only primary emission with optional mirrored file writes, and redaction-safe emission through the shared security helper. Its `observability::traits` submodule exposes the current `Logger` and object-safe `Telemetry` trait boundaries plus `NoopLogger`; the concrete observability logger and telemetry runtime still own behavior and implement those traits without changing runtime behavior. `services::app_support::render_run_outcome` consumes the logger through that trait boundary when logging classified errors and stdout-write failures.
 - `cli/src/services/observability.rs` no longer owns duplicate log enums or parsing helpers; it consumes the canonical primitive seam from `cli/src/services/config/mod.rs` and stays focused on logger and telemetry runtime behavior.
@@ -113,7 +113,7 @@ The repository includes a new placeholder Rust binary crate at `cli/`.
 - `cli/src/services/lifecycle.rs` defines the current compile-safe lifecycle seam. `ServiceLifecycle` has default no-op generic `diagnose`, `fix`, and `setup` methods over `C: HasRepoRoot`, with lifecycle-owned health, fix, and setup result types so the trait contract is not publicly anchored to doctor/setup module types or the full `AppContext` shape. The same module owns the static `LifecycleProvider` enum and shared `lifecycle_providers(include_hooks)` catalog/factory, returning providers in deterministic order (config → local_db → auth_db → agent_trace_db → hooks when requested); enum dispatch calls each concrete provider through generic context methods without boxed lifecycle-provider allocation or repo-root trait-object context erasure. Hooks exposes a `HooksLifecycle` provider in `cli/src/services/hooks/lifecycle.rs` for hook rollout diagnosis/fix/setup using lifecycle-owned health records plus the canonical required-hook installer. Config exposes a `ConfigLifecycle` provider in `cli/src/services/config/lifecycle.rs` for global/repo-local config validation and repo-local `.sce/config.json` bootstrap. local_db exposes a `LocalDbLifecycle` provider in `cli/src/services/local_db/lifecycle.rs` for canonical local DB path health, parent-directory readiness/bootstrap, and `LocalDb::new()` setup. auth_db exposes an `AuthDbLifecycle` provider in `cli/src/services/auth_db/lifecycle.rs` for canonical auth DB path health, parent-directory readiness/bootstrap, and `AuthDb::new()` setup. agent_trace_db exposes an `AgentTraceDbLifecycle` provider in `cli/src/services/agent_trace_db/lifecycle.rs` for setup-time checkout identity creation when a repo root is available, per-checkout Agent Trace DB path health/fix when an ID exists, and legacy global DB fallback outside checkout context. Doctor runtime aggregates the full provider catalog for `diagnose` and `fix` and adapts lifecycle records into doctor report/fix records at the orchestration boundary; setup command aggregates the shared catalog for `setup` with hooks included only when requested and adapts hook setup outcomes before rendering setup-owned messages.
 - Agent Trace lifecycle setup uses checkout identity to resolve the per-checkout DB path and initializes it with `AgentTraceDb::open_at(path)`; hook runtime keeps lazy per-checkout DB initialization/upgrade only as the fallback for setup-not-run or incomplete-schema cases.
 - `cli/src/services/auth_command/mod.rs` defines the implemented auth command surface for `sce auth login|renew|logout|status`, including device-flow login, stored-token renewal (`--force` supported for renew), logout, and status rendering in text/JSON formats; `cli/src/services/auth_command/command.rs` owns the `AuthCommand` payload used by the static `RuntimeCommand` enum.
-- `cli/src/services/db/mod.rs` provides the shared generic Turso infrastructure seam: `DbSpec` supplies a service-specific name, path, ordered embedded migrations, and config-file lookup key (`db_config_key()`), while `TursoDb<M: DbSpec>` owns parent-directory creation, `Builder::new_local(...)` initialization (with `experimental_multiprocess_wal(true)` for safe concurrent access), Turso connection setup, tokio current-thread runtime bridging, retry-backed blocking `execute`/`query`/`query_map` wrappers, and generic migration execution with per-database `__sce_migrations` metadata. `TursoDb::new()` and `EncryptedTursoDb::new()` wrap only their local open/connect block in `run_with_retry_sync` using a config-driven connection-open policy resolved from the `DATABASE_RETRY_CONFIG` `OnceLock` with fallback to hardcoded defaults, while both adapters' `execute()`, `query()`, and `query_map()` methods use a config-driven operation policy from the same source. Both adapters' `query_map()` methods retry the initial query and row-fetch loop, then apply caller row mapping after retry completion. Migration execution is not retried. The same module also provides `EncryptedTursoDb<M: DbSpec>`, a structurally parallel encrypted adapter that resolves the encryption key through `encryption_key::get_or_create_encryption_key()`, enables Turso local encryption with strict `aegis256` cipher selection, and exposes retry-backed synchronous wrappers plus migration execution. `cli/src/services/db/encryption_key.rs` first derives a Turso-compatible 64-character hex key from non-empty `SCE_AUTH_DB_ENCRYPTION_KEY` env-secret text when present, otherwise falls back to keyring-backed credential-store get-or-create behavior; no plaintext auth DB fallback exists.
+- `cli/src/services/db/mod.rs` provides the shared generic Turso infrastructure seam: `DbSpec` supplies a service-specific name, path, ordered embedded migrations, and config-file lookup key (`db_config_key()`), while `TursoDb<M: DbSpec>` owns parent-directory creation, `Builder::new_local(...)` initialization (with `experimental_multiprocess_wal(true)` for safe concurrent access), Turso connection setup, tokio current-thread runtime bridging, retry-backed blocking `execute`/`query`/`query_values`/`query_map` wrappers, and generic migration execution with per-database `__sce_migrations` metadata. `TursoDb::new()` and `EncryptedTursoDb::new()` wrap only their local open/connect block in `run_with_retry_sync` using a config-driven connection-open policy resolved from the `DATABASE_RETRY_CONFIG` `OnceLock` with fallback to hardcoded defaults, while operation methods use a config-driven operation policy from the same source. `query_values()` returns fully fetched column names plus raw `turso::Value` rows for deterministic operator-facing rendering; `query_map()` retries the initial query and row-fetch loop, then applies caller row mapping after retry completion. Migration execution is not retried. The same module also provides `EncryptedTursoDb<M: DbSpec>`, a structurally parallel encrypted adapter that resolves the encryption key through `encryption_key::get_or_create_encryption_key()`, enables Turso local encryption with strict `aegis256` cipher selection, and exposes retry-backed synchronous wrappers plus migration execution. `cli/src/services/db/encryption_key.rs` first derives a Turso-compatible 64-character hex key from non-empty `SCE_AUTH_DB_ENCRYPTION_KEY` env-secret text when present, otherwise falls back to keyring-backed credential-store get-or-create behavior; no plaintext auth DB fallback exists.
 - `cli/src/services/local_db/mod.rs` provides the concrete local DB spec and `LocalDb` type alias over the shared generic `TursoDb<LocalDbSpec>` adapter. `LocalDbSpec` resolves the deterministic persistent runtime DB target through the shared default-path seam and declares no local migrations; `TursoDb` supplies retry-backed blocking `execute`/`query`, parent-directory creation, Turso connection setup, tokio current-thread runtime bridging, and generic migration execution.
 - `cli/src/services/auth_db/mod.rs` provides the encrypted auth DB spec and `AuthDb` type alias over `EncryptedTursoDb<AuthDbSpec>`. `AuthDbSpec` resolves `<state_root>/sce/auth.db` through the shared default-path seam and embeds ordered auth migrations. Auth DB lifecycle setup/doctor integration is wired through `AuthDbLifecycle`; auth command/token-storage reads/writes are directed through `token_storage.rs`.
 - `cli/src/services/agent_trace_db/mod.rs` provides the Agent Trace DB spec and `AgentTraceDb` type alias over `TursoDb<AgentTraceDbSpec>`. `AgentTraceDbSpec` resolves the legacy `<state_root>/sce/agent-trace.db` fallback through the shared default-path seam and embeds ordered fresh-start migrations `001..016` for `diff_traces`, `post_commit_patch_intersections`, `agent_traces`, `messages`, `parts`, `session_models`, `diff_traces.payload_type`, indexes, and triggers. `agent_traces.agent_trace_id` is `NOT NULL UNIQUE`. The module provides explicit-path `open_at(path)` and `open_for_hooks_without_migrations_at(path)` helpers for per-checkout DB files plus `DiffTraceInsert<'_>`/`insert_diff_trace()` including the `payload_type` discriminator, `PostCommitPatchIntersectionInsert<'_>`/`insert_post_commit_patch_intersection()`, `AgentTraceInsert<'_>`/`insert_agent_trace()`, `InsertMessageInsert`/`insert_message()` plus `insert_messages()` for parent message inserts with duplicate `(session_id, message_id)` writes ignored, `InsertPartInsert`/`insert_part()` plus `insert_parts()` for append-only part text writes, `SessionModelUpsert<'_>`/`upsert_session_model()` plus lookup helpers for durable `session_models` attribution, and `recent_diff_trace_patches(cutoff_time_ms, end_time_ms)` for inclusive chronological `diff_traces` reads that dispatch on `payload_type`, parse valid raw patch or structured payload rows, and return skipped malformed-row reports. `cli/src/services/agent_trace_db/lifecycle.rs` registers Agent Trace DB setup/doctor lifecycle behavior: setup creates/reuses and registers checkout identity, resolves `<state_root>/sce/agent-trace-{checkout_id}.db`, initializes it with `AgentTraceDb::open_at(path)`, and records `database_path`; active hook runtime still resolves checkout identity and lazily creates or upgrades the per-checkout DB when setup has not run or schema metadata is incomplete.
@@ -121,17 +121,17 @@ The repository includes a new placeholder Rust binary crate at `cli/`.
 - `cli/src/services/setup/mod.rs` defines the setup command contract (`SetupMode`, `SetupTarget`, `SetupRequest`, CLI flag parser/validator), an `inquire`-backed interactive target prompter (`InquireSetupTargetPrompter`), setup dispatch outcomes (proceed/cancelled), compile-time embedded asset access (`EmbeddedAsset`, target-scoped iterators, required-hook asset iterators/lookups) generated by `cli/build.rs` from the ephemeral crate-local `cli/assets/generated/config/{opencode,claude}/**` mirror plus `cli/assets/hooks/**`, and focused internal support seams for install-flow vs prompt-flow logic; `cli/src/services/setup/command.rs` owns the `SetupCommand` payload used by the static `RuntimeCommand` enum and executes against any context implementing repo-root scoping. Its install engine/orchestrator stages embedded files and uses a unified remove-and-replace policy (removing existing targets before swapping staged content, with deterministic recovery guidance on swap failure and no backup artifact creation), and formats deterministic completion messaging; required-hook install orchestration (`install_required_git_hooks`) follows the same remove-and-replace policy (removing existing hooks before swapping staged content, with deterministic recovery guidance on swap failure). The setup command derives a repo-root-scoped context before aggregating static lifecycle provider `setup` dispatch across providers (config → local_db → auth_db → agent_trace_db → hooks when requested), so setup providers consume only repo-root access from the scoped context.
 - `cli/src/services/setup/mod.rs` keeps those responsibilities inside one file for now, but the current ownership split is explicit: the inline `install` module owns repository-path normalization, staging/swap install behavior, required-hook installation, and filesystem safety guards, while the inline `prompt` module owns interactive target selection and prompt styling.
 - `cli/src/services/security.rs` provides shared security utilities for deterministic secret redaction (`redact_sensitive_text`) and directory write-permission probes (`ensure_directory_is_writable`) used by app/setup/observability surfaces.
-- `cli/src/services/doctor/mod.rs` owns the current doctor request/report surface while focused submodules (`doctor/inspect.rs`, `doctor/render.rs`, `doctor/fixes.rs`, `doctor/types.rs`) split report fact collection, rendering, manual fix reporting, and doctor-owned domain types into smaller seams; `cli/src/services/doctor/command.rs` owns the `DoctorCommand` payload used by the static `RuntimeCommand` enum and executes against any context implementing repo-root scoping. Runtime doctor execution either renders `sce doctor dbs` checkout discovery or resolves a repository root, derives a scoped context, requests the shared static lifecycle provider catalog with hooks included for service-owned `diagnose` and `fix` behavior, adapts lifecycle-owned health/fix records into doctor-owned problem/fix records, and then renders stable text/JSON problem records with category/severity/fixability/remediation fields plus deterministic fix-result reporting in fix mode. Report fact collection preserves environment/repository/hook/integration display data and adds checkout identity plus per-checkout Agent Trace DB status when a checkout ID exists, while service-owned lifecycle providers own config validation, local DB and Agent Trace DB readiness/bootstrap, and hook rollout diagnosis/repair.
+- `cli/src/services/doctor/mod.rs` owns the current doctor request/report surface while focused submodules (`doctor/inspect.rs`, `doctor/render.rs`, `doctor/fixes.rs`, `doctor/types.rs`) split report fact collection, rendering, manual fix reporting, and doctor-owned domain types into smaller seams; `cli/src/services/doctor/command.rs` owns the `DoctorCommand` payload used by the static `RuntimeCommand` enum and executes against any context implementing repo-root scoping. Runtime doctor execution resolves a repository root, derives a scoped context, requests the shared static lifecycle provider catalog with hooks included for service-owned `diagnose` and `fix` behavior, adapts lifecycle-owned health/fix records into doctor-owned problem/fix records, and then renders stable text/JSON problem records with category/severity/fixability/remediation fields plus deterministic fix-result reporting in fix mode. Checkout DB discovery no longer lives in `doctor`; it moved to the `trace` group (`sce trace db list`) in `cli/src/services/trace/`. Report fact collection preserves environment/repository/hook/integration display data and adds checkout identity plus per-checkout Agent Trace DB status when a checkout ID exists, while service-owned lifecycle providers own config validation, local DB and Agent Trace DB readiness/bootstrap, and hook rollout diagnosis/repair.
 - `cli/src/services/version/mod.rs` defines the version command parser/rendering contract (`parse_version_request`, `render_version`) with deterministic text output and stable JSON runtime-identification fields; `cli/src/services/version/command.rs` owns the `VersionCommand` payload used by the static `RuntimeCommand` enum.
 - `cli/src/services/completion/mod.rs` defines completion parser/rendering contract (`parse_completion_request`, `render_completion`) with deterministic Bash/Zsh/Fish script output aligned to current parser-valid command/flag surfaces; `cli/src/services/completion/command.rs` owns the `CompletionCommand` payload used by the static `RuntimeCommand` enum.
 - `cli/src/services/hooks/mod.rs` defines the current local hook runtime parsing/dispatch (`HookSubcommand`, `run_hooks_subcommand`) plus a commit-msg co-author policy seam (`apply_commit_msg_coauthor_policy`) that injects one canonical SCE trailer only when the enabled-by-default attribution-hooks config/env control is not opted out, `SCE_DISABLED` is false, and the staged-diff AI-overlap preflight confirms AI/editor evidence (`StagedDiffAiOverlapResult::Overlap`); the preflight is wired into `run_commit_msg_subcommand_in_repo` and logs `sce.hooks.commit_msg.ai_overlap_error` on error paths; `cli/src/services/hooks/command.rs` owns the `HooksCommand` payload used by the static `RuntimeCommand` enum. In the current attribution-only baseline, `pre-commit` and `post-rewrite` are deterministic no-op surfaces; `post-commit` requires validated `--remote-url`, threads that URL through the Agent Trace flow, prints it to stderr, and remains an active intersection + Agent Trace persistence entrypoint (captures current commit patch, queries recent `diff_traces` from the bounded past-7-days window, combines valid patches via `patch::combine_patches`, intersects with post-commit patch via `patch::intersect_patches`, persists result to `post_commit_patch_intersections`, then persists built Agent Trace payloads with range-level `content_hash` values to `agent_traces` in AgentTraceDb without post-commit file artifacts); `diff-trace` performs STDIN JSON intake, validates required non-empty `sessionID`/`diff`/`tool_name`, optional `model_id` (absent/`null` → `None`, resolved from `session_models` by `tool_name` + `session_id` when absent) and required `tool_version` (present and either `null` or non-empty string) plus required `u64` `time` (Unix epoch milliseconds), rejects values that cannot fit AgentTraceDb signed `time_ms` storage, inserts the parsed payload fields into AgentTraceDb without writing a parsed-payload artifact under `context/tmp`; `session-model` performs STDIN JSON intake, validates required non-empty `sessionID`/`model_id`/`tool_name`, required `u64` `time` (Unix epoch milliseconds), and required nullable/non-empty `tool_version`, then upserts the parsed payload into AgentTraceDb `se... (line truncated to 2000 chars)
 - Claude `SessionStart` session-model parsing in `cli/src/services/hooks/mod.rs` uses explicit payload version fields (`tool_version`/`claude_version`/`version`) when present; if no non-empty payload version is available, it best-effort runs `claude --version`, trims stdout, and leaves `tool_version` nullable without failing intake when the command is unavailable, fails, or returns empty output.
 - Diff-trace attribution resolution in `cli/src/services/hooks/mod.rs` looks up `session_models` when `model_id` or `tool_version` is missing/nullable, fills only missing fields from the stored row when available, preserves direct payload precedence, and continues persistence with `None` for unresolved attribution.
 - `cli/src/services/resilience.rs` defines bounded retry/timeout/backoff execution policy (`RetryPolicy`, `run_with_retry`) for transient operation hardening with deterministic failure messaging and retry observability.
-- No user-invocable `sce sync` command is wired in the current runtime; local DB bootstrap and setup-time per-checkout Agent Trace DB initialization flow through lifecycle providers aggregated by setup, while checkout/global DB health/repair and checkout DB discovery flow through the doctor surface.
+- No user-invocable `sce sync` command is wired in the current runtime; local DB bootstrap and setup-time per-checkout Agent Trace DB initialization flow through lifecycle providers aggregated by setup, while checkout/global DB health/repair flow through the doctor surface and checkout DB discovery flows through the `trace` group (`sce trace db list`).
 - `cli/src/services/patch.rs` defines the standalone patch domain model (`ParsedPatch`, `PatchFileChange`, `FileChangeKind`, `PatchHunk`, `TouchedLine`, `TouchedLineKind`) for in-memory parsed unified-diff representation, capturing only touched lines (added/removed) plus minimal per-file/per-hunk metadata while excluding non-hunk headers and unchanged context lines. All types are `serde`-serializable/deserializable with `snake_case` JSON field naming. The module also provides `parse_patch`, a public parser function that converts raw unified-diff text (both `Index:` SVN-style and `diff --git` git-style formats) into `ParsedPatch` structs, with `ParseError` for actionable malformed-input diagnostics. Storage-agnostic JSON load helpers (`load_patch_from_json` for string input, `load_patch_from_json_bytes` for byte input) reconstruct `ParsedPatch` from serialized JSON content with `PatchLoadError` for actionable deserialization diagnostics. Its patch-set operations now include deterministic ordered combination plus target-shaped intersection that prefers exact touched-line matches and falls back to historical `kind`+`content` matching when incremental diffs and canonical post-commit diffs have drifted line numbers; `parse_patch`, `combine_patches`, and `intersect_patches` are consumed by the active post-commit hook runtime.
 - `cli/src/services/structured_patch.rs` defines the synchronous structured editor-hook derivation seam. It derives Claude `PostToolUse` `Write` structured-update hunks, `Write` `tool_input.content` create fallback, and `Edit` structured-patch payloads into canonical `ParsedPatch` values plus Claude session/tool metadata, returning deterministic skip reasons for unsupported events/tools/payload shapes. The module is pure and side-effect-free. It is wired into `sce hooks diff-trace` for Claude payload classification at intake (T04) and into `AgentTraceDb::recent_diff_trace_patches` for post-commit structured payload parsing dispatch at read time (T05).
-- `cli/src/services/` contains module boundaries for command_registry, lifecycle, auth_command, config, setup, doctor, hooks, checkout identity, bash_policy, version, completion, help, patch, SCE web URL helpers, shared database infrastructure, local DB adapters, encrypted auth DB adapters, and Agent Trace DB adapters with explicit trait seams for future implementations. `cli/src/services/checkout/` owns checkout ID file infrastructure and per-checkout Agent Trace DB lazy resolution for hook runtime; setup uses `AgentTraceDbLifecycle::setup()` to establish checkout identity and initialize the per-checkout DB, while `sce doctor` surfaces checkout identity and per-checkout Agent Trace DB status when a checkout ID exists and `sce doctor dbs` discovers checkouts via filesystem scan of `agent-trace-*.db` files on disk. `cli/src/services/bash_policy.rs` owns both the CLI-agnostic evaluator logic and the hidden `sce policy bash` command adapter used by OpenCode and Claude hook callers. `cli/src/services/command_registry.rs` defines the static `RuntimeCommand` enum, deterministic `CommandRegistry` name catalog, and `build_default_registry()` function for command dispatch metadata. Service-owned command modules own the runtime command payload structs for help/help-text, version, completion, auth, config, setup, doctor, hooks, and policy.
+- `cli/src/services/` contains module boundaries for command_registry, lifecycle, auth_command, config, setup, doctor, hooks, checkout identity, bash_policy, version, completion, help, patch, SCE web URL helpers, shared database infrastructure, local DB adapters, encrypted auth DB adapters, and Agent Trace DB adapters with explicit trait seams for future implementations. `cli/src/services/checkout/` owns checkout ID file infrastructure and per-checkout Agent Trace DB lazy resolution for hook runtime; setup uses `AgentTraceDbLifecycle::setup()` to establish checkout identity and initialize the per-checkout DB, while `sce doctor` surfaces checkout identity and per-checkout Agent Trace DB status when a checkout ID exists and `sce trace db list` discovers checkouts via filesystem scan of `agent-trace-*.db` files on disk. `cli/src/services/bash_policy.rs` owns both the CLI-agnostic evaluator logic and the hidden `sce policy bash` command adapter used by OpenCode and Claude hook callers. `cli/src/services/command_registry.rs` defines the static `RuntimeCommand` enum, deterministic `CommandRegistry` name catalog, and `build_default_registry()` function for command dispatch metadata. Service-owned command modules own the runtime command payload structs for help/help-text, version, completion, auth, config, setup, doctor, hooks, and policy.
 - `cli/README.md` is the crate-local onboarding and usage source of truth for placeholder behavior, safety limitations, and roadmap mapping back to service contracts.
 - `flake.nix` applies `rust-overlay` (`oxalica/rust-overlay`) to nixpkgs, pins `rust-bin.stable.1.95.0.default` with `rustfmt` + `clippy`, reads the package/check version from repo-root `.version`, builds `packages.sce` through Crane (`buildDepsOnly` -> `buildPackage`) with a filtered repo-root source that preserves the Cargo tree plus `cli/assets/hooks`, then injects generated OpenCode/Claude config payloads and schema inputs into a temporary `cli/assets/generated/` mirror during derivation unpack so `cli/build.rs` can package the crate without requiring committed generated crate assets. The same `cli/build.rs` now scans `cli/migrations/*/*.sql` and writes `cli/src/generated_migrations.rs` with deterministic migration constants sorted by numeric filename prefix.
 - The root flake runs `cli-tests`, `cli-clippy`, and `cli-fmt` plus the dedicated `integrations-install-tests`, `integrations-install-clippy`, and `integrations-install-fmt` derivations through Crane-backed paths so both Rust crates have first-class default-flake verification; it also exposes directory-scoped JS validation derivations for both `npm/` and the shared `config/lib/` plugin package root.
diff --git a/context/cli/checkout-identity.md b/context/cli/checkout-identity.md
index d1a919aa..4a1a7628 100644
--- a/context/cli/checkout-identity.md
+++ b/context/cli/checkout-identity.md
@@ -31,7 +31,7 @@ During hook runtime:
 - `AgentTraceDb::open_for_hooks_without_migrations_at(path)` is tried first; `ensure_schema_ready_for_hooks()` decides whether the schema is current.
 - Missing or incomplete schema falls back to `AgentTraceDb::open_at(path)`, which runs migrations through the shared Turso adapter.
 
-The global `agent-trace.db` path remains only as a lifecycle fallback when no checkout context or checkout ID is available. `sce doctor` displays the current checkout ID and per-checkout Agent Trace DB status when a checkout ID exists, and `sce doctor dbs` discovers checkouts by scanning `<state_root>/sce/agent-trace-*.db` files on disk, sorted by mtime descending.
+The global `agent-trace.db` path remains only as a lifecycle fallback when no checkout context or checkout ID is available. `sce doctor` displays the current checkout ID and per-checkout Agent Trace DB status when a checkout ID exists, and `sce trace db list` discovers checkouts by scanning `<state_root>/sce/agent-trace-*.db` files on disk, sorted by mtime descending.
 
 ## Testing boundary
 
diff --git a/context/cli/cli-command-surface.md b/context/cli/cli-command-surface.md
index 91430558..3d81002e 100644
--- a/context/cli/cli-command-surface.md
+++ b/context/cli/cli-command-surface.md
@@ -47,7 +47,7 @@ Operator onboarding currently comes from `sce --help`, command-local `--help` ou
 - the banner uses a per-column right-to-left color gradient (cyan on the right, magenta on the left) when stdout color is enabled, and renders as plain ASCII when color is disabled (non-TTY or `NO_COLOR`)
 - the banner is rendered by `command_surface::help_text()` calling `style::banner_with_gradient(SCE_BANNER_LINES)` before the heading
 - the visible real-command rows are sourced from `cli_schema::TOP_LEVEL_COMMANDS`, so top-level purpose text and help visibility are defined once for both help rendering and known-command classification
-- the visible command list is `help`, `config`, `setup`, `doctor`, `version`, and `completion`
+- the visible command list is `help`, `config`, `setup`, `doctor`, `trace`, `version`, and `completion`
 - top-level help omits implemented/placeholder labels
 - top-level examples cover setup plus doctor/version machine-readable or repair-intent flows (`doctor --format json`, `doctor --fix`, `version --format json`) and use the shared example-command styling when stdout color is enabled
 - `auth` and `hooks` stay parser-valid and directly invocable, but are hidden from those top-level help surfaces
@@ -63,7 +63,7 @@ Deferred or gated command surfaces currently avoid claiming unimplemented behavi
 `setup` now also exposes compile-time embedded config assets for OpenCode/Claude targets, sourced from the generated `config/.opencode/**` and `config/.claude/**` trees via `cli/build.rs` with normalized forward-slash relative paths and target-scoped iteration APIs; the embedded asset set includes the OpenCode bash-policy plugin wrapper plus Claude settings `PreToolUse` Bash policy hook, both delegating to the Rust `sce policy bash` path.
 `setup` additionally includes a repository-root install engine (`install_embedded_setup_assets`) that stages embedded files and uses a unified remove-and-replace policy for `.opencode/`/`.claude/` (removing existing targets before swapping staged content, with deterministic recovery guidance on swap failure) while treating bash-policy enforcement files as first-class SCE-managed assets.
 `setup` now executes end-to-end and prints deterministic completion details including selected target(s) and per-target install count.
-`doctor` now executes end-to-end with explicit diagnosis, repair-intent, and checkout-discovery surfaces: `sce doctor` stays read-only, `sce doctor --fix` selects repair-intent mode, and `sce doctor dbs [--format text|json]` discovers checkouts by scanning `<state_root>/sce/agent-trace-*.db` files on disk. The current runtime aggregates `ServiceLifecycle::diagnose` and `ServiceLifecycle::fix` calls across all registered service providers (`config`, `local_db`, `auth_db`, `agent_trace_db`, `hooks`) plus integration checks, covering state-root resolution, global and repo-local `sce/config.json` readability/schema validation, local DB and checkout/global Agent Trace DB path/health, DB-parent readiness barriers, the repo hook rollout slice when a repository target is detected, and repo-root installed OpenCode integration presence for `plugins`, `agents`, `commands`, and `skills`. Fix mode delegates to each provider's `fix` implementation, which reuses the canonical setup hook install flow to repair missing/stale/non-executable required hooks and missing hooks directories, and it can bootstrap missing canonical database parent directories when the resolved paths match canonical owned locations.
+`doctor` now executes end-to-end with explicit diagnosis and repair-intent surfaces: `sce doctor` stays read-only and `sce doctor --fix` selects repair-intent mode. Agent Trace DB checkout discovery has moved out of `doctor` into the `trace` group (`sce trace db list`, `sce trace status`, `sce trace status --all`); see [trace-command.md](trace-command.md). The current `doctor` runtime aggregates `ServiceLifecycle::diagnose` and `ServiceLifecycle::fix` calls across all registered service providers (`config`, `local_db`, `auth_db`, `agent_trace_db`, `hooks`) plus integration checks, covering state-root resolution, global and repo-local `sce/config.json` readability/schema validation, local DB and checkout/global Agent Trace DB path/health, DB-parent readiness barriers, the repo hook rollout slice when a repository target is detected, and repo-root installed OpenCode integration presence for `plugins`, `agents`, `commands`, and `skills`. Fix mode delegates to each provider's `fix` implementation, which reuses the canonical setup hook install flow to repair missing/stale/non-executable required hooks and missing hooks directories, and it can bootstrap missing canonical database parent directories when the resolved paths match canonical owned locations.
 A user-invocable `sync` command is not wired in the current CLI surface; local DB and Agent Trace DB bootstrap currently happen through `setup`, and DB health/repair currently happens through `doctor`. Command wiring for `sce sync` is deferred to `0.4.0`.
 
 ## Command loop and error model
@@ -80,7 +80,7 @@ A user-invocable `sync` command is not wired in the current CLI surface; local D
 - Interactive `sce setup` prompt cancellation/interrupt exits cleanly with: `Setup cancelled. No files were changed.`
 - Command handlers return deterministic status messaging:
 - `setup`: `Setup completed successfully.` plus selected targets and per-target install destinations/counts.
-- `doctor`: current runtime emits `SCE doctor diagnose` / `SCE doctor fix` human text headers plus ordered `Environment`, `Configuration` (including checkout identity + Agent Trace checkout DB rows when available), `Repository`, `Git Hooks`, and `Integrations` sections with bracketed `[PASS]`/`[FAIL]`/`[MISS]` row tokens, shared-style green pass plus red fail/miss colorization when enabled, simplified `label (path)` rows, top-level-only hook rows, and a deterministic summary footer; JSON output carries stable problem/fixability records plus deterministic fix-result records in fix mode and reports `checkout_identity` plus the resolved Agent Trace DB record. `sce doctor dbs` emits either `no discovered checkouts` or discovered checkout rows sorted by mtime descending, with JSON fields `checkout_id`, `database_path`, and `last_seen`.
+- `doctor`: current runtime emits `SCE doctor diagnose` / `SCE doctor fix` human text headers plus ordered `Environment`, `Configuration` (including checkout identity + Agent Trace checkout DB rows when available), `Repository`, `Git Hooks`, and `Integrations` sections with bracketed `[PASS]`/`[FAIL]`/`[MISS]` row tokens, shared-style green pass plus red fail/miss colorization when enabled, simplified `label (path)` rows, top-level-only hook rows, and a deterministic summary footer; JSON output carries stable problem/fixability records plus deterministic fix-result records in fix mode and reports `checkout_identity` plus the resolved Agent Trace DB record.
   - `hooks`: deterministic hook subcommand status messaging for runtime entrypoint invocation and argument/STDIN contract validation.
 
 ## Service contracts
diff --git a/context/cli/trace-command.md b/context/cli/trace-command.md
new file mode 100644
index 00000000..fdb13738
--- /dev/null
+++ b/context/cli/trace-command.md
@@ -0,0 +1,226 @@
+# sce trace command
+
+Top-level CLI command group exposing Agent Trace database visibility for operators.
+
+Lives under `cli/src/services/trace/` with these subcommands:
+
+- `sce trace db list` — discover per-checkout Agent Trace DBs under `<state_root>/sce/agent-trace-*.db` and render an alias / status / path table.
+- `sce trace db shell <uuid-or-alias>` — resolve a discovered ready DB by positional alias or checkout ID and open an embedded in-process SQL shell.
+- `sce trace status` — render counts and last-activity for the cwd's checkout DB.
+- `sce trace status --all` — aggregate counts across every discovered DB.
+
+The list/status subcommands declare `--format text|json` via `services::output_format::OutputFormat`; `db shell` is interactive and uses standard input/output directly after successful resolution. Clap surface is defined in `cli/src/cli_schema.rs` (`Commands::Trace`, `TraceSubcommand`, `TraceDbSubcommand`) and dispatched through `services::command_registry` to `services::trace::command::TraceCommand`.
+
+## Implemented behavior
+
+### Discovery — `services::trace::discovery`
+
+`discover_agent_trace_dbs()` scans the resolved `<state_root>/sce/` directory for `agent-trace-{checkout_id}.db` files, sorts by file mtime descending (ties broken by `checkout_id` ascending), and assigns positional `agent_trace_{N}` aliases. Each entry carries an mtime-derived `SystemTime`, the parsed `checkout_id`, and a `Readiness` verdict (`Ready` or `Skipped { missing_table }`).
+
+Readiness is probed read-only via `AgentTraceDb::open_for_hooks_without_migrations_at` and a `sqlite_master` lookup for each required table in declared order:
+
+```
+diff_traces
+post_commit_patch_intersections
+agent_traces
+messages
+parts
+session_models
+```
+
+The first missing table is reported as the skip reason. The discovery module returns an empty Vec when the `sce` directory does not exist; callers do not need to special-case that.
+
+`resolve_agent_trace_db_identifier(databases, identifier)` is the pure resolver seam used by `sce trace db shell <uuid-or-alias>`. It accepts either an `agent_trace_N` alias or a full `checkout_id`, returns a cloned ready `DiscoveredAgentTraceDb`, rejects unknown identifiers with guidance to run `sce trace db list`, rejects ambiguous alias/checkout-ID collisions, and rejects skipped databases with the stored missing-table readiness reason.
+
+### Embedded shell core — `services::trace::shell`
+
+`run_agent_trace_db_shell(target, input, output)` opens the resolved Agent Trace DB path in-process with `AgentTraceDb::open_for_hooks_without_migrations_at`, verifies `ensure_schema_ready_for_hooks()`, prints the resolved alias, checkout ID, and database path, then runs a minimal SQL shell over caller-provided `BufRead`/`Write` streams. The core supports `.help`, `.tables`, `.exit`, and `.quit`, splits single-line input on semicolons, executes query statements through `TursoDb::query_values`, executes non-query statements through `execute`, and renders deterministic text rows as `column | column`, `--- | ---`, row values, and `(N rows)`. SQL errors are rendered as shell diagnostics and do not terminate the loop.
+
+`.tables` queries `sqlite_schema` for every visible table with `type = 'table'`, orders by table name, and prints one table name per line without counts or schema details. Internal SCE tables such as `__sce_migrations` are included when present.
+
+The shell command is embedded-only and does not invoke the external `turso` CLI. `TraceCommand` discovers DBs, resolves `<uuid-or-alias>` through `resolve_agent_trace_db_identifier`, maps resolver failures to validation-class CLI errors, then hands locked stdin/stdout to `run_agent_trace_db_shell`. The command returns an empty payload after shell exit so the normal app renderer does not duplicate shell output.
+
+Operator contract:
+
+- Run `sce trace db list` first to find the current positional alias (`agent_trace_N`) or copy the full checkout ID. Aliases follow discovery order and may change when DB mtimes change.
+- Start the shell with `sce trace db shell <uuid-or-alias>`, where the identifier must resolve to exactly one ready discovered DB. Unknown, ambiguous, or skipped/not-ready DB identifiers fail before the shell starts with validation-class guidance to inspect `sce trace db list`.
+- On startup, the shell prints the resolved alias, checkout ID, and database path before accepting SQL.
+- `.help` lists supported dot commands; `.tables` lists table names only in deterministic order; `.exit` and `.quit` terminate the shell.
+- Piped stdin is supported for deterministic automation, for example `SELECT COUNT(*) FROM diff_traces;` followed by `.exit`.
+- The implementation is an in-process Rust/Turso shell only; it never shells out to `turso`, `sqlite3`, or another external database CLI.
+
+### `sce trace db list` rendering — `services::trace::render_list`
+
+`render(databases, format)` dispatches to the text or JSON renderer.
+
+**Text** — `services::style::heading("SCE trace db list")` followed by a 4-column padded table:
+
+```
+Alias          Status                                              Updated at              Path
+agent_trace_0  ready                                               2026-06-27 12:34:56 UTC /path/to/agent-trace-aaaa.db
+agent_trace_1  skipped: missing table 'post_commit_patch_intersections'  2026-06-27 12:34:51 UTC /path/to/agent-trace-bbbb.db
+```
+
+Empty-state output is the heading plus `no agent-trace databases discovered`.
+
+**JSON** — stable shape:
+
+```json
+{
+  "status": "ok",
+  "command": "trace",
+  "subcommand": "db.list",
+  "databases": [
+    {
+      "alias": "agent_trace_0",
+      "checkout_id": "aaaa",
+      "path": "/path/to/agent-trace-aaaa.db",
+      "status": "ready",
+      "updated_at": "2026-06-27T12:34:56+00:00"
+    },
+    {
+      "alias": "agent_trace_1",
+      "checkout_id": "bbbb",
+      "path": "/path/to/agent-trace-bbbb.db",
+      "status": "skipped",
+      "skip_reason": "missing table: post_commit_patch_intersections",
+      "updated_at": "2026-06-27T12:34:51+00:00"
+    }
+  ]
+}
+```
+
+`skip_reason` is omitted when `status == "ready"`. Text `Updated at` is rendered as `YYYY-MM-DD HH:MM:SS UTC` from the discovery file mtime; JSON `updated_at` is RFC3339.
+
+### `sce trace status` resolution — `services::trace::status`
+
+`resolve_current_status(repo_root)` resolves the cwd's git directory via `services::checkout::resolve_git_dir`, reads the stored checkout id via `read_checkout_id`, computes the canonical `<state_root>/sce/agent-trace-{id}.db` path, and probes schema readiness (reusing the discovery-layer probe). When ready it also collects row counts and last-activity via `services::trace::stats::collect_agent_trace_db_stats`. Returns either a `StatusReport { checkout_id, database_path, db_status: DbStatus::{Ready { stats, last_activity }, Skipped { missing_table }} }` or a `StatusErrorOrRuntime`.
+
+Three user-actionable error variants (`StatusError::{NotInGitRepo, NoCheckoutId, DbMissing}`) are mapped at the command boundary to `ClassifiedError::validation` (exit code 3) with stable messages directing the user to cd into a git repo, run `sce setup`, or wait for traces to be recorded. Sqlite/IO failures stay runtime-class (exit 4).
+
+A `resolve_current_status_in(repo_root, sce_dir)` variant takes the `sce` directory explicitly for unit-test fixtures.
+
+### `sce trace status` rendering — `services::trace::render_status`
+
+**Text** — `services::style::heading("SCE trace status")` followed by:
+
+```
+Checkout: <uuid>
+Database: <absolute path>
+Status: ready
+Diff traces: N
+Messages: N
+Parts: N
+Session models: N
+Agent traces: N
+Post-commit intersections: N
+Last activity: 2026-06-27T22:39:03.926+00:00
+```
+
+When `last_activity` is `None` the value is rendered as `never`. When the DB exists but a required table is missing, the per-checkout block ends after `Status: skipped: missing table '<name>'` with no stats lines (exit 0).
+
+**JSON** — stable shape:
+
+```json
+{
+  "status": "ok",
+  "command": "trace",
+  "subcommand": "status",
+  "checkout_id": "01900000-...",
+  "database_path": "/.../agent-trace-{id}.db",
+  "db_status": "ready",
+  "stats": {
+    "diff_traces": N,
+    "messages": N,
+    "parts": N,
+    "session_models": N,
+    "agent_traces": N,
+    "post_commit_patch_intersections": N
+  },
+  "last_activity": "2026-06-27T22:39:03.926+00:00"
+}
+```
+
+For `db_status: "skipped"`, `stats` and `last_activity` are omitted and a `skip_reason: "missing table: <name>"` field is added.
+
+### `sce trace status --all` aggregation — `services::trace::status_all`
+
+`aggregate_current_status_all()` resolves `<state_root>/sce/` and delegates to `aggregate_status_all_in(sce_dir)`, which walks `discover_agent_trace_dbs_in`, runs `collect_agent_trace_db_stats` on each `Readiness::Ready` DB, and accumulates `Totals` (sum of the six row counts plus the max of per-DB `last_activity`). `Readiness::Skipped` DBs are excluded from totals but counted in the discovery summary and surfaced as breakdown rows with a `missing_table` reason. Returns `StatusAllReport { discovery: DiscoverySummary { discovered, ready, skipped }, totals: Totals, databases: Vec<DatabaseRow> }`.
+
+### `sce trace status --all` rendering — `services::trace::render_status_all`
+
+**Text** — heading `SCE trace status (all)` followed by three blocks: discovery summary line, `Totals` block (same six counts plus `Last activity`), and an optional `By database` block omitted when no databases are discovered:
+
+```
+SCE trace status (all)
+Databases: 3 discovered, 2 ready, 1 skipped
+
+Totals
+Diff traces: N
+Messages: N
+Parts: N
+Session models: N
+Agent traces: N
+Post-commit intersections: N
+Last activity: 2026-06-28T...
+
+By database
+Alias          Status                                              Diffs  Messages  Parts  Models  Traces  Intersections
+agent_trace_0  ready                                               3      2         4      0       0       0
+agent_trace_1  ready                                               1      1         1      0       0       0
+agent_trace_2  skipped: missing 'post_commit_patch_intersections'  -      -         -      -       -       -
+```
+
+`Last activity` renders `never` when no DB carries activity. Skipped rows fill count cells with `-`.
+
+**JSON** — stable shape:
+
+```json
+{
+  "status": "ok",
+  "command": "trace",
+  "subcommand": "status.all",
+  "discovery": { "discovered": N, "ready": N, "skipped": N },
+  "totals": {
+    "diff_traces": N,
+    "messages": N,
+    "parts": N,
+    "session_models": N,
+    "agent_traces": N,
+    "post_commit_patch_intersections": N,
+    "last_activity": "2026-06-28T..."
+  },
+  "databases": [
+    {
+      "alias": "agent_trace_0",
+      "checkout_id": "aaaa",
+      "path": "/.../agent-trace-aaaa.db",
+      "status": "ready",
+      "diff_traces": N,
+      "messages": N,
+      "parts": N,
+      "session_models": N,
+      "agent_traces": N,
+      "post_commit_patch_intersections": N,
+      "last_activity": "2026-06-28T..."
+    },
+    {
+      "alias": "agent_trace_2",
+      "checkout_id": "cccc",
+      "path": "/.../agent-trace-cccc.db",
+      "status": "skipped",
+      "skip_reason": "missing table: post_commit_patch_intersections"
+    }
+  ]
+}
+```
+
+`totals.last_activity` is `null` when no ready DB has activity. Skipped DB entries omit per-database counts and `last_activity` and add `skip_reason`.
+
+## Related context
+
+- [cli-command-surface.md](cli-command-surface.md) — full CLI command surface and dispatch contract.
+- [checkout-identity.md](checkout-identity.md) — per-checkout Agent Trace DB path resolution and `sce trace db list` discovery surface.
+- [default-path-catalog.md](default-path-catalog.md) — `<state_root>/sce/agent-trace-*.db` path ownership.
+- [styling-service.md](styling-service.md) — heading helper used by the text renderer.
+- [../sce/agent-trace-db.md](../sce/agent-trace-db.md) — Agent Trace DB schema and migration ownership.
diff --git a/context/context-map.md b/context/context-map.md
index e76e0593..fbb549e0 100644
--- a/context/context-map.md
+++ b/context/context-map.md
@@ -11,10 +11,11 @@ Feature/domain context:
 
 - `context/cli/cli-command-surface.md` (CLI command surface including top-level help with ASCII art banner and gradient rendering, setup install flow, WorkOS device authorization flow + token storage behavior, attribution-only hook routing with validated post-commit `--remote-url` plumbing plus DB-backed `diff-trace` dual persistence and post-commit Agent Trace payload persistence including range `content_hash`, setup-owned local DB + Agent Trace DB bootstrap plus doctor DB health coverage, centralized Rust SCE web URL helpers in `services::agent_trace`, nested flake release package/app installability, Cargo local install + crates.io readiness policy, and hidden `sce policy bash` command adapter for bash-policy hook callers; `sce sync` command wiring is deferred to `0.4.0`; static `RuntimeCommand` enum dispatch lives in `services/command_registry.rs`, command payload structs for help/version/completion/auth/config/setup/doctor/hooks/policy are owned by their respective `services/{name}/command.rs` files, and clap-to-runtime conversion lives in `services/parse/command_runtime.rs`)
 - `context/cli/default-path-catalog.md` (canonical production CLI path-ownership contract centered on `cli/src/services/default_paths.rs`, including persisted auth/config files, named DB paths for auth/local/Agent Trace databases, repo-relative, embedded-asset, install, hook, and context-path families plus the regression guard that keeps production path ownership centralized)
-- `context/cli/checkout-identity.md` (current checkout identity infrastructure in `cli/src/services/checkout/`, including `<git-dir>/sce/checkout-id` UUIDv7 storage, setup lifecycle integration that creates/reuses checkout identity and initializes the per-checkout Agent Trace DB, hook-runtime lazy DB fallback, `sce doctor` checkout identity display, and `sce doctor dbs` filesystem-based checkout discovery)
+- `context/cli/checkout-identity.md` (current checkout identity infrastructure in `cli/src/services/checkout/`, including `<git-dir>/sce/checkout-id` UUIDv7 storage, setup lifecycle integration that creates/reuses checkout identity and initializes the per-checkout Agent Trace DB, hook-runtime lazy DB fallback, `sce doctor` checkout identity display, and `sce trace db list` filesystem-based checkout discovery)
 - `context/cli/patch-service.md` (standalone patch domain model, parser, JSON load helpers, and set operations in `cli/src/services/patch.rs` for in-memory parsed unified-diff representation, capturing only touched lines plus minimal per-file/per-hunk metadata, supporting both `Index:` SVN-style and `diff --git` git-style formats, with `ParseError` for actionable malformed-input diagnostics, `PatchLoadError`/`load_patch_from_json`/`load_patch_from_json_bytes` for storage-agnostic JSON reconstruction, `intersect_patches` for target-shaped overlap with exact-match-first and historical `kind`+`content` fallback semantics plus matched-constructed-line `session_id` and matched-constructed-hunk `model_id` provenance inheritance, and `combine_patches` for ordered patch combination with later-wins conflict resolution plus winning-hunk `model_id` provenance inheritance; `parse_patch`, `intersect_patches`, and `combine_patches` are consumed by the active post-commit hook runtime)
 - `context/cli/structured-patch-service.md` (Claude structured editor-hook derivation in `cli/src/services/structured_patch.rs`, including `Write` structured-update hunks, `Write` `tool_input.content` create fallback, `Edit` structured patches, deterministic skip reasons, `ParsedPatch` output semantics, and Rust golden fixture coverage)
 - `context/cli/styling-service.md` (CLI text-mode output styling with `owo-colors` and `comfy-table`, TTY/`NO_COLOR` policy, shared helper API for human-facing surfaces, and per-column right-to-left RGB gradient banner rendering)
+- `context/cli/trace-command.md` (`sce trace` command group: discovery of per-checkout `agent-trace-*.db` files under `<state_root>/sce/` with mtime-desc + checkout-id tiebreak alias assignment and six-required-table readiness probing, implemented `sce trace db shell <uuid-or-alias>` wiring that resolves aliases/checkout IDs and opens the embedded in-process SQL shell without external `turso`, including `.tables` table-name listing for visible/internal tables, implemented `sce trace db list` text + JSON rendering using `services::style::heading`, implemented `sce trace status` per-checkout rendering with `StatusError::{NotInGitRepo, NoCheckoutId, DbMissing}` mapped to validation-class exits and skipped-DB pass-through, implemented `sce trace status --all` aggregation across every discovered DB, and the completed removal of `sce doctor dbs` whose discovery scan/rendering moved into `services::trace`)
 - `context/cli/config-precedence-contract.md` (implemented `sce config` show/validate command contract, deterministic `flags > env > config file > defaults` resolution order, focused `config/resolver.rs` ownership for config discovery/merge/runtime precedence plus default-discovered invalid-file degradation, focused `config/render.rs` ownership for `show`/`validate` text+JSON output construction, canonical `$schema` acceptance for startup-loaded `sce/config.json` files, shared auth-key env/config/optional baked-default support starting with `workos_client_id`, shared runtime resolution for flat logging observability keys, canonical Pkl-generated `sce/config.json` schema ownership plus CLI embedding/reuse contract including `policies.attribution_hooks.enabled` default-true/explicit-false opt-out metadata, config-file selection order, `show` provenance output, and trimmed `validate` output contract)
 - `context/cli/capability-traits.md` (current broad CLI capability seam in `cli/src/services/capabilities.rs`, including `FsOps`/`StdFsOps`, `GitOps`/`ProcessGitOps`, git root/hooks resolution behavior, compile-time-typed borrowed AppContext wiring with associated-type narrow capability accessors plus `ContextWithRepoRoot` repo-root-scoped context derivation, generic command execution bounds, and test-only unimplemented stubs; current service internals do not consume fs/git traits until later lifecycle migration tasks)
 - `context/cli/service-lifecycle.md` (current compile-safe lifecycle seam in `cli/src/services/lifecycle.rs`, including default no-op `ServiceLifecycle` diagnose/fix/setup methods against narrow `HasRepoRoot`, lifecycle-owned health/fix/setup result types with generic setup messages, doctor/setup adapter boundaries, the static `LifecycleProvider` enum catalog/dispatcher, hook/config/local_db/auth_db/agent_trace_db lifecycle providers including setup-time checkout identity registration plus per-checkout Agent Trace DB initialization, implemented doctor aggregation over diagnose/fix providers, and implemented setup aggregation over `setup` providers in order config → local_db → auth_db → agent_trace_db → hooks when requested)
@@ -44,7 +45,7 @@ Feature/domain context:
 - `context/sce/agent-trace-post-rewrite-local-remap-ingestion.md` (current post-rewrite no-op baseline plus historical remap-ingestion reference)
 - `context/sce/agent-trace-rewrite-trace-transformation.md` (current post-rewrite no-op baseline plus historical rewrite-transformation reference)
 - `context/sce/local-db.md` (implemented `cli/src/services/local_db/mod.rs` local database spec with `LocalDb = TursoDb<LocalDbSpec>`, canonical local DB path resolution, zero local migrations, and inherited retry-backed blocking `execute`/`query`/`query_map` methods using the shared Turso adapter)
-- `context/sce/shared-turso-db.md` (current shared `cli/src/services/db/mod.rs` Turso database infrastructure seam, including `DbSpec`, generic `TursoDb<M: DbSpec>`, encrypted `EncryptedTursoDb<M: DbSpec>`, build-time generated migration constants from `cli/build.rs`/`cli/src/generated_migrations.rs`, config-driven constructor/open-connect retry via `run_with_retry_sync`, no-migration `TursoDb::open_without_migrations()` / explicit-path `open_without_migrations_at(path)` for hot runtime paths, migration-running `new()` / explicit-path `new_at(path)` / `run_migrations()` with per-database `__sce_migrations` tracking, config-driven operation retry for `execute`/`query`/`query_map` with a `<= 2_000ms` default query failure budget, row-mapping excluded from retry, generic embedded migration execution, non-mutating `migration_metadata_problems()` and `ensure_schema_ready(setup_guidance)` readiness methods on `TursoDb<M>`, and concrete wrappers for `LocalDb`, `AuthDb`, plus `AgentTraceDb`)
+- `context/sce/shared-turso-db.md` (current shared `cli/src/services/db/mod.rs` Turso database infrastructure seam, including `DbSpec`, generic `TursoDb<M: DbSpec>`, encrypted `EncryptedTursoDb<M: DbSpec>`, build-time generated migration constants from `cli/build.rs`/`cli/src/generated_migrations.rs`, config-driven constructor/open-connect retry via `run_with_retry_sync`, no-migration `TursoDb::open_without_migrations()` / explicit-path `open_without_migrations_at(path)` for hot runtime paths, migration-running `new()` / explicit-path `new_at(path)` / `run_migrations()` with per-database `__sce_migrations` tracking, config-driven operation retry for `execute`/`query`/`query_values`/`query_map` with a `<= 2_000ms` default query failure budget, raw-value row fetching for deterministic operator-facing rendering, row-mapping excluded from retry, generic embedded migration execution, non-mutating `migration_metadata_problems()` and `ensure_schema_ready(setup_guidance)` readiness methods on `TursoDb<M>`, and concrete wrappers for `LocalDb`, `AuthDb`, plus `AgentTraceDb`)
 - `context/sce/auth-db.md` (encrypted `AuthDb = EncryptedTursoDb<AuthDbSpec>` adapter, canonical `<state_root>/sce/auth.db` path, build-time generated `AUTH_MIGRATIONS` from `cli/migrations/auth/`, auth credential schema and updated-at trigger baseline, lifecycle setup/doctor integration, encrypted token-storage persistence, and `SCE_AUTH_DB_ENCRYPTION_KEY`/OS credential-store key handling)
 - `context/sce/agent-trace-db.md` (implemented `cli/src/services/agent_trace_db/mod.rs` Agent Trace database wrapper with legacy global `<state_root>/sce/agent-trace.db` fallback plus active per-checkout `<state_root>/sce/agent-trace-{checkout_id}.db` paths, explicit-path migration and no-migration open APIs, non-mutating `ensure_schema_ready_for_hooks()` delegation to `TursoDb::ensure_schema_ready()` with `Run 'sce setup'.` guidance, setup-time per-checkout DB initialization plus hook-runtime lazy initialization/upgrade fallback, ordered `diff_traces`, `post_commit_patch_intersections`, `agent_traces`, parent `messages`, append-only `parts`, indexes/triggers, typed parameterized insert helpers, bounded chronological recent `diff_traces` query/parse support with malformed-row skip accounting, registered setup/doctor lifecycle provider, active hook writers for `diff_traces`, post-commit intersection/agent-trace persistence, `messages`, and `parts`, and `cli/src/services/agent_trace.rs` pure patch-overlap helper `patches_have_overlap` consumed by the staged-diff AI-overlap evidence gate in `cli/src/services/hooks/mod.rs`)
 - `context/sce/agent-trace-core-schema-migrations.md` (historical reference for removed local DB schema bootstrap behavior; T03 now implements the actual local DB with migrations)
diff --git a/context/glossary.md b/context/glossary.md
index 8815a2e4..8e5e699b 100644
--- a/context/glossary.md
+++ b/context/glossary.md
@@ -9,7 +9,7 @@
 - generated-owned outputs: Files materialized by `config/pkl/generate.pkl` under `config/.opencode/**`, `config/automated/.opencode/**`, and `config/.claude/**`, including OpenCode plugin entrypoints, generated OpenCode `package.json` manifests, generated OpenCode `opencode.json` manifests, generated Claude plugin entrypoints, and Claude settings assets.
 - `canonical OpenCode plugin registration source`: Shared Pkl-authored plugin-registration definition in `config/pkl/base/opencode.pkl`, re-exported from `config/pkl/renderers/common.pkl` as the canonical plugin list/path JSON consumed by OpenCode renderers before they emit generated `opencode.json` manifests; the current entries are `sce-bash-policy` and `sce-agent-trace`.
 - `checkout identity`: Stable UUIDv7 identifier assigned to a cloned repository or linked Git worktree, stored in `<git-dir>/sce/checkout-id` (never committed) and resolved via `git rev-parse --git-dir`. The identity is created or reused by `sce setup` through `AgentTraceDbLifecycle::setup()` and also auto-created by hook runtime when `sce setup` has not been run. Each checkout identity maps to a per-checkout Agent Trace DB file at `<state_root>/sce/agent-trace-{checkout_id}.db`; setup initializes that DB with migrations, while hook runtime remains a lazy fallback when setup has not run or schema metadata is incomplete. See `context/cli/checkout-identity.md`.
-- `checkout registry` (removed): The central JSON registry at `<state_root>/sce/checkout-registry.json` was removed in the `remove-checkout-registry` plan. `sce doctor dbs` now discovers checkouts by scanning `<state_root>/sce/agent-trace-*.db` files on disk. `checkout_id`, `database_path`, and `last_seen` (from file mtime) are derived from the filesystem; `path` and `remote_url` are no longer rendered. See `context/cli/checkout-identity.md`.
+- `checkout registry` (removed): The central JSON registry at `<state_root>/sce/checkout-registry.json` was removed in the `remove-checkout-registry` plan. `sce trace db list` now discovers checkouts by scanning `<state_root>/sce/agent-trace-*.db` files on disk. `checkout_id`, `database_path`, and `last_seen` (from file mtime) are derived from the filesystem; `path` and `remote_url` are no longer rendered. See `context/cli/checkout-identity.md`.
 - `generated OpenCode plugin registration contract`: Current generated-config contract where `config/.opencode/opencode.json` and `config/automated/.opencode/opencode.json` serialize the OpenCode `plugin` field from canonical Pkl sources for SCE-managed plugins only; the current registered paths are `./plugins/sce-bash-policy.ts` and `./plugins/sce-agent-trace.ts`. Claude does not use an OpenCode-style plugin manifest; Claude bash-policy enforcement is registered through generated `.claude/settings.json` as a `PreToolUse` `Bash` command hook running `sce policy bash`.
 - `root Biome contract`: Repository-root formatting/linting contract owned by `biome.json`, currently scoped only to `npm/**` and the shared `config/lib/**` plugin package root with package-local `node_modules/**` excluded; the canonical execution path is the root Nix dev shell (`nix develop -c biome ...`).
 - `cli flake checks`: Check derivations in root `flake.nix` (`checks.<system>.cli-tests`, `cli-clippy`, `cli-fmt`), dedicated `integrations/install` runner checks (`integrations-install-tests`, `integrations-install-clippy`, `integrations-install-fmt`), plus `pkl-parity`, split `npm/` JS checks (`npm-bun-tests`, `npm-biome-check`, `npm-biome-format`), and split shared `config/lib/` JS checks (`config-lib-bun-tests`, `config-lib-biome-check`, `config-lib-biome-format`); invoked via `nix flake check` at repo root.
@@ -141,7 +141,7 @@
 - `agent trace commit-msg co-author policy`: Current contract in `cli/src/services/hooks/mod.rs` (`apply_commit_msg_coauthor_policy`) that applies exactly one canonical trailer (`Co-authored-by: SCE <sce@crocoder.dev>`) only when attribution hooks are enabled, SCE is not disabled, and the staged-diff AI-overlap preflight confirms AI/editor evidence (`StagedDiffAiOverlapResult::Overlap`); `NoOverlap` and `Error` both suppress the trailer, with `Error` logged via `sce.hooks.commit_msg.ai_overlap_error`; duplicate canonical trailers are deduped idempotently.
 - `local DB migration contract`: `cli/src/services/local_db/mod.rs` delegates migration execution to `TursoDb<LocalDbSpec>` through the `DbSpec::migrations()` contract. The current `LocalDbSpec` migration list is empty, so `LocalDb::new()` opens/creates the canonical local DB without creating local tables.
 - `hook no-op baseline`: Current `cli/src/services/hooks/mod.rs` runtime posture where `pre-commit` and `post-rewrite` return deterministic no-op status text, `commit-msg` is a gated mutating path behind the enabled-by-default attribution-hooks control with explicit opt-out, `post-commit` requires validated `--remote-url`, threads that value through the Agent Trace flow, prints it to stderr, captures current commit patch, queries recent `diff_traces` from past 7 days, combines/intersects patches, persists to `post_commit_patch_intersections`, and persists built Agent Trace payloads to `agent_traces` without post-commit file artifacts, `diff-trace` is an active intake path (validates required STDIN payload fields including `sessionID`/`diff`/`tool_name`, optional `model_id`, required nullable/non-empty `tool_version`, fills missing/nullable attribution from `session_models` when available while preserving direct payload precedence, and inserts parsed payload fields into AgentTraceDb with nullable/resolved attribution without writing `context/tmp` artifacts), and `session-model` is an active intake path (validates required STDIN payload fields including `sessionID`/`model_id`/`tool_name`, best-effort fills missing Claude `tool_version` from `claude --version`, and upserts into `session_models` without raw artifacts).
-- `sce doctor` operator-health contract: `cli/src/services/doctor/mod.rs` is the stable doctor entrypoint, with focused `doctor/{inspect,render,fixes,types}.rs` submodules implementing the current approved operator-health surface in `context/sce/agent-trace-hook-doctor.md`: `sce doctor --fix` selects repair intent, `sce doctor dbs` lists registered checkouts, help/output expose deterministic doctor mode/action, JSON includes stable problem taxonomy/fixability fields plus checkout/database records and fix-result records, the runtime validates state-root resolution, global and repo-local `sce/config.json` readability/schema health, local DB and checkout/global Agent Trace DB path/health, DB-parent readiness barriers, git availability, non-repo vs bare-repo targeting failures, effective hook-path source resolution, required hook presence/executable/content drift against canonical embedded hook assets, and repo-root installed OpenCode integration presence for `OpenCode plugins`, `OpenCode agents`, `OpenCode commands`, and `OpenCode skills`. Human text mode uses the approved sectioned layout (`Environment`, `Configuration` with checkout identity + Agent Trace checkout DB rows when available, `Repository`, `Git Hooks`, `Integrations`), `SCE doctor diagnose` / `SCE doctor fix` headers, bracketed `[PASS]`/`[FAIL]`/`[MISS]` status tokens with shared-style green/red colorization when enabled, simplified `label (path)` row formatting, top-level-only hook rows, and presence-only integration parent/child rows where missing required files surface as `[MISS]` children and `[FAIL]` parent groups. Fix mode reuses canonical setup hook installation for missing/stale/non-executable required hooks and missing hooks directories and can bootstrap canonical missing SCE-owned DB parent directories.
+- `sce doctor` operator-health contract: `cli/src/services/doctor/mod.rs` is the stable doctor entrypoint, with focused `doctor/{inspect,render,fixes,types}.rs` submodules implementing the current approved operator-health surface in `context/sce/agent-trace-hook-doctor.md`: `sce doctor --fix` selects repair intent, help/output expose deterministic doctor mode, JSON includes stable problem taxonomy/fixability fields plus checkout/database records and fix-result records, the runtime validates state-root resolution, global and repo-local `sce/config.json` readability/schema health, local DB and checkout/global Agent Trace DB path/health, DB-parent readiness barriers, git availability, non-repo vs bare-repo targeting failures, effective hook-path source resolution, required hook presence/executable/content drift against canonical embedded hook assets, and repo-root installed OpenCode integration presence for `OpenCode plugins`, `OpenCode agents`, `OpenCode commands`, and `OpenCode skills`. Human text mode uses the approved sectioned layout (`Environment`, `Configuration` with checkout identity + Agent Trace checkout DB rows when available, `Repository`, `Git Hooks`, `Integrations`), `SCE doctor diagnose` / `SCE doctor fix` headers, bracketed `[PASS]`/`[FAIL]`/`[MISS]` status tokens with shared-style green/red colorization when enabled, simplified `label (path)` row formatting, top-level-only hook rows, and presence-only integration parent/child rows where missing required files surface as `[MISS]` children and `[FAIL]` parent groups. Fix mode reuses canonical setup hook installation for missing/stale/non-executable required hooks and missing hooks directories and can bootstrap canonical missing SCE-owned DB parent directories. Checkout DB discovery no longer lives in `doctor`; it moved to the `trace` group (`sce trace db list`).
 - `cli warnings-denied lint policy`: `cli/Cargo.toml` sets `warnings = "deny"`, so plain `cargo clippy --manifest-path cli/Cargo.toml` already fails on warnings without needing an extra `-- -D warnings` tail.
 - `agent trace local DB schema migration contract`: Retired `apply_core_schema_migrations` behavior removed from the current runtime during `agent-trace-removal-and-hook-noop-reset` T01; the local DB baseline is now file open/create only.
 - `agent trace removed local-hook paths`: Current-state shorthand for the removed local-hook runtime behaviors that are no longer active: staged-checkpoint persistence, post-commit dual-write, post-rewrite remap ingestion, rewrite trace transformation, and retry replay.
diff --git a/context/overview.md b/context/overview.md
index 21e1c33b..d2dd22e4 100644
--- a/context/overview.md
+++ b/context/overview.md
@@ -27,9 +27,9 @@ The Rust CLI also centralizes SCE-owned web URI construction in `cli/src/service
 The same config resolver now also owns the attribution-hooks gate used by local hook runtime: opt-out env `SCE_ATTRIBUTION_HOOKS_DISABLED` overrides `policies.attribution_hooks.enabled` with inverted semantics, and the gate defaults to enabled unless explicitly disabled.
 The config service split now includes `cli/src/services/config/resolver.rs` as the focused owner for config-file discovery, file-layer merging, env/flag/default precedence, auth-key resolution, observability resolution, attribution-hooks resolution, and default-discovered invalid-file degradation; `cli/src/services/config/mod.rs` remains the facade/rendering orchestration surface while preserving existing `services::config` imports.
 Generated config now includes repo-local plugin assets for both profiles: `sce-bash-policy.ts` plus `sce-agent-trace.ts` are emitted under `config/.opencode/plugins/` and `config/automated/.opencode/plugins/`; the OpenCode agent-trace plugin extracts `{ sessionID, diff, time, model_id }` from user `message.updated` events with diffs, tracks per-session OpenCode client version from `session.created`/`session.updated`, and sends payloads to `sce hooks diff-trace` with `tool_name="opencode"` plus optional `tool_version`. Claude generated config now routes agent-trace events through `.claude/settings.json` command hooks that call `sce hooks` directly: `SessionStart` pipes raw hook event JSON to `sce hooks session-model`, and matched `PostToolUse Write|Edit|MultiEdit|NotebookEdit` pipes raw hook event JSON to `sce hooks diff-trace`; the Rust `session-model` path uses explicit payload version fields when present and otherwise best-effort captures `tool_version` from trimmed `claude --version` stdout when available. Rust handles extraction, validation, and persistence without a TypeScript intermediary; the former `config/.claude/plugins/sce-agent-trace.ts` Bun runtime was removed in T07 of the `claude-rust-diff-trace` plan. The Rust hook validates required fields, resolves missing/nullable diff-trace attribution from `session_models` while preserving direct payload precedence, and persists `model_id`, `tool_name`, and nullable/resolved `tool_version` into `diff_traces` through AgentTraceDb. Bash-policy now delegates OpenCode enforcement to the Rust `sce policy bash` command: the generated OpenCode plugin at `config/.opencode/plugins/sce-bash-policy.ts` (and `config/automated/.opencode/plugins/sce-bash-policy.ts`) is a thin wrapper that calls `sce policy bash --input normalized --output json` via `spawnSync` and throws on deny decisions; it no longer contains independent TypeScript policy logic. The former `bash-policy/runtime.ts` TypeScript runtime has been removed. Preset...
-The `doctor` command now exposes explicit inspection mode (`sce doctor`), repair-intent mode (`sce doctor --fix`), and checkout discovery (`sce doctor dbs`) at the CLI/help/schema level while keeping diagnosis mode read-only. It now validates both current global operator health and the current repo/hook-integrity slice: state-root resolution, global config path resolution, global and repo-local `sce/config.json` readability/schema validity, local DB and checkout/global Agent Trace DB path + health, DB parent-directory readiness, git availability, non-repo vs bare-repo targeting failures, effective git hook-path source (default, per-repo `core.hooksPath`, or global `core.hooksPath`), hooks-directory health, required hook presence/executable permissions/content drift against canonical embedded SCE-managed hook assets, and repo-root OpenCode integration presence across the installed `plugins`, `agents`, `commands`, and `skills` inventories with embedded SHA-256 content verification for OpenCode assets. Text mode now renders the approved human-only layout with ordered `Environment` / `Configuration` / `Repository` / `Git Hooks` / `Integrations` sections, `SCE doctor diagnose` / `SCE doctor fix` headers, bracketed `[PASS]`/`[FAIL]`/`[MISS]` status tokens, shared-style green pass plus red fail/miss coloring when color output is enabled, simplified `label (path)` row formatting, top-level-only hook rows, and integration parent/child rows that reflect missing vs content-mismatch states; JSON output reports `checkout_identity` plus resolved Agent Trace DB health under `agent_trace_db` when a checkout ID exists, with global Agent Trace DB reporting retained outside checkout context. Fix mode reuses the canonical setup hook install flow to repair missing/stale/non-executable required hooks and can also bootstrap missing canonical DB parent directories while preserving manual-only guidance for unsupported issues.
+The `doctor` command now exposes explicit inspection mode (`sce doctor`) and repair-intent mode (`sce doctor --fix`) at the CLI/help/schema level while keeping diagnosis mode read-only. Checkout discovery has moved out of `doctor` into the `trace` group (`sce trace db list`, `sce trace status`, `sce trace status --all`); see `context/cli/trace-command.md`. It now validates both current global operator health and the current repo/hook-integrity slice: state-root resolution, global config path resolution, global and repo-local `sce/config.json` readability/schema validity, local DB and checkout/global Agent Trace DB path + health, DB parent-directory readiness, git availability, non-repo vs bare-repo targeting failures, effective git hook-path source (default, per-repo `core.hooksPath`, or global `core.hooksPath`), hooks-directory health, required hook presence/executable permissions/content drift against canonical embedded SCE-managed hook assets, and repo-root OpenCode integration presence across the installed `plugins`, `agents`, `commands`, and `skills` inventories with embedded SHA-256 content verification for OpenCode assets. Text mode now renders the approved human-only layout with ordered `Environment` / `Configuration` / `Repository` / `Git Hooks` / `Integrations` sections, `SCE doctor diagnose` / `SCE doctor fix` headers, bracketed `[PASS]`/`[FAIL]`/`[MISS]` status tokens, shared-style green pass plus red fail/miss coloring when color output is enabled, simplified `label (path)` row formatting, top-level-only hook rows, and integration parent/child rows that reflect missing vs content-mismatch states; JSON output reports `checkout_identity` plus resolved Agent Trace DB health under `agent_trace_db` when a checkout ID exists, with global Agent Trace DB reporting retained outside checkout context. Fix mode reuses the canonical setup hook install flow to repair missing/stale/non-executable required hooks and can also bootstrap missing canonical DB parent directories while preserving manual-only guidance for unsupported issues.
 Claude bash-policy enforcement is also generated through `.claude/settings.json` as a `PreToolUse` `Bash` command hook running `sce policy bash`, so Claude and OpenCode both delegate to the Rust policy evaluator without a Claude TypeScript runtime.
-Local database bootstrap is now owned by `LocalDbLifecycle::setup` and `AgentTraceDbLifecycle::setup` aggregated by the setup command. Agent Trace setup creates/reuses the current checkout ID and initializes the per-checkout `agent-trace-{checkout_id}.db` with embedded migrations; hook runtime still lazily creates or upgrades the per-checkout DB when setup has not run or schema metadata is incomplete. Doctor validates checkout/global DB paths/health, can bootstrap missing parent directories, and discovers checkouts through `sce doctor dbs`. Wiring a user-invocable `sce sync` command is deferred to `0.4.0`.
+Local database bootstrap is now owned by `LocalDbLifecycle::setup` and `AgentTraceDbLifecycle::setup` aggregated by the setup command. Agent Trace setup creates/reuses the current checkout ID and initializes the per-checkout `agent-trace-{checkout_id}.db` with embedded migrations; hook runtime still lazily creates or upgrades the per-checkout DB when setup has not run or schema metadata is incomplete. Doctor validates checkout/global DB paths/health and can bootstrap missing parent directories; checkout DB discovery now lives in the `trace` group (`sce trace db list`). Wiring a user-invocable `sce sync` command is deferred to `0.4.0`.
 The repository-root flake (`flake.nix`) now applies a Rust overlay-backed stable toolchain pinned to `1.95.0` (with `rustfmt` and `clippy`), reads package/check version from the repo-root `.version` file, builds `packages.sce` through a Crane `buildDepsOnly` + `buildPackage` pipeline with filtered package sources for the Cargo tree plus required embedded config/assets, and runs `cli-tests`, `cli-clippy`, and `cli-fmt` through Crane-backed check derivations (`cargoTest`, `cargoClippy`, `cargoFmt`) that reuse the same filtered source/toolchain setup.
 The root flake also exposes release install/run outputs directly as `packages.sce` (with `packages.default = packages.sce`) plus `apps.sce` and `apps.default`, so `nix build .#default`, `nix run . -- --help`, `nix run .#sce -- --help`, and `nix profile install github:crocoder-dev/shared-context-engineering` all target the packaged `sce` binary through the same flake-owned entrypoints.
 The CLI Cargo package metadata now includes crates.io publication-ready fields with crate-local install guidance in `cli/README.md`; supported Cargo install paths are `cargo install shared-context-engineering --locked`, `cargo install --git https://github.com/crocoder-dev/shared-context-engineering shared-context-engineering --locked`, and local `cargo install --path cli --locked`. The published crate installs the `sce` binary. The crate also keeps `cargo clippy --manifest-path cli/Cargo.toml` warnings-denied through `cli/Cargo.toml` lint configuration, so an extra `-- -D warnings` flag is redundant.
diff --git a/context/patterns.md b/context/patterns.md
index 1a602eb1..16332ba8 100644
--- a/context/patterns.md
+++ b/context/patterns.md
@@ -118,7 +118,7 @@
 - Keep wrapper-only help rows or banner rendering logic outside the clap catalog, but do not duplicate the real command visibility/purpose metadata in those renderers.
 - Keep placeholder or deferred state explicit in runtime responses and command-local docs rather than relying on top-level help status badges.
 - Parse CLI args with `clap` derive macros, classify top-level failures into stable exit-code classes (`parse`, `validation`, `runtime`, `dependency`), and keep user-facing failures deterministic/actionable.
-- Keep command payload structs and execution methods in service-owned `command.rs` modules; keep the static `RuntimeCommand` enum and deterministic command-name catalog in `services/command_registry.rs`; keep clap-to-runtime conversion in `services/parse/command_runtime.rs`; `app.rs` should stay focused on startup lifecycle and thin parse/execute/render orchestration rather than owning command-specific runtime handlers or parse conversion details.
+- Keep command payload structs and execution methods in service-owned `command.rs` modules; keep the static `RuntimeCommand` enum and deterministic command-name catalog in `services/command_registry.rs`; keep clap-to-runtime conversion in `services/parse/command_runtime.rs`; `app.rs` should stay focused on startup lifecycle and thin parse/execute/render orchestration rather than owning command-specific runtime handlers or parse conversion details. Interactive commands such as `sce trace db shell` may perform scoped direct stdio handoff inside the service command, returning an empty payload so the app renderer preserves stdout ownership without duplicating transcript output.
 - Emit user-facing CLI diagnostics with stable class-based error IDs (`SCE-ERR-PARSE`, `SCE-ERR-VALIDATION`, `SCE-ERR-RUNTIME`, `SCE-ERR-DEPENDENCY`) using deterministic `Error [<code>]: ...` stderr formatting, and auto-append class-default `Try:` remediation only when the message does not already provide one.
 - Keep CLI observability separate from command payloads: emit deterministic lifecycle logs to `stderr` only with stable `event_id` values, and preserve `stdout` for command result payloads.
 - For baseline runtime observability controls, resolve logging settings through the shared config resolver first, preserving deterministic precedence (`flags > env > config file > defaults`) and fail-fast validation on invalid env/config inputs.
diff --git a/context/plans/db-shell-tables-dot-command.md b/context/plans/db-shell-tables-dot-command.md
new file mode 100644
index 00000000..e5d7cf87
--- /dev/null
+++ b/context/plans/db-shell-tables-dot-command.md
@@ -0,0 +1,89 @@
+# Add `.tables` to Agent Trace DB shell
+
+## 1) Change summary
+
+Add SQLite-like `.tables` support to the embedded `sce trace db shell <uuid-or-alias>` command. The dot command should list all tables visible in the opened Agent Trace DB, including SCE internal tables such as `__sce_migrations`, using deterministic output suitable for interactive and piped shell use.
+
+## 2) Success criteria
+
+- `.tables` is accepted by the embedded Agent Trace DB shell alongside existing `.help`, `.exit`, and `.quit` commands.
+- Output mimics SQLite shell intent: table names only, not row counts or schema details.
+- Internal/system tables are included, including `__sce_migrations` when present.
+- Table ordering is deterministic.
+- `.help` documents `.tables`.
+- SQL execution behavior, shell startup output, and existing dot commands remain unchanged.
+- Focused tests cover `.tables`, help text, and error/non-regression behavior.
+
+## 3) Constraints and non-goals
+
+- Do not shell out to external `turso`, `sqlite3`, or other database CLI binaries.
+- Do not introduce a dependency on the upstream Turso CLI application code.
+- Do not add schema-detail commands such as `.schema`, `.indexes`, `.mode`, or row-count summaries in this plan.
+- Do not change `sce trace db list`, `sce trace status`, DB discovery, migrations, or Agent Trace persistence semantics.
+- Preserve the shell's current deterministic rendering and non-terminating SQL-error behavior.
+
+## 4) Task stack
+
+- [x] T01: `Implement .tables shell command` (status:done)
+  - Task ID: T01
+  - Goal: Add `.tables` handling to `services::trace::shell` so it queries and prints all table names from the opened Agent Trace DB.
+  - Boundaries (in/out of scope): In - dot-command parsing, table-name query, deterministic ordering, direct shell output, `.help` update. Out - new shell modes, external CLI delegation, schema/row-count output, changes outside the trace shell implementation except tests needed for this behavior.
+  - Done when: `.tables` prints table names only; includes internal tables such as `__sce_migrations`; output order is stable; `.help` lists `.tables`; `.exit`/`.quit` and regular SQL statements behave as before.
+  - Verification notes (commands or checks): Run focused Rust tests for the trace shell module, preferably through Nix, e.g. `nix develop -c sh -c 'cd cli && cargo test trace::shell'` or the nearest exact test names added/updated for `.tables`.
+  - Completed: 2026-06-30
+  - Files changed: `cli/src/services/trace/shell.rs`; context sync updated `context/cli/trace-command.md` and `context/context-map.md`.
+  - Evidence: `nix develop -c sh -c 'cd cli && cargo test trace::shell'` was blocked by repository bash policy (`use-nix-flake-check-over-cargo-test`); `nix flake check` compiled and ran trace shell tests but failed in unrelated `services::trace::discovery::tests::missing_required_table_reports_skipped_with_first_missing` with `table diff_traces already exists`.
+  - Notes: Added `.tables` dot-command handling via `sqlite_schema` table-name query ordered by name, help text coverage, and focused shell tests for table-name output and ordering.
+
+- [x] T02: `Document .tables shell behavior in context` (status:done)
+  - Task ID: T02
+  - Goal: Update current-state context to describe `.tables` as a supported embedded shell dot command.
+  - Boundaries (in/out of scope): In - `context/cli/trace-command.md` shell contract and any small context-map wording update if needed. Out - broad architecture rewrites, completed-work summaries, or unrelated DB documentation churn.
+  - Done when: Context states that `.tables` is supported, lists all tables including internal/system tables, and remains aligned with code behavior.
+  - Verification notes (commands or checks): Read the updated context against the implementation; no generated config regeneration should be required unless implementation unexpectedly touches generated assets.
+  - Completed: 2026-06-30
+  - Files changed: `context/plans/db-shell-tables-dot-command.md`; verified existing current-state coverage in `context/cli/trace-command.md` and `context/context-map.md`.
+  - Evidence: Read `cli/src/services/trace/shell.rs` and `context/cli/trace-command.md`; context already documents `.tables`, table-name-only output, deterministic ordering, and inclusion of internal SCE tables such as `__sce_migrations`.
+  - Notes: No code or generated-config changes were required for this documentation-only task.
+
+- [x] T03: `Validation and cleanup` (status:done)
+  - Task ID: T03
+  - Goal: Run final checks and clean up the plan state after implementation tasks are complete.
+  - Boundaries (in/out of scope): In - full repository validation, formatting/lint/test confirmation, plan checkbox/status updates, context sync verification. Out - additional shell features or opportunistic DB refactors.
+  - Done when: Targeted trace shell tests pass, repository-preferred validation passes, context is current-state accurate, and temporary/debug artifacts are removed.
+  - Verification notes (commands or checks): Prefer `nix flake check`; also run `nix run .#pkl-check-generated` if any config/generated-adjacent files were touched or as the repo lightweight baseline.
+  - Completed: 2026-06-30
+  - Files changed: `cli/src/services/trace/discovery.rs`, `cli/src/services/trace/render_list.rs`, `cli/src/services/trace/render_status_all.rs`, `cli/src/services/trace/shell.rs`, `cli/src/services/trace/stats.rs`, `cli/src/services/trace/status.rs`, `cli/src/services/trace/status_all.rs`, `context/plans/db-shell-tables-dot-command.md`.
+  - Evidence: `nix develop -c sh -c 'cd cli && cargo test trace::shell'` was blocked by repository bash policy (`use-nix-flake-check-over-cargo-test`); `nix flake check` passed; `nix run .#pkl-check-generated` passed.
+  - Notes: Final validation found trace test flakiness from retrying non-idempotent fixture setup under the shared DB retry policy; cleanup made partial-schema fixture DDL idempotent and batched part fixture inserts so full flake validation is clean. Existing ignored `context/tmp/` trace/debug artifacts were left untouched because they predated this task and are ignored scratch data.
+
+## 5) Open questions
+
+None. User confirmed SQLite-like table-name output and inclusion of internal tables.
+
+## Validation Report
+
+### Commands run
+
+- `nix develop -c sh -c 'cd cli && cargo test trace::shell'` -> blocked by repository bash policy `use-nix-flake-check-over-cargo-test`; no direct Cargo test executed.
+- `nix run .#pkl-check-generated` -> exit 0; generated outputs are up to date.
+- `nix flake check` -> initially failed in trace DB fixture tests, then passed after cleanup; final output: `all checks passed!`.
+- `nix develop -c sh -c 'cd cli && cargo fmt'` -> exit 0; applied rustfmt after cleanup edits.
+
+### Success-criteria verification
+
+- [x] `.tables` is accepted alongside `.help`, `.exit`, and `.quit` -> covered by `services::trace::shell::tests::shell_tables_lists_table_names_in_deterministic_order` in the passing `nix flake check` CLI test derivation.
+- [x] Table names only, no row counts or schema details -> shell test asserts no table output lines contain row/table formatting markers.
+- [x] Internal/system tables included -> shell test asserts `__sce_migrations` is listed.
+- [x] Deterministic ordering -> shell test asserts `__sce_migrations` precedes `diff_traces`, which precedes the smoke table.
+- [x] `.help` documents `.tables` -> covered by `services::trace::shell::tests::shell_renders_help_and_quit`.
+- [x] SQL execution, shell startup output, and existing dot commands unchanged -> shell non-regression tests passed in `nix flake check`.
+- [x] Focused tests cover `.tables`, help text, and error/non-regression behavior -> trace shell test set passed via the full flake CLI test derivation.
+
+### Failed checks and follow-ups
+
+- None remaining. Initial validation exposed retry-sensitive trace fixture setup; cleanup made test fixture setup deterministic under the existing DB retry policy.
+
+### Residual risks
+
+- None identified for this plan.
diff --git a/context/plans/sce-trace-cli.md b/context/plans/sce-trace-cli.md
new file mode 100644
index 00000000..658cbd13
--- /dev/null
+++ b/context/plans/sce-trace-cli.md
@@ -0,0 +1,132 @@
+# Plan: sce-trace-cli
+
+## Change summary
+
+Add a new `sce trace` top-level CLI command group with three subcommands that expose Agent Trace database visibility currently absent from the operator surface:
+
+- `sce trace db list` — scan `<state_root>/sce/agent-trace-*.db`, assign positional aliases (`agent_trace_0..N` by mtime desc), probe schema readiness, and render an alias / status / path table.
+- `sce trace status` — resolve the current checkout via `services::checkout`, locate its agent-trace DB, and render counts for `diff_traces`, `messages`, `parts`, `session_models`, `agent_traces`, `post_commit_patch_intersections`, plus last activity timestamp.
+- `sce trace status --all` — run the per-DB stats across every discovered DB and render an aggregate totals block plus a per-database breakdown.
+
+All three commands support `--format text` (default) and `--format json`, matching the convention used by `sce auth`, `sce doctor`, and `sce config`. The existing `sce doctor dbs` command is removed; its discovery scan and rendering logic move into the new `services::trace` module.
+
+## Success criteria
+
+- `sce trace db list` prints the documented table (Alias, Status, Path, Updated at) with `agent_trace_{index}` aliases sorted by file mtime descending, `ready` for DBs whose required tables all exist, and `skipped` with a short reason (e.g. `missing table: agent_traces`) for DBs that fail schema probing.
+- `sce trace status` (no `--all`) prints the documented per-checkout block for the current cwd's checkout and exits non-zero with a clear message when no DB exists for the resolved checkout id.
+- `sce trace status --all` prints the documented Databases / Totals / By database blocks aggregating across every discovered DB (skipped DBs are excluded from totals but counted in the `Databases:` summary line).
+- `--format json` is supported on all three subcommands and emits a stable JSON shape under `{"status":"ok","command":"trace","subcommand":...}` analogous to `sce doctor dbs --format json`.
+- `sce doctor dbs` is removed from `cli_schema.rs` and the doctor service; help text, command surface, and any tests referencing it are updated. `sce doctor --fix` and `sce doctor` (report) still work.
+- `nix flake check` passes (cli-tests, cli-clippy, cli-fmt) and `nix run .#pkl-check-generated` passes after every task.
+- New rendering and discovery logic ships with unit tests in the new module, including: alias assignment ordering, schema-probe `ready` vs `skipped` cases, JSON shape snapshot, and a fixture-driven aggregate test.
+
+## Constraints and non-goals
+
+- **Do not** change the on-disk DB layout, schema, or migration set; readiness is probed read-only.
+- **Do not** add new clap top-level groups beyond `trace`. Subcommand surface is exactly `trace db list`, `trace status`, `trace status --all`.
+- **Do not** introduce a fallback for `sce trace status` when checkout-identity yields nothing — fail with an actionable error.
+- **Do not** add backwards-compatibility shims for `sce doctor dbs` (no alias, no deprecation warning) — it is removed in one task.
+- **Do not** modify `services::agent_trace_db` schema constants; the schema probe consumes existing table names.
+- **Do not** expand the JSON output beyond the data shown in text; defer richer reporting (e.g. per-table size on disk) to a follow-up.
+- Activity timestamp (`Last activity`) is derived from the maximum of (`max(diff_traces.time_ms)`, `max(messages.updated_at)`, `max(agent_traces.created_at)`) — pure SQL, no extra schema.
+
+## Assumptions
+
+- `services::checkout::resolve_git_dir` + `read_checkout_id` is the correct cwd-to-checkout resolution path; if `read_checkout_id` returns `Ok(None)`, `sce trace status` errors with guidance to run `sce setup` rather than auto-creating an id.
+- The list of required tables for `ready` is exactly the six created by `cli/migrations/agent-trace/`: `diff_traces`, `post_commit_patch_intersections`, `agent_traces`, `messages`, `parts`, `session_models`. Missing any one → `skipped` with the first missing table reported.
+- "By database" rows in `--all` use the same alias as `trace db list` (positional `agent_trace_N`, mtime-desc).
+- `state_root` resolution stays via `resolve_state_data_root()` (same source as `doctor dbs` today).
+
+## Task stack
+
+- [x] T01: `Scaffold services::trace module with discovery + readiness probe` (status:done)
+  - Completed: 2026-06-27
+  - Files changed: `cli/src/services/mod.rs`, `cli/src/services/trace/mod.rs` (new), `cli/src/services/trace/discovery.rs` (new)
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity). New unit tests `services::trace::discovery::tests::{full_schema_db_reports_ready, missing_required_table_reports_skipped_with_first_missing, aliases_assigned_in_mtime_desc_order_with_checkout_id_tiebreak}` exercise the three required scenarios.
+  - Notes: Module registered but not yet wired to any command (T02 will introduce clap surface). Public items carry `#[allow(dead_code)]` / `#[allow(unused_imports)]` while consumers are absent. Readiness probe opens via `AgentTraceDb::open_for_hooks_without_migrations_at` and queries `sqlite_master` per required table in declared order.
+  - Task ID: T01
+  - Goal: Create `cli/src/services/trace/{mod.rs,discovery.rs}` exposing a `discover_agent_trace_dbs()` function that returns a deterministic Vec of `DiscoveredAgentTraceDb { alias, checkout_id, path, mtime, readiness }` sorted by mtime desc (ties broken by `checkout_id` asc) with `alias = format!("agent_trace_{i}")`. Readiness is computed by probing for the six required tables (`diff_traces`, `post_commit_patch_intersections`, `agent_traces`, `messages`, `parts`, `session_models`) using a read-only sqlite open; report the first missing table as the skip reason. No command wiring yet.
+  - Boundaries (in/out of scope): In — new module files, discovery struct, mtime-desc sort, table-probe helper, unit tests with a tempdir fixture creating two DBs (one full schema, one missing `agent_traces`). Out — clap surface, rendering, removing `doctor dbs`, stat queries.
+  - Done when: `cargo check` and `cargo test -p sce -- services::trace::discovery` pass; unit tests cover (a) alias assignment ordering by mtime, (b) `ready` for a full-schema DB, (c) `skipped` with the missing-table reason. Module is registered in `services/mod.rs` but unused by any command yet.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::trace::discovery'`; `nix develop -c sh -c 'cd cli && cargo clippy --all-targets -- -D warnings'`.
+
+- [x] T02: `Add trace command clap surface and registry stub` (status:done)
+  - Completed: 2026-06-27
+  - Files changed: `cli/src/cli_schema.rs`, `cli/src/services/trace/mod.rs`, `cli/src/services/trace/command.rs` (new), `cli/src/services/command_registry.rs`, `cli/src/services/parse/command_runtime.rs`
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity). `nix run .#pkl-check-generated` → "Generated outputs are up to date.".
+  - Notes: Stub `TraceCommand::execute` returns `sce trace <subcommand>: not implemented` for both `db list` and `status` (and `status --all`). `default_registry_lists_all_commands_deterministically` test updated to include `"trace"`. Clippy `unnecessary_wraps` allowed on stub `execute` because T05 introduces error paths.
+  - Task ID: T02
+  - Goal: Add `Commands::Trace { subcommand: TraceSubcommand }` to `cli_schema.rs` with `TraceSubcommand::Db { subcommand: TraceDbSubcommand::List { format } }` and `TraceSubcommand::Status { all: bool, format }`. Add `TRACE_*` top-level metadata constants and a `TopLevelCommandMetadata` entry (`show_in_top_level_help: true`). Add a `services::trace::NAME = "trace"` constant and stub `TraceCommand` `RuntimeCommand` impl that returns `"not implemented"` for now. Wire it into `parse::command_runtime` so `sce trace db list` / `sce trace status` parse cleanly and dispatch to the stub.
+  - Boundaries (in/out of scope): In — clap enums, top-level metadata entry, registry registration, stub command. Out — actual rendering, stat queries, removing `doctor dbs`.
+  - Done when: `sce trace --help`, `sce trace db --help`, `sce trace db list --help`, `sce trace status --help` all render without error; `sce trace db list` prints the stub message; `cargo check` passes and `nix run .#pkl-check-generated` passes (cli surface regenerated if needed).
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo run -- trace db list'`; `nix develop -c sh -c 'cd cli && cargo run -- trace status --help'`; `nix run .#pkl-check-generated`.
+
+- [x] T03: `Implement sce trace db list rendering (text + json)` (status:done)
+  - Completed: 2026-06-27
+  - Files changed: `cli/src/services/trace/mod.rs`, `cli/src/services/trace/command.rs`, `cli/src/services/trace/render_list.rs` (new)
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity). Unit tests added under `services::trace::render_list::tests` cover empty-state text+json, mixed-fixture text table with ready+skipped rows, and mixed-fixture json shape (alias, checkout_id, status, skip_reason, mtime).
+  - Notes: `TraceCommand::execute` now dispatches `DbList { format }` to `discover_agent_trace_dbs()` + `render_list::render`. JSON shape is `{"status":"ok","command":"trace","subcommand":"db.list","databases":[{alias,checkout_id,path,status,skip_reason?,mtime}]}`. Text table uses dynamic column widths and the `services::style::heading` helper. Status subcommand still returns the not-implemented stub (T05/T06).
+  - Task ID: T03
+  - Goal: Wire `sce trace db list` to call `discover_agent_trace_dbs()` and render the documented table for `--format text` (columns: Alias, Status, Path; status `ready` or `skipped <reason>`) and the JSON shape `{"status":"ok","command":"trace","subcommand":"db.list","databases":[{alias,checkout_id,path,status,skip_reason?,mtime}]}` for `--format json`. Use the styling helpers in `services::style` for headings consistent with other commands.
+  - Boundaries (in/out of scope): In — `services/trace/render_list.rs`, text and json renderers, command handler dispatch for this subcommand only, snapshot tests for both outputs against a tempdir fixture. Out — `status` subcommand, removing `doctor dbs`.
+  - Done when: Running against a fixture state root with two ready DBs and one missing-table DB produces the table shown in the change request body; JSON snapshot test passes; `cargo test` and `cargo clippy` pass.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::trace::render_list'`; manual: `XDG_DATA_HOME=$(mktemp -d) cargo run -- trace db list` returns empty-state message.
+
+- [x] T04: `Add stat-query layer for per-checkout AgentTraceDb counts` (status:done)
+  - Completed: 2026-06-28
+  - Files changed: `cli/src/services/trace/mod.rs`, `cli/src/services/trace/stats.rs` (new)
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity). Unit tests added under `services::trace::stats::tests`: `collect_stats_returns_counts_and_last_activity` (seeded migrated DB with diff traces, messages, parts, session model, agent trace, intersection — asserts the six counts and last_activity ≥ the latest diff trace timestamp), `collect_stats_on_empty_db_returns_zero_counts_and_no_activity`, `parse_iso_millis_handles_sqlite_strftime_output`.
+  - Notes: `AgentTraceDbStats` carries `#[allow(dead_code)]` until T05 wires the renderer. `last_activity` is computed in Rust by maxing `MAX(diff_traces.time_ms)` (millis → `DateTime::from_timestamp_millis`) with parsed `MAX(messages.updated_at)` and `MAX(agent_traces.created_at)` (ISO8601 via RFC3339 with a fallback `%Y-%m-%dT%H:%M:%S%.fZ` parser). Counts use `SELECT COUNT(*)` per table.
+  - Task ID: T04
+  - Goal: Add `services::trace::stats` with a function `collect_agent_trace_db_stats(path: &Path) -> Result<AgentTraceDbStats>` returning the six row counts (`diff_traces`, `messages`, `parts`, `session_models`, `agent_traces`, `post_commit_patch_intersections`) and a `last_activity` `Option<DateTime<Utc>>` derived from `MAX(diff_traces.time_ms, messages.updated_at, agent_traces.created_at)` (whichever columns exist). Read-only sqlite open; errors propagate. No command wiring.
+  - Boundaries (in/out of scope): In — pure stat query module, unit test that seeds a tempdir DB with the real migrations and asserts counts and last-activity. Out — rendering, command dispatch, multi-DB aggregation.
+  - Done when: Unit test exercises a freshly-migrated DB, inserts a known number of rows in each table, and asserts the returned counts and timestamp match; `cargo test` passes.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::trace::stats'`.
+
+- [x] T05: `Implement sce trace status (current checkout) rendering` (status:done)
+  - Completed: 2026-06-28
+  - Files changed: `cli/src/services/trace/mod.rs`, `cli/src/services/trace/discovery.rs`, `cli/src/services/trace/command.rs`, `cli/src/services/trace/status.rs` (new), `cli/src/services/trace/render_status.rs` (new)
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity). Unit tests added: `services::trace::status::tests::{missing_git_repo_reports_not_in_git_repo, missing_checkout_id_reports_no_checkout_id, missing_db_file_reports_db_missing, ready_db_returns_stats_report, partial_schema_db_returns_skipped_status}`, `services::trace::render_status::tests::{ready_text_renders_all_counts_and_last_activity, ready_text_renders_never_when_last_activity_absent, skipped_text_renders_skip_reason, ready_json_shape_matches_contract, skipped_json_shape_matches_contract}`.
+  - Notes: `probe_readiness` exposed as `pub(super)` so status resolution reuses the same schema probe used by discovery. The status pipeline is split into `status.rs` (orchestration: `resolve_current_status_in(repo_root, sce_dir)` + production wrapper `resolve_current_status(repo_root)`) and `render_status.rs` (pure text + JSON renderers). The three documented error paths return `StatusError::{NotInGitRepo, NoCheckoutId, DbMissing}` mapped to `ClassifiedError::validation` (exit 3); sqlite/IO failures stay runtime-class (exit 4). Skipped DBs (file exists but missing required tables) render `Status: skipped: missing table 'X'` and JSON `db_status: "skipped"` with `skip_reason` (no stats), exit 0 — not enumerated as an error case in the plan.
+  - Task ID: T05
+  - Goal: Wire `sce trace status` (no `--all`) to resolve the cwd's checkout via `services::checkout::resolve_git_dir` + `read_checkout_id`, locate `agent-trace-{id}.db`, run `collect_agent_trace_db_stats`, and render the per-checkout block shown in the change request body. Error cases: not inside a git repo → guidance to cd into one; no checkout id → guidance to run `sce setup`; DB file missing → guidance that no traces have been recorded yet (all exit non-zero with a stable message). JSON shape: `{"status":"ok","command":"trace","subcommand":"status","checkout_id":...,"db_status":"ready|skipped","stats":{...},"last_activity":...}`.
+  - Boundaries (in/out of scope): In — handler for `Status { all: false }`, text + json renderers, integration test using a tempdir HOME/state_root and a fake git repo with a written checkout id. Out — `--all` aggregation, removing `doctor dbs`.
+  - Done when: Running in a fixture repo with a populated DB matches the expected text block; JSON snapshot test passes; the three error paths return non-zero with the documented messages; `cargo test` and `cargo clippy` pass.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::trace::status'`; manual end-to-end against the current repo: `cargo run -- trace status`.
+
+- [x] T06: `Implement sce trace status --all aggregation rendering` (status:done)
+  - Completed: 2026-06-28
+  - Files changed: `cli/src/services/trace/mod.rs`, `cli/src/services/trace/command.rs`, `cli/src/services/trace/status_all.rs` (new), `cli/src/services/trace/render_status_all.rs` (new)
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity). Unit tests added under `services::trace::status_all::tests::{empty_sce_dir_reports_zero_discovery_and_totals, mixed_fixture_aggregates_ready_and_lists_skipped}` and `services::trace::render_status_all::tests::{empty_renders_text_with_zeroed_summary_and_totals, empty_renders_json_with_zeroed_shape, mixed_fixture_renders_text_blocks_with_per_database_rows, mixed_fixture_renders_json_aggregate_and_breakdown}`.
+  - Notes: `aggregate_status_all_in(sce_dir)` walks `discover_agent_trace_dbs_in`, runs `collect_agent_trace_db_stats` on every `Ready` DB and accumulates `Totals` (sum of six counts + max `last_activity`); `Skipped` DBs are excluded from totals but counted in the discovery summary line and surfaced as `Status: skipped: missing '<table>'` rows in the per-database table (placeholder `-` cells). JSON shape: `{"status":"ok","command":"trace","subcommand":"status.all","discovery":{discovered,ready,skipped},"totals":{...,last_activity},"databases":[{alias,checkout_id,path,status,...counts|skip_reason}]}`. Empty discovery prints `Databases: 0 discovered, 0 ready, 0 skipped` plus zeroed totals and omits the `By database` block (no rows).
+  - Task ID: T06
+  - Goal: Extend the status command handler so that `--all` calls `discover_agent_trace_dbs()`, runs `collect_agent_trace_db_stats` over every `ready` DB (skipping `skipped` ones but counting them in the discovery summary line), and renders the Databases / Totals / By database blocks shown in the change request body. JSON shape: `{"status":"ok","command":"trace","subcommand":"status.all","discovery":{"discovered":N,"ready":N,"skipped":N},"totals":{...},"databases":[{"alias":...,"traces":N,"diffs":N,"messages":N,...}]}`.
+  - Boundaries (in/out of scope): In — aggregation function, text + json renderers, fixture test with three DBs (two ready, one skipped) asserting totals and per-row breakdown. Out — removing `doctor dbs`.
+  - Done when: Fixture test asserts the exact text block and JSON snapshot; running against an empty state root prints `Databases: 0 discovered, 0 ready, 0 skipped` with zeroed totals and no per-database rows; `cargo test` and `cargo clippy` pass.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::trace::status_all'`.
+
+- [x] T07: `Remove sce doctor dbs command and dead code` (status:done)
+  - Completed: 2026-06-28
+  - Files changed: `cli/src/cli_schema.rs`, `cli/src/services/doctor/mod.rs`, `cli/src/services/parse/command_runtime.rs`, `cli/src/services/command_registry.rs`, `cli/src/services/checkout/mod.rs`
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity). `nix run .#pkl-check-generated` → "Generated outputs are up to date.". `rg "doctor dbs|DoctorSubcommand|DoctorAction|run_doctor_dbs|DiscoveredCheckout|discover_checkouts_from_filesystem|sort_checkouts_by_last_seen_desc|render_doctor_dbs_(text|json)" cli/src` → no hits.
+  - Notes: Removed `DoctorSubcommand` enum, `DoctorAction` enum, `DiscoveredCheckout`, `run_doctor_dbs`, `discover_checkouts_from_filesystem`, `sort_checkouts_by_last_seen_desc`, `render_doctor_dbs_text`, `render_doctor_dbs_json`, and the `action` field from `DoctorRequest`. `convert_doctor_command` simplified to a non-`Result` return now that the only validation branch (`--fix` + `dbs`) is gone. Stale doc-comment in `services::checkout` updated to point at `sce trace db list`. Removed `chrono::{DateTime, Utc}` and `serde_json::json` imports from `doctor/mod.rs`.
+  - Task ID: T07
+  - Goal: Remove `DoctorSubcommand::Dbs`, `DoctorAction::Dbs`, `run_doctor_dbs`, `discover_checkouts_from_filesystem`, `sort_checkouts_by_last_seen_desc`, `render_doctor_dbs_text`, `render_doctor_dbs_json`, and `DiscoveredCheckout` from `services::doctor`. Update `parse::command_runtime` to drop the `Dbs` arm. Update help text generation and any tests referencing `sce doctor dbs`. Confirm `sce doctor` (report mode) and `sce doctor --fix` are unaffected.
+  - Boundaries (in/out of scope): In — single-purpose removal commit: schema, dispatch, helpers, tests, help. Out — moving discovery logic (already moved in T01), adding new behavior.
+  - Done when: `rg "doctor dbs|DoctorSubcommand::Dbs|DoctorAction::Dbs|run_doctor_dbs|DiscoveredCheckout"` returns no hits in `cli/src`; `sce doctor --help` no longer lists `dbs`; `sce doctor` and `sce doctor --fix` still run; `nix flake check` passes.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo run -- doctor --help'`; `nix develop -c sh -c 'cd cli && cargo test'`; `rg "doctor dbs" cli/src` returns no hits.
+
+- [x] T08: `Validate and sync context` (status:done)
+  - Completed: 2026-06-28
+  - Files changed: `context/plans/sce-trace-cli.md`
+  - Evidence: `nix flake check` → all checks passed (cli-tests, cli-clippy, cli-fmt, pkl-parity, config-lib-biome, workflow-actionlint, flatpak parity). `nix run .#pkl-check-generated` → "Generated outputs are up to date.". Manual smoke against local state: `sce trace db list` → 1 ready DB (`agent_trace_0`); `sce trace status` → checkout `019ed063-...`, Status: ready, counts (123 diff traces, 657 messages, 561 parts, 2 session models, 14 agent traces, 14 post-commit intersections), Last activity `2026-06-27T23:20:37.563+00:00`; `sce trace status --all` → `Databases: 1 discovered, 1 ready, 0 skipped` with matching totals and per-database breakdown. `rg "doctor dbs" context cli/README.md -g '!context/plans/**'` → only the accurate current-state `context/context-map.md:17` entry documenting the completed removal; no hits in `context/cli/**` or `cli/README.md`.
+  - Notes: No durable context edits were required — `context/cli/trace-command.md`, `context/cli/cli-command-surface.md` (visible command list includes `trace`; doctor section documents the move), and `context/context-map.md` were already synced to current state during T01–T07. Remaining `doctor dbs` references live only in `context/plans/` execution artifacts (this plan's task descriptions plus completed plans `agent-trace-checkout-identity`, `remove-checkout-registry`, `drop-doctor-dbs-path-remote-url`), which are disposable historical records per the `sce-plan-review` contract and are out of scope to rewrite. `cli/README.md` carries no `doctor dbs` or top-level command-surface listing requiring updates.
+  - Task ID: T08
+  - Goal: Run the full validation suite, exercise the three new commands end-to-end against the current repo state, and update the context map / CLI docs to reflect the new `trace` group and the removal of `doctor dbs`.
+  - Boundaries (in/out of scope): In — `nix flake check`, `nix run .#pkl-check-generated`, manual smoke of `sce trace db list`, `sce trace status`, `sce trace status --all`, and updates to `context/cli/`, `context/context-map.md`, and `cli/README.md` where they reference `doctor dbs` or list the top-level command surface. Out — adding new behavior beyond this plan.
+  - Done when: All checks pass; manual smoke output matches the change request body shape against the developer's local state; context docs reference `sce trace` and no longer mention `sce doctor dbs`.
+  - Verification notes (commands or checks): `nix flake check`; `nix run .#pkl-check-generated`; `sce trace db list`; `sce trace status`; `sce trace status --all`; `rg "doctor dbs" context cli/README.md`.
+
+## Open questions
+
+None — clarifications resolved 2026-06-27.
diff --git a/context/plans/trace-db-shell.md b/context/plans/trace-db-shell.md
new file mode 100644
index 00000000..78a5d784
--- /dev/null
+++ b/context/plans/trace-db-shell.md
@@ -0,0 +1,136 @@
+# Plan: trace-db-shell
+
+## Change summary
+
+Add an embedded, in-process Agent Trace database shell behind:
+
+```sh
+sce trace db shell <uuid-or-alias>
+```
+
+The command resolves `<uuid-or-alias>` against the same discovered Agent Trace databases surfaced by `sce trace db list`, where the argument may be either a full checkout UUID/checkout ID or a positional alias such as `agent_trace_0`. After resolution it opens the target local Turso database directly from Rust and starts an interactive SQL shell over that database file.
+
+This must not delegate to the external `turso` CLI or any other external shell binary. The command is thin CLI orchestration over existing trace discovery plus a new embedded shell service.
+
+## Success criteria
+
+- `sce trace db shell <uuid-or-alias>` is accepted by clap and appears in trace DB help.
+- `<uuid-or-alias>` resolves using current `sce trace db list` discovery semantics:
+  - `agent_trace_N` aliases resolve to the discovered database with that alias.
+  - full checkout IDs/UUIDs resolve to the discovered database with matching `checkout_id`.
+  - unknown or ambiguous identifiers fail as validation errors with actionable guidance to run `sce trace db list`.
+- The resolved database must be schema-ready before the shell starts; skipped/missing-table DBs fail with the existing readiness reason instead of opening an unsafe shell.
+- The shell is embedded/in-process only: implementation uses Rust/Turso APIs already in the CLI dependency graph and never invokes the external `turso` command.
+- The interactive shell supports a minimal documented operator contract:
+  - prints the resolved alias, checkout ID, and database path before accepting input;
+  - supports `.help`, `.exit`, and `.quit` dot commands;
+  - executes SQL entered by the user against the resolved DB;
+  - renders query result rows in deterministic text form;
+  - renders non-query statement success without corrupting stdout/stderr contracts for normal command errors.
+- Non-interactive stdin use is deterministic enough for tests: piped commands such as `SELECT COUNT(*) FROM diff_traces;` followed by `.exit` can be exercised in automated coverage.
+- Targeted tests cover identifier resolution, unknown/skipped DB handling, shell command parsing, query rendering, and a non-interactive shell smoke path.
+- `nix flake check` and `nix run .#pkl-check-generated` pass after the implementation is complete.
+
+## Constraints and non-goals
+
+- Do not call or require the external `turso` CLI.
+- Do not add a new database schema, migration, or persisted artifact.
+- Do not change existing `sce trace db list`, `sce trace status`, or `sce trace status --all` output contracts except for help text that lists the new subcommand.
+- Do not add network/Turso Cloud behavior; this opens local Agent Trace DB files already discovered under `<state_root>/sce/`.
+- Do not implement full `turso shell` feature parity in this plan. The scope is the minimal embedded operator shell contract listed in success criteria.
+- Do not auto-create checkout identities or database files from this command. It only opens databases discovered from existing `agent-trace-*.db` files.
+
+## Assumptions
+
+- The user-facing argument name can be documented as `<uuid-or-alias>` even though discovery stores `checkout_id` strings parsed from `agent-trace-{checkout_id}.db` filenames.
+- Existing discovery order remains the alias source of truth; aliases are intentionally positional and may change when DB mtimes change, matching `sce trace db list` behavior.
+- A minimal embedded SQL shell is acceptable as long as it is in-process and useful for inspecting the Agent Trace DB. Exact Turso CLI prompt formatting, meta-commands, and table formatting are out of scope.
+- Because this is an interactive command, the implementation may route the shell transcript directly through stdio from the command/service boundary if the existing `RuntimeCommand -> String` return contract cannot represent a live REPL cleanly; any such boundary change must stay narrowly scoped to this command.
+
+## Task stack
+
+- [x] T01: `Add trace DB identifier resolution` (status:done)
+  - Task ID: T01
+  - Goal: Add a pure resolver that maps `<uuid-or-alias>` to one discovered, ready Agent Trace DB using current `discover_agent_trace_dbs()` results.
+  - Boundaries (in/out of scope): In — resolver module/function, identifier matching for `alias` and `checkout_id`, ready-vs-skipped validation, actionable error type/messages, focused unit tests using discovered DB fixtures. Out — clap command wiring, interactive shell loop, SQL execution/rendering changes.
+  - Done when: Resolver returns the expected DB for `agent_trace_N` and full checkout ID, rejects unknown identifiers with guidance to run `sce trace db list`, rejects skipped DBs with the missing-table reason, and has deterministic tests for each branch.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::trace'` or the narrower resolver test module once named.
+  - Completed: 2026-06-30
+  - Files changed: `cli/src/services/trace/discovery.rs`, `cli/src/services/trace/mod.rs`
+  - Evidence: `nix flake check` passed; `nix run .#pkl-check-generated` passed. A narrower direct Cargo test command was blocked by repo policy in favor of `nix flake check`.
+  - Notes: Added the pure resolver and typed user-actionable errors for alias/checkout-ID resolution, unknown identifiers, ambiguous identifiers, and skipped/not-ready databases. Branch-specific generated resolver tests were removed at user request; existing trace tests plus full flake validation pass.
+
+- [x] T02: `Implement embedded SQL shell core` (status:done)
+  - Task ID: T02
+  - Goal: Implement the in-process shell loop/core over a resolved Agent Trace DB path, including dot-command handling and deterministic SQL result rendering.
+  - Boundaries (in/out of scope): In — shell core module, `.help`/`.exit`/`.quit`, semicolon/newline command handling sufficient for operator SQL inspection, query/non-query execution through existing Turso adapter APIs, deterministic text rendering, tests with piped input/output seams. Out — clap integration, external process execution, full Turso CLI compatibility, rich terminal editing/history.
+  - Done when: A test can feed SQL plus `.exit` into the shell core and assert rendered rows/counts; `.help`, `.quit`, malformed SQL diagnostics, and non-query success output are covered; implementation contains no external `turso` process invocation.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::trace::shell'` after the module exists.
+  - Completed: 2026-06-30
+  - Files changed: `cli/src/services/db/mod.rs`, `cli/src/services/trace/mod.rs`, `cli/src/services/trace/shell.rs`
+  - Evidence: `nix flake check` passed; `nix run .#pkl-check-generated` passed. The narrower `nix develop -c sh -c 'cd cli && cargo test services::trace::shell'` command was blocked by repo bash policy in favor of `nix flake check`.
+  - Notes: Added a testable embedded Agent Trace DB shell core with path-open/schema-readiness checks, deterministic startup transcript, `.help`/`.exit`/`.quit`, newline/semicolon statement execution, query table rendering, non-query success output, and SQL-error diagnostics that keep the shell running. Added a shared `TursoDb::query_values` helper for fully fetched raw value rows. Context-sync classification: small shared DB adapter surface plus localized trace shell core; updated shared DB and trace-command context.
+
+- [x] T03: `Wire sce trace db shell command surface` (status:done)
+  - Task ID: T03
+  - Goal: Add `sce trace db shell <uuid-or-alias>` to clap parsing, runtime request conversion, and `TraceCommand` dispatch so it resolves the identifier and starts the embedded shell.
+  - Boundaries (in/out of scope): In — `TraceDbSubcommand::Shell`, request enum update, parser conversion, command dispatch, help text, validation-error mapping for resolver failures. Out — new shell features beyond T02, changes to existing trace list/status rendering.
+  - Done when: `sce trace db shell --help`/`sce trace db --help` show the shell command, valid aliases/checkout IDs open the embedded shell, unknown identifiers return validation-class errors, and existing trace commands continue to parse and run unchanged.
+  - Verification notes (commands or checks): `nix develop -c sh -c 'cd cli && cargo test services::parse services::trace'`; manual smoke with piped input once implemented, e.g. `printf '.exit\n' | nix develop -c sh -c 'cd cli && cargo run -- trace db shell agent_trace_0'`.
+  - Completed: 2026-06-30
+  - Files changed: `cli/src/cli_schema.rs`, `cli/src/services/parse/command_runtime.rs`, `cli/src/services/trace/command.rs`, `cli/src/services/trace/mod.rs`
+  - Evidence: `nix flake check` passed; `nix run .#pkl-check-generated` passed; `nix run .#sce -- trace db --help` showed `shell`; `nix run .#sce -- trace db shell --help` showed `<uuid-or-alias>`; `nix run .#sce -- trace db shell does_not_exist` returned `SCE-ERR-VALIDATION` with `sce trace db list` guidance. The narrower `nix develop -c sh -c 'cd cli && cargo test services::parse::command_runtime services::trace'` command was blocked by repo bash policy in favor of `nix flake check`.
+  - Notes: Added clap/runtime request wiring for `sce trace db shell <uuid-or-alias>`, dispatch through existing discovery + resolver, validation-class resolver errors, and direct in-process stdio handoff to the embedded shell core. Existing list/status request variants remain unchanged. Context-sync classification: localized command-surface wiring for an already-planned trace shell; trace-command durable context should include the now-wired shell subcommand.
+
+- [x] T04: `Document trace DB shell operator contract` (status:done)
+  - Task ID: T04
+  - Goal: Update current-state context/docs for the new shell subcommand and its embedded-only behavior.
+  - Boundaries (in/out of scope): In — `context/cli/trace-command.md`, relevant command-surface/default-path/context-map references if needed, and CLI README/help-adjacent docs if they list trace DB subcommands. Out — broad historical plan rewrites and unrelated Agent Trace documentation churn.
+  - Done when: Durable context states that `sce trace db shell <uuid-or-alias>` resolves discovered DB aliases/checkout IDs and opens an embedded in-process SQL shell without external `turso`; no current-state docs contradict that behavior.
+  - Verification notes (commands or checks): Review `context/context-map.md`, `context/cli/trace-command.md`, and any CLI docs touched by the implementation.
+  - Completed: 2026-06-30
+  - Files changed: `context/cli/trace-command.md`, `context/plans/trace-db-shell.md`
+  - Evidence: Reviewed `context/cli/trace-command.md` operator contract; searched current docs for `trace db shell`, `trace db list`, `external turso`, and `turso shell` references; no contradictory current-state docs found.
+  - Notes: Added an explicit operator contract covering `sce trace db list` alias/checkout-ID discovery, ready-only resolution failure modes, startup metadata, `.help`/`.exit`/`.quit`, piped stdin automation, and the embedded-only no-external-database-CLI boundary. Context-sync classification: localized current-state trace command documentation update; root context already referenced the implemented shell and no root edits were required for this task.
+
+- [x] T05: `Validate and clean up trace DB shell` (status:done)
+  - Task ID: T05
+  - Goal: Run full validation, smoke the new command, and remove temporary scaffolding before handoff.
+  - Boundaries (in/out of scope): In — full repo validation, generated-output parity check, manual/non-interactive smoke of the shell command against a discovered DB when available, check for accidental external `turso` invocation, final context sync verification. Out — adding new features after validation begins.
+  - Done when: `nix flake check` and `nix run .#pkl-check-generated` pass; a smoke command demonstrates the embedded shell can open a DB and run a simple query or exits cleanly with documented guidance when no DB exists; no temporary files or debug scaffolding remain; plan task evidence is updated.
+  - Verification notes (commands or checks): `nix flake check`; `nix run .#pkl-check-generated`; `rg "Command::new\(\"turso\"\)|turso shell|spawn.*turso" cli/src`; `sce trace db list`; `printf 'SELECT COUNT(*) FROM diff_traces;\n.exit\n' | sce trace db shell <uuid-or-alias>` when a ready DB is available.
+  - Completed: 2026-06-30
+  - Files changed: `context/plans/trace-db-shell.md`
+  - Evidence: `nix flake check` passed; `nix run .#pkl-check-generated` passed; `nix run .#sce -- trace db list` found ready `agent_trace_0`; `printf 'SELECT COUNT(*) FROM diff_traces;\n.exit\n' | nix run .#sce -- trace db shell agent_trace_0` opened the embedded shell and returned count `8`; `Command::new("turso")|turso shell|spawn.*turso` search under `cli/src/**/*.rs` found no matches.
+  - Notes: No temporary/debug scaffolding or out-of-scope feature work was needed. Context-sync classification: final validation/plan-evidence update for an already documented feature; expected verify-only root context pass.
+
+## Open questions
+
+None.
+
+## Validation Report
+
+### Commands run
+
+- `nix flake check` -> exit 0 (`all checks passed!`).
+- `nix run .#pkl-check-generated` -> exit 0 (`Generated outputs are up to date.`).
+- `nix run .#sce -- trace db list` -> exit 0; discovered ready `agent_trace_0` at `/home/davidabram/.local/state/sce/agent-trace-019ee24b-ac0f-7a51-b8ba-877334cd4bd7.db`.
+- `printf 'SELECT COUNT(*) FROM diff_traces;\n.exit\n' | nix run .#sce -- trace db shell agent_trace_0` -> exit 0; shell printed alias/checkout/path metadata and returned `COUNT(*) = 8`.
+- Search for `Command::new("turso")|turso shell|spawn.*turso` under `cli/src/**/*.rs` -> no matches.
+
+### Success-criteria verification
+
+- [x] `sce trace db shell <uuid-or-alias>` is accepted by clap and appears in trace DB help — verified in T03 evidence.
+- [x] Alias/checkout-ID resolution and skipped/unknown validation behavior are implemented — verified in T01/T03 evidence and retained by `nix flake check`.
+- [x] Embedded shell is in-process only — final source search found no external `turso` invocation under `cli/src`.
+- [x] Minimal shell operator contract is documented and implemented — verified in T02/T04 evidence and final smoke.
+- [x] Non-interactive stdin smoke path works — piped `SELECT COUNT(*) FROM diff_traces;` returned `8`.
+- [x] Full validation and generated parity pass — `nix flake check` and `nix run .#pkl-check-generated` both exited 0.
+
+### Failed checks and follow-ups
+
+- None.
+
+### Residual risks
+
+- Positional aliases are intentionally mtime-dependent and may change between `trace db list` and `trace db shell`, as documented in the operator contract.
diff --git a/context/sce/agent-trace-db.md b/context/sce/agent-trace-db.md
index 51470d69..1bb23990 100644
--- a/context/sce/agent-trace-db.md
+++ b/context/sce/agent-trace-db.md
@@ -58,7 +58,7 @@ Active hook runtime resolves per-checkout Agent Trace DB files:
 - Function: `agent_trace_db_path_for_checkout(checkout_id)` in `cli/src/services/default_paths.rs`
 - Path template: `<state_root>/sce/agent-trace-{checkout_id}.db`
 - Checkout ID source: `<git-dir>/sce/checkout-id`, where `<git-dir>` comes from `git rev-parse --git-dir`
-- Checkouts are discovered by `sce doctor dbs` via filesystem scan of `<state_root>/sce/agent-trace-*.db` files; there is no central registry file.
+- Checkouts are discovered by `sce trace db list` via filesystem scan of `<state_root>/sce/agent-trace-*.db` files; there is no central registry file.
 
 ## Migrations
 
@@ -182,7 +182,7 @@ Both triggers compare `OLD.*` vs `NEW.*` for all mutable columns (excluding `upd
 - `fix()` bootstraps the resolved per-checkout DB parent directory for auto-fixable parent-readiness problems, with the same global fallback outside checkout context.
 - `setup()` creates/reuses the current checkout identity when a repo root is available, resolves `<state_root>/sce/agent-trace-{checkout_id}.db` through `agent_trace_db_path_for_checkout(checkout_id)`, opens/creates it with `AgentTraceDb::open_at(&db_path)` to apply embedded migrations, and emits setup messaging with the checkout ID plus initialized DB path. Hook runtime lazy initialization remains available for checkouts where setup has not run or schema metadata is incomplete.
 - `sce doctor` surfaces checkout identity and per-checkout Agent Trace DB health in the `Configuration` section when a checkout ID exists, with `[PASS]`/`[FAIL]`/`[MISS]` status tokens. Outside checkout context it falls back to the legacy/global Agent Trace DB row. JSON output includes `checkout_identity` when available plus the resolved `agent_trace_db` field.
-- `sce doctor dbs` discovers checkouts by scanning `<state_root>/sce/agent-trace-*.db` files on disk, reporting them in text or JSON sorted by mtime descending.
+- `sce trace db list` discovers checkouts by scanning `<state_root>/sce/agent-trace-*.db` files on disk, reporting them in text or JSON sorted by mtime descending. See [context/cli/trace-command.md](../cli/trace-command.md).
 
 ## Runtime writers
 
diff --git a/context/sce/shared-turso-db.md b/context/sce/shared-turso-db.md
index 65d463fc..6e0c7ea8 100644
--- a/context/sce/shared-turso-db.md
+++ b/context/sce/shared-turso-db.md
@@ -15,7 +15,7 @@
   - config-driven connection-open retry around only the `build().await.connect()` block using `run_with_retry_sync` (resolved from `policies.database_retry.<db>.connection_open` via `DATABASE_RETRY_CONFIG` `OnceLock` with fallback to hardcoded defaults `3` attempts, `1s` timeout, `25ms..200ms` backoff)
   - config-driven operation retry for `execute()`, `query()`, and `query_map()` using `run_with_retry_sync` (resolved from `policies.database_retry.<db>.query` via the same `OnceLock` with fallback to hardcoded defaults `5` attempts, `200ms` timeout, `25ms..100ms` backoff, with default worst-case failure budget `<= 2_000ms`)
   - parent-directory creation
-  - retry-backed synchronous `execute()`, `query()`, and row-mapping `query_map()` wrappers via the public adapter methods, with config-driven query retry resolved from `policies.database_retry.<db>.query`
+  - retry-backed synchronous `execute()`, `query()`, raw-value `query_values()`, and row-mapping `query_map()` wrappers via the public adapter methods, with config-driven query retry resolved from `policies.database_retry.<db>.query`
   - migration-running initialization through `new()` and generic embedded migration execution through `run_migrations()` delegated to the shared internal `TursoConnectionCore<M>` with per-database `__sce_migrations` metadata
   - explicit-path migration-running initialization through `new_at(path)`, preserving the same service-specific retry/migration behavior while letting callers supply a database path outside `DbSpec::db_path()`
   - no-migration opening through `open_without_migrations()`, which preserves parent-directory creation and connection-open retry but does not create `__sce_migrations` or apply embedded migrations
@@ -70,7 +70,7 @@ All three database wrappers (local DB, auth DB, Agent Trace DB) have lifecycle p
 
 Migrations are deliberately outside the connection-open retry block. The constructors retry only local Turso open/connect; schema changes are not retried because migration SQL must not be replayed after partial execution.
 
-`TursoDb<M>` and `EncryptedTursoDb<M>` operation methods use the same config-driven query retry policy, resolved from `policies.database_retry.<db>.query` via `DATABASE_RETRY_CONFIG` `OnceLock` with fallback to hardcoded defaults (`5` attempts, `200ms` timeout, `25ms..100ms` backoff; default worst-case failure budget `<= 2_000ms`). `execute()` and `query()` convert caller parameters to owned Turso params before retry so each attempt can clone the same values. `query_map()` retries the initial query and full row-fetch loop, then runs caller-provided row mapping after retry completion so mapping failures are surfaced as logic errors and are not retried.
+`TursoDb<M>` and `EncryptedTursoDb<M>` operation methods use the same config-driven query retry policy, resolved from `policies.database_retry.<db>.query` via `DATABASE_RETRY_CONFIG` `OnceLock` with fallback to hardcoded defaults (`5` attempts, `200ms` timeout, `25ms..100ms` backoff; default worst-case failure budget `<= 2_000ms`). `execute()`, `query()`, and `query_values()` convert caller parameters to owned Turso params before retry so each attempt can clone the same values. `query_values()` returns fully fetched column names plus raw `turso::Value` rows for deterministic rendering by operator-facing services. `query_map()` retries the initial query and full row-fetch loop, then runs caller-provided row mapping after retry completion so mapping failures are surfaced as logic errors and are not retried.
 
 Existing databases created before migration metadata are upgraded by re-applying the current idempotent migration list and recording each migration ID. This lets later `sce setup` / lifecycle initialization runs apply migrations added after the database file already existed, including Agent Trace DB schema/index additions.