Method open_with_options

src/tracedecay/lifecycle.rs:193–324

(
        project_root: &Path,
        open_options: TraceDecayOpenOptions,
    )

    }

    pub async fn open_with_options(
        project_root: &Path,
        open_options: TraceDecayOpenOptions,
    ) -> Result<Self> {
        let store_layout =
            Self::resolve_store_layout_for_project(project_root, &open_options).await?;
        let config = load_config_from_path(project_root, &store_layout.config_path)?;
        let active_branch = branch::current_branch(project_root);
        Self::auto_track_active_branch(
            project_root,
            &store_layout.data_root,
            active_branch.as_deref(),
            open_options.clone(),
        )
        .await?;

        let (db_path, serving_branch, fallback_warning) = Self::resolve_db_for_branch(
            project_root,
            &store_layout.data_root,
            active_branch.as_deref(),
        );

        if !db_path.exists() {
            return Err(TraceDecayError::Config {
                message: format!(
                    "no TraceDecay database found at '{}'; run 'tracedecay init' first",
                    db_path.display()
                ),
            });
        }

        // If the dirty sentinel exists, a previous sync/index was interrupted.
        // Check integrity and rebuild if necessary.
        let crashed = has_dirty_sentinel_at(&store_layout.dirty_path);
        if crashed {
            eprintln!(
                "[tracedecay] previous operation was interrupted — checking database integrity…"
            );
        }

        // Try to open; if the database is completely unreadable, delete and
        // re-initialize rather than failing permanently.
        let open_result = Database::open(&db_path).await;
        let (db, migrated) = match open_result {
            Ok(pair) => pair,
            Err(ref e) if Database::is_corruption_error(e) || crashed => {
                print_corruption_warning();
                delete_db_files(&db_path);
                clear_dirty_sentinel_at(&store_layout.dirty_path);
                let (db, _) = Database::initialize(&db_path).await?;
                let ts = Self {
                    db,
                    config,
                    project_root: project_root.to_path_buf(),
                    store_layout: store_layout.clone(),
                    open_options: open_options.clone(),
                    registry: LanguageRegistry::new(),
                    active_branch: active_branch.clone(),