chore(cleanup): sweep migration-removal leftovers

Delete the code orphaned by the removal commits: the session-temporal
repair paged audit drivers (the trigger-backed invariants themselves
survive), the memory cutover's canonical-label helper, the migrate
registry's unread field, and the vector-generation test helpers, taking
workspace dead-code warnings from twelve to zero. Regenerate the
dashboard contracts schema, whose stale legacy_backfill_complete
requirement failed the blocking contracts:check step. Close the
serving-path doc's 150K publication open issue as superseded, rewrite
its forward-migration wording, and mark the plan doc's memory-cutover
section superseded. Drop an unreferenced build-support draft and ignore
the .superpowers session-notes directory.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ScriptedAlchemy

.gitignore

@@ -26,3 +26,4 @@ __pycache__/
 # transient Playwright/axe verification output (screenshots and findings).
 # Shipped-state baselines live in dashboard/audit-baselines/ and stay tracked.
 dashboard/.*-axe/
+.superpowers/

crates/tracedecay-global-db/src/schema_contract/invariants.rs

@@ -56,14 +56,6 @@ pub(super) const AUDIT_PAGE_ROWS: i64 = 128;
 /// limit while avoiding tens of thousands of SQL-channel round trips on a
 /// production-sized store.
 pub(super) const OBSERVATION_AUDIT_PAGE_ROWS: i64 = 48;
