Merge branch 'simplify/v2-cleanup' into codex/tracedecay-total-redesign-plan

Author: ScriptedAlchemy

crates/tracedecay-capture/src/claude/mod.rs

@@ -1,6 +1,6 @@
 mod canonical;
 
-use sha2::{Digest, Sha256};
+use tracedecay_domain::canonical_text::canonical_framed_sha256;
 
 pub use canonical::{normalize, stable_record_id};
 
@@ -26,14 +26,3 @@ pub fn observation_source_id(native_transcript_id: &[u8]) -> String {
         canonical_framed_sha256(OBSERVATION_SOURCE_ID_DOMAIN, &[native_transcript_id])
     )
 }
-
-fn canonical_framed_sha256(domain: &[u8], parts: &[&[u8]]) -> String {
-    let mut hasher = Sha256::new();
-    hasher.update((domain.len() as u64).to_be_bytes());
-    hasher.update(domain);
-    for part in parts {
-        hasher.update((part.len() as u64).to_be_bytes());
-        hasher.update(part);
-    }
-    hex::encode(hasher.finalize())
-}

crates/tracedecay-capture/src/kiro.rs

@@ -1,5 +1,5 @@
 use serde_json::{Map, Value};
-use sha2::{Digest, Sha256};
+use tracedecay_domain::canonical_text::canonical_framed_sha256;
 
 const PROVIDER: &str = "kiro";
 const DELIMITED_NATIVE_MESSAGE_ID_DOMAIN: &[u8] = b"tracedecay.kiro-delimited-native-message.v2";
@@ -87,14 +87,3 @@ pub fn stable_message_id(
     );
     format!("{DERIVED_MESSAGE_ID_PREFIX}{digest}")
 }
-
-fn canonical_framed_sha256(domain: &[u8], parts: &[&[u8]]) -> String {
-    let mut hasher = Sha256::new();
-    hasher.update((domain.len() as u64).to_be_bytes());
-    hasher.update(domain);
-    for part in parts {
-        hasher.update((part.len() as u64).to_be_bytes());
-        hasher.update(part);
-    }
-    hex::encode(hasher.finalize())
-}

crates/tracedecay-code-extraction/src/traversal.rs

@@ -6,30 +6,16 @@ use tree_sitter::Node as TsNode;
 /// This helper is intentionally language-agnostic: callers provide the raw
 /// `kind()` string they expect, and the traversal checks direct children in
 /// source order without filtering to named nodes.
-#[allow(dead_code)]
 pub(crate) fn has_direct_child_kind(node: TsNode<'_>, kind: &str) -> bool {
     find_direct_child_by_kind(node, kind).is_some()
 }
 
-/// Visits each direct child in source order.
-///
-/// This keeps the raw tree-sitter cursor loop in one place so extractors that
-/// only need to recurse into direct children can share the traversal behavior.
-#[allow(dead_code)]
-pub(crate) fn visit_children<'tree>(node: TsNode<'tree>, mut visit: impl FnMut(TsNode<'tree>)) {
-    visit_children_while(node, |child| {
-        visit(child);
-        true
-    });
-}
-
 /// Returns the first direct child whose tree-sitter kind exactly matches
 /// `kind`.
 ///
 /// The match is an exact `Node::kind()` string comparison. Both named and
 /// anonymous children participate so extractor migrations preserve existing
 /// behavior.
-#[allow(dead_code)]
 pub(crate) fn find_direct_child_by_kind<'tree>(
     node: TsNode<'tree>,
     kind: &str,
@@ -51,7 +37,6 @@ pub(crate) fn find_direct_child_by_kind<'tree>(
 /// Descendants are visited with a pre-order depth-first traversal over all
 /// children so callers can replace the duplicated recursive extractor helpers
 /// without changing search order.
-#[allow(dead_code)]
 pub(crate) fn find_descendant_by_kind<'tree>(
     node: TsNode<'tree>,
     kind: &str,
@@ -91,7 +76,8 @@ fn visit_children_while<'tree>(node: TsNode<'tree>, mut visit: impl FnMut(TsNode
 #[allow(clippy::expect_used)]
 mod tests {
     use super::{
-        find_descendant_by_kind, find_direct_child_by_kind, has_direct_child_kind, visit_children,
+        find_descendant_by_kind, find_direct_child_by_kind, has_direct_child_kind,
+        visit_children_while,
     };
     use crate::ts_provider;
     use tree_sitter::{Node as TsNode, Parser};
@@ -140,8 +126,9 @@ mod tests {
         let function = parse_c_function("int answer(void) { return 42; }");
         let mut child_kinds = Vec::new();
 
-        visit_children(function, |child| {
+        visit_children_while(function, |child| {
             child_kinds.push(child.kind().to_owned());
+            true
         });
 
         assert_eq!(

crates/tracedecay-domain/src/canonical_text.rs

@@ -8,6 +8,8 @@
 //! Only the predicate is shared — never the error, so no contract's
 //! accept/reject reporting changes by reusing it.
 
+use sha2::{Digest, Sha256};
+
 use crate::research::DomainError;
 
 /// Byte bound shared by canonical identities and labels across the contracts.
@@ -79,6 +81,26 @@ pub fn encode_tagged_lowercase_hex(tag: &str, bytes: &[u8]) -> String {
     encoded
 }
 
+/// Length-prefixed SHA-256 over a domain separator and an ordered list of
+/// parts, encoded as lowercase hex.
+///
+/// Every frame — the domain tag included — is preceded by its big-endian
+/// `u64` byte length, so no two different splits of the same concatenated
+/// bytes can collide. This is an identity primitive: derived ids already
+/// written to disk depend on the exact framing, so the byte layout must never
+/// change.
+#[must_use]
+pub fn canonical_framed_sha256(domain: &[u8], parts: &[&[u8]]) -> String {
+    let mut hasher = Sha256::new();
+    hasher.update((domain.len() as u64).to_be_bytes());
+    hasher.update(domain);
+    for part in parts {
+        hasher.update((part.len() as u64).to_be_bytes());
+        hasher.update(part);
+    }
+    encode_lowercase_hex(&hasher.finalize())
+}
+
 /// Canonical bounded string that reports an empty value distinctly from a
 /// non-canonical one.
 ///

crates/tracedecay-migrate/src/hermes/resolution.rs

@@ -6,34 +6,22 @@ use std::path::{Path, PathBuf};
 use super::copy::{MIGRATION_QUERY_PAGE_ROWS, ensure_materialized_row_room, table_columns};
 use crate::root_seam::global_db::RegisteredGlobalDb;
 use tracedecay_runtime_core::db::engine::{QueryExecutor, params};
+use tracedecay_runtime_core::path_safety::{
+    canonicalize_existing_prefix, canonicalize_path_or_existing_parent,
+};
 
 pub struct ResolvedTargetProject {
     pub root: PathBuf,
     pub registry_project_id: Option<String>,
     pub user_scope: bool,
 }
 
+/// Compares two paths after canonicalizing the deepest existing ancestor and
+/// reattaching any missing tail. This preserves OS aliases such as macOS
+/// `/var` -> `/private/var` even after the final project directory was moved
+/// or a symlink alias was removed.
 pub fn same_path(left: &Path, right: &Path) -> bool {
-    canonicalize_with_missing_tail(left).unwrap_or_else(|| left.to_path_buf())
-        == canonicalize_with_missing_tail(right).unwrap_or_else(|| right.to_path_buf())
-}
-
-/// Canonicalizes the deepest existing ancestor and reattaches a missing tail.
-/// This preserves OS aliases such as macOS `/var` -> `/private/var` even after
-/// the final project directory was moved or a symlink alias was removed.
-fn canonicalize_with_missing_tail(path: &Path) -> Option<PathBuf> {
-    let mut ancestor = path;
-    let mut tail = Vec::new();
-    loop {
-        if let Ok(mut canonical) = ancestor.canonicalize() {
-            for component in tail.iter().rev() {
-                canonical.push(component);
-            }
-            return Some(canonical);
-        }
-        tail.push(ancestor.file_name()?.to_os_string());
-        ancestor = ancestor.parent()?;
-    }
+    canonicalize_path_or_existing_parent(left) == canonicalize_path_or_existing_parent(right)
 }
 
 fn real_project_root(
@@ -127,7 +115,7 @@ async fn resolve_project_candidate(
         return Ok(None);
     }
 
-    let canonical_candidate = canonicalize_with_missing_tail(candidate);
+    let canonical_candidate = canonicalize_existing_prefix(candidate);
     let context = if let Some(registry) = registry {
         let direct = registry
             .project_registry_context_by_alias(candidate)

crates/tracedecay-migrate/src/profile_identity.rs

@@ -3,6 +3,7 @@ use std::path::{Path, PathBuf};
 use serde::{Deserialize, Serialize};
 use tracedecay_domain::{BrainId, UserProfileId};
 use tracedecay_runtime_core::errors::{Result, TraceDecayError};
+use tracedecay_runtime_core::path_safety::canonicalize_existing_prefix;
 use tracedecay_runtime_core::storage::PROFILE_IDENTITY_FILENAME;
 
 const PROFILE_IDENTITY_SCHEMA_VERSION: u32 = 1;
@@ -157,6 +158,15 @@ fn random_identity(prefix: &str) -> Result<String> {
     Ok(format!("{prefix}.{}", hex::encode(bytes)))
 }
 
+/// Absolutizes `path` and canonicalizes through its deepest existing
+/// ancestor.
+///
+/// Known divergence, deliberately preserved: the daemon's identically-named
+/// resolver additionally applies
+/// [`tracedecay_runtime_core::path_safety::collapse_relative_components`] to
+/// the result. This one must not — the identity strings it produces are
+/// already written into migrated profile records, and collapsing `.`/`..`
+/// here would rewrite them. Only the canonicalization algorithm is shared.
 fn canonical_identity_path(path: &Path) -> Result<PathBuf> {
     let absolute = if path.is_absolute() {
         path.to_path_buf()
@@ -165,29 +175,9 @@ fn canonical_identity_path(path: &Path) -> Result<PathBuf> {
             .map_err(|error| profile_identity_io("resolve", path, &error))?
             .join(path)
     };
-    if let Ok(canonical) = absolute.canonicalize() {
-        return Ok(canonical);
-    }
-    let mut suffix = Vec::new();
-    let mut existing = absolute.as_path();
-    while !existing.exists() {
-        let Some(name) = existing.file_name() else {
-            return Err(TraceDecayError::Config {
-                message: format!("failed to resolve identity path '{}'", path.display()),
-            });
-        };
-        suffix.push(name.to_os_string());
-        existing = existing.parent().ok_or_else(|| TraceDecayError::Config {
-            message: format!("failed to resolve identity path '{}'", path.display()),
-        })?;
-    }
-    let mut canonical = existing
-        .canonicalize()
-        .map_err(|error| profile_identity_io("canonicalize", existing, &error))?;
-    for component in suffix.iter().rev() {
-        canonical.push(component);
-    }
-    Ok(canonical)
+    canonicalize_existing_prefix(&absolute).ok_or_else(|| TraceDecayError::Config {
+        message: format!("failed to resolve identity path '{}'", path.display()),
+    })
 }
 
 fn invalid_identity(path: &Path, field: &str, error: impl std::fmt::Display) -> TraceDecayError {

crates/tracedecay-runtime-core/src/config.rs

@@ -112,28 +112,7 @@ fn canonicalize_data_dir(path: PathBuf) -> PathBuf {
     if !path.is_absolute() {
         return path;
     }
-    canonicalize_path_or_existing_parent(&path)
-}
-
-fn canonicalize_path_or_existing_parent(path: &Path) -> PathBuf {
-    if let Ok(canonical) = path.canonicalize() {
-        return canonical;
-    }
-
-    let mut current = path;
-    let mut missing_suffix = PathBuf::new();
-    while let Some(name) = current.file_name() {
-        missing_suffix = Path::new(name).join(missing_suffix);
-        let Some(parent) = current.parent() else {
-            break;
-        };
-        current = parent;
-        if let Ok(canonical_parent) = current.canonicalize() {
-            return canonical_parent.join(missing_suffix);
-        }
-    }
-
-    path.to_path_buf()
+    crate::path_safety::canonicalize_path_or_existing_parent(&path)
 }
 
 /// Walks up from `start` looking for the nearest ancestor that hosts an

crates/tracedecay-runtime-core/src/lib.rs

@@ -71,6 +71,7 @@ pub mod lifecycle_lease;
 pub mod memory;
 pub mod open_store_holders;
 pub mod os_str_bytes;
+pub mod path_safety;
 pub mod path_scope;
 pub mod privacy;
 pub mod project_registry;