-const SESSION_TEMPORAL_REPAIR_AUDITS: &[&str] = &[
-    "session temporal receipts or cursor keys are mutable",
-    "session cursor key rotation state is invalid",
-    "session refresh operation state is invalid",
-    "session temporal generation state is invalid",
-    "session temporal authority ownership is invalid",
-];
-pub const SESSION_TEMPORAL_REPAIR_AUDIT_PAGE_ROWS: i64 = 256;
 
 pub async fn authority_invariant_triggers_intact(
     conn: &impl QueryExecutor,
@@ -527,222 +519,16 @@ pub async fn validate_authority_rows_exhaustive(
     validate_invariant_rows(conn).await
 }
 
-pub async fn validate_session_temporal_repair_authority_audit(
-    conn: &impl QueryExecutor,
-    audit_index: usize,
-) -> tracedecay_runtime_core::errors::Result<()> {
-    let invariant = INVARIANTS
-        .iter()
-        .filter(|invariant| SESSION_TEMPORAL_REPAIR_AUDITS.contains(&invariant.violation))
-        .nth(audit_index)
-        .ok_or_else(|| {
-            global_db_operation_message(
-                OPERATION,
-                format!("unknown session temporal repair authority audit {audit_index}"),
-            )
-        })?;
-    if let Some(query) = invariant.audit_query
-        && query_has_rows(conn, query).await?
-    {
-        return Err(global_db_operation_message(OPERATION, invariant.violation));
-    }
-    Ok(())
-}
-
-#[cfg(test)]
-pub async fn validate_session_temporal_effect_authority_page(
-    conn: &impl QueryExecutor,
-    after_rowid: i64,
-) -> tracedecay_runtime_core::errors::Result<(i64, bool)> {
-    validate_session_temporal_effect_authority_page_with_limit(
-        conn,
-        after_rowid,
-        SESSION_TEMPORAL_REPAIR_AUDIT_PAGE_ROWS,
-    )
-    .await
-}
-
-pub async fn validate_session_temporal_effect_authority_page_with_limit(
-    conn: &impl QueryExecutor,
-    after_rowid: i64,
-    page_rows: i64,
-) -> tracedecay_runtime_core::errors::Result<(i64, bool)> {
-    debug_assert!(page_rows > 0);
-    let mut rows = conn
-        .query(
-            "SELECT effect.rowid, observation.observation_id IS NULL
-             FROM session_temporal_observation_effects AS effect
-             LEFT JOIN observations AS observation
-               ON observation.observation_id = effect.observation_id
-              AND observation.sequence = effect.observation_sequence
-              AND observation.receipt_id = effect.receipt_id
-             WHERE effect.rowid > ?1
-             ORDER BY effect.rowid
-             LIMIT ?2",
-            params![after_rowid, page_rows],
-        )
-        .await
-        .map_err(|error| global_db_operation_error(OPERATION, error))?;
-    let mut last_rowid = after_rowid;
-    let mut count = 0_i64;
-    while let Some(row) = rows
-        .next()
-        .await
-        .map_err(|error| global_db_operation_error(OPERATION, error))?
-    {
-        last_rowid = row
-            .get(0)
-            .map_err(|error| global_db_operation_error(OPERATION, error))?;
-        let invalid = row
-            .get::<i64>(1)
-            .map_err(|error| global_db_operation_error(OPERATION, error))?
-            != 0;
-        if invalid {
-            return Err(global_db_operation_message(
-                OPERATION,
-                SESSION_TEMPORAL_REPAIR_AUDITS[0],
-            ));
-        }
-        count += 1;
-    }
-    Ok((last_rowid, count < page_rows))
-}
-
-pub async fn validate_session_temporal_receipt_authority_page_with_limit(
-    conn: &impl QueryExecutor,
-    after_rowid: i64,
-    page_rows: i64,
-) -> tracedecay_runtime_core::errors::Result<(i64, bool)> {
-    debug_assert!(page_rows > 0);
-    let mut rows = conn
-        .query(
-            "SELECT receipt.rowid,
-                    generation.session_id IS NULL
-                    OR (
-                        receipt.batch_ordinal > 0
-                        AND NOT EXISTS (
-                            SELECT 1
-                            FROM session_temporal_projection_receipts AS previous
-                            WHERE previous.session_id = receipt.session_id
-                              AND previous.generation = receipt.generation
-                              AND previous.batch_ordinal = receipt.batch_ordinal - 1
-                              AND previous.source_through <= receipt.source_through
-                              AND previous.projection_through <= receipt.projection_through
-                        )
-                    )
-             FROM session_temporal_projection_receipts AS receipt
-             LEFT JOIN session_temporal_generations AS generation
-               ON generation.session_id = receipt.session_id
-              AND generation.generation = receipt.generation
-              AND generation.frozen_watermarks_json = receipt.frozen_watermarks_json
-             WHERE receipt.rowid > ?1
-             ORDER BY receipt.rowid
-             LIMIT ?2",
-            params![after_rowid, page_rows],
-        )
-        .await
-        .map_err(|error| global_db_operation_error(OPERATION, error))?;
-    let mut last_rowid = after_rowid;
-    let mut count = 0_i64;
-    while let Some(row) = rows
-        .next()
-        .await
-        .map_err(|error| global_db_operation_error(OPERATION, error))?
-    {
-        last_rowid = row
-            .get(0)
-            .map_err(|error| global_db_operation_error(OPERATION, error))?;
-        let invalid = row
-            .get::<i64>(1)
-            .map_err(|error| global_db_operation_error(OPERATION, error))?
-            != 0;
-        if invalid {
-            return Err(global_db_operation_message(
-                OPERATION,
-                SESSION_TEMPORAL_REPAIR_AUDITS[0],
-            ));
-        }
-        count += 1;
-    }
-    Ok((last_rowid, count < page_rows))
-}
-
 #[cfg(test)]
 mod tests {
     use tempfile::TempDir;
 
     use super::{
         FOREIGN_KEY_AUDIT_PROGRESS, foreign_key_violation_exists_read_only,
-        foreign_key_violation_exists_resumable, validate_session_temporal_effect_authority_page,
-        validate_session_temporal_effect_authority_page_with_limit,
+        foreign_key_violation_exists_resumable,
     };
     use tracedecay_runtime_core::db::engine::TestConnection;
 
-    #[tokio::test]
-    async fn session_temporal_effect_audit_checkpoints_bounded_pages() {
-        let directory = TempDir::new().unwrap();
-        let database_path = directory.path().join("sessions.db");
-        let mut connection = rusqlite::Connection::open(&database_path).unwrap();
-        connection
-            .execute_batch(
-                "CREATE TABLE observations (
-                    observation_id TEXT NOT NULL,
-                    sequence INTEGER NOT NULL,
-                    receipt_id TEXT NOT NULL,
-                    PRIMARY KEY(observation_id, sequence, receipt_id)
-                 );
-                 CREATE TABLE session_temporal_observation_effects (
-                    observation_id TEXT NOT NULL,
-                    observation_sequence INTEGER NOT NULL,
-                    receipt_id TEXT NOT NULL
-                 );",
-            )
-            .unwrap();
-        let transaction = connection.transaction().unwrap();
-        for ordinal in 1..=257 {
-            let observation_id = format!("observation-{ordinal}");
-            let receipt_id = format!("receipt-{ordinal}");
-            transaction
-                .execute(
-                    "INSERT INTO observations(observation_id, sequence, receipt_id)
-                     VALUES (?1, ?2, ?3)",
-                    rusqlite::params![observation_id, ordinal, receipt_id],
-                )
-                .unwrap();
-            transaction
-                .execute(
-                    "INSERT INTO session_temporal_observation_effects(
-                        observation_id, observation_sequence, receipt_id
-                     ) VALUES (?1, ?2, ?3)",
-                    rusqlite::params![observation_id, ordinal, receipt_id],
-                )
-                .unwrap();
-        }
-        transaction.commit().unwrap();
-        drop(connection);
-        let connection = TestConnection::open(&database_path);
-
-        let (first_cursor, first_complete) =
-            validate_session_temporal_effect_authority_page(&connection, 0)
-                .await
-                .unwrap();
-        assert_eq!(first_cursor, 256);
-        assert!(!first_complete);
-        let (second_cursor, second_complete) =
-            validate_session_temporal_effect_authority_page(&connection, first_cursor)
-                .await
-                .unwrap();
-        assert_eq!(second_cursor, 257);
-        assert!(second_complete);
-
-        let (adaptive_cursor, adaptive_complete) =
-            validate_session_temporal_effect_authority_page_with_limit(&connection, 0, 512)
-                .await
-                .unwrap();
-        assert_eq!(adaptive_cursor, 257);
-        assert!(adaptive_complete);
-    }
-
     #[tokio::test]
     async fn foreign_key_audit_finds_violations_by_child_table() {
         let directory = TempDir::new().unwrap();

crates/tracedecay-global-db/src/schema_contract/mod.rs

@@ -12,12 +12,9 @@ fn normalize_trigger_sql(sql: &str) -> String {
 }
 
 pub(super) use invariants::{
-    SESSION_TEMPORAL_REPAIR_AUDIT_PAGE_ROWS, authority_invariant_triggers_intact,
-    restore_immutability_after_canonical_repair, suspend_immutability_for_canonical_repair,
-    suspend_session_invariants_for_schema_upgrade, validate_authority_rows_exhaustive,
-    validate_session_temporal_effect_authority_page_with_limit,
-    validate_session_temporal_receipt_authority_page_with_limit,
-    validate_session_temporal_repair_authority_audit,
+    authority_invariant_triggers_intact, restore_immutability_after_canonical_repair,
+    suspend_immutability_for_canonical_repair, suspend_session_invariants_for_schema_upgrade,
+    validate_authority_rows_exhaustive,
 };
 pub use invariants::{
     ensure_authority_audit_checkpoint_schema, ensure_authority_invariant_schema,

crates/tracedecay-migrate/SEAMS.md

@@ -166,7 +166,7 @@ follow `global_db` (seam 1) rather than needing a design of their own.
 
 ## 7. `test-transport` is not forwarded to the kernel
 
-`memory_cutover.rs:56` and `:62` call
+`memory_cutover.rs:50` and `:56` call
 `storage::set_durable_atomic_write_fault_for_test`, which
 `tracedecay-runtime-core` gates behind `#[cfg(any(test, feature =
 "test-transport"))]`. This crate's `test-transport` feature currently forwards

crates/tracedecay-migrate/src/registry.rs

@@ -112,8 +112,6 @@ pub struct RegistryReconstructionDiffReport {
 /// The command crate can request exact registry/session operations without
 /// receiving database handles or reopening owned paths.
 pub struct MigrationRegistryRuntime {
-    registry:
-        crate::root_seam::daemon::store_runtime::session_registry::DaemonSessionRuntimeRegistryV1,
     profile_database: std::sync::Arc<RegisteredGlobalDb>,
 }
 
@@ -162,10 +160,7 @@ impl MigrationRegistryRuntime {
             )
             .await?;
         let profile_database = registry.profile_database().await?;
-        Ok(Self {
-            registry,
-            profile_database,
-        })
+        Ok(Self { profile_database })
     }
 
     pub async fn registered_project_paths(

crates/tracedecay-runtime-core/Cargo.toml

@@ -89,7 +89,4 @@ unexpected_cfgs = { level = "warn", check-cfg = [
     # Gates the one db::coverage test that drives a real graph query; the
     # `GraphQueryManager` it needs lives above this kernel.
     "cfg(tracedecay_graph_query_tests)",
-    # Gates the two store::memory cutover tests that drive `MemoryApplication`,
-    # which also lives above this kernel.
-    "cfg(tracedecay_memory_application_tests)",
 ] }

crates/tracedecay-runtime-core/SEAMS.md

@@ -188,19 +188,19 @@ refuse a lock while a branch-admin mutation is unfinished.
 
 ### 6. Test coverage parked behind cfgs
 
-Two `cfg` flags were added (declared in the crate's `[lints.rust]
-unexpected_cfgs` check-cfg list) because the types they need live above the
-kernel. Nothing sets them, so these tests do not run anywhere right now:
+One `cfg` flag was added (declared in the crate's `[lints.rust]
+unexpected_cfgs` check-cfg list) because the types it needs live above the
+kernel. Nothing sets it, so this test does not run anywhere right now:
 
 - `tracedecay_graph_query_tests` — `db/coverage.rs`
   `temp_table_lifecycle_uses_the_database_writer` needs
   `graph::queries::GraphQueryManager`.
-- `tracedecay_memory_application_tests` — `store/memory/memory_cutover_test.rs`
-  `cutover_preserves_legacy_usage_telemetry_and_search_ranking` and
-  `dashboard_vector_points_report_v1_entity_link_connections` need
-  `application::memory::MemoryApplication` / `MemoryOperationContext`.
 
-Both should be re-homed into the crate that owns the missing type.
+It should be re-homed into the crate that owns the missing type.
+
+(A second flag, `tracedecay_memory_application_tests`, gated
+`store/memory/memory_cutover_test.rs`; that file went away with the
+legacy-memory cutover removal, and the flag with it.)
 
 ### 7. Visibility promotion is now the kernel's public surface
 

crates/tracedecay-runtime-core/src/memory/types.rs

@@ -28,25 +28,6 @@ impl MemoryCategory {
         }
     }
 
-    /// Strict inverse of [`MemoryCategory::as_str`].
-    ///
-    /// Unlike the [`FromStr`] implementation this accepts only the exact
-    /// canonical labels: no aliases, no case folding, no separator rewriting.
-    /// Durable projections that round-trip a stored label must use this so a
-    /// non-canonical spelling stays a parse failure rather than becoming a
-    /// silently reinterpreted category.
-    pub(crate) fn from_canonical_label(value: &str) -> Option<Self> {
-        match value {
-            "general" => Some(Self::General),
-            "user_pref" => Some(Self::UserPref),
-            "project" => Some(Self::Project),
-            "tool" => Some(Self::Tool),
-            "decision" => Some(Self::Decision),
-            "code_area" => Some(Self::CodeArea),
-            _ => None,
-        }
-    }
-
     pub fn from_proposal_label(value: &str) -> Result<Self, ParseMemoryCategoryError> {
         if let Ok(category) = value.parse::<Self>() {
             return Ok(category);

crates/tracedecay-usecases/src/semantic_runtime/production.rs

@@ -2588,7 +2588,6 @@ mod tests {
         VectorWatermark,
     };
 
-    use tracedecay_runtime_core::db::{DatabaseAuthority, TestDatabaseRuntimeMode};
     use tracedecay_semantic::{
         DaemonSemanticRuntimeHandleV1, FastEmbedSemanticGenerationRequestV1,
         PreparedSemanticRuntimeCommitV1, SemanticGenerationPointerV1,