bamboo-server 2026.7.33

use super::request::{optional_non_empty, resolve_model, resolve_session_id};
use super::sync_runtime_workspace;
use bamboo_agent_core::Session;

use bamboo_engine::session_app::chat::{
    clear_skill_runtime_state, resolve_base_prompt,
    resolve_copilot_conclusion_with_options_enhancement, resolve_enhance_prompt,
    resolve_selected_skill_ids, resolve_workspace_path,
};

/// Regression: `/goal off` and `/goal clear` must clear the stale runtime
/// `goal.state` (status / continuation budget / double-check eval history).
/// Previously the cleanup was gated behind `should_resume`, so only
/// `/goal <prompt>` (set-prompt) reached it and off/clear left it behind —
/// surfacing a stale "complete" badge over the history API.
#[actix_web::test]
async fn goal_off_and_clear_remove_stale_goal_state() {
    use crate::AppState;
    use bamboo_engine::session_app::chat::GoalCommand;
    use tempfile::tempdir;

    const STALE_GOAL_STATE: &str = r#"{"objective":"ship it","status":"complete","continuation_count":2,"eval_history":[{"checkpoint":"terminal","iteration":3,"decision":"achieved","confidence":"high","reasoning":"done","recorded_at":"t"}],"created_at":"t","updated_at":"t"}"#;

    let temp_dir = tempdir().expect("tempdir");
    bamboo_config::paths::init_bamboo_dir(temp_dir.path().to_path_buf());
    let state = AppState::new(temp_dir.path().to_path_buf())
        .await
        .expect("app state");

    for (session_id, cmd) in [
        ("goal-off-test", GoalCommand::Off),
        ("goal-clear-test", GoalCommand::Clear),
    ] {
        // Seed a session carrying a stale, finished goal.state + a spread of
        // stale `gold.*` runtime snapshot keys (incl. ones that were NOT on the
        // old explicit removal list), plus the config key which must survive.
        let mut session = Session::new(session_id, "model");
        session
            .metadata
            .insert("goal.state".to_string(), STALE_GOAL_STATE.to_string());
        for (k, v) in [
            ("gold.evaluation_count", "7"),
            ("gold.last_reasoning", "old reasoning"),
            ("gold.last_checkpoint", "terminal"),
            ("gold.last_iteration", "7"),
            ("gold.last_decision", "achieved"),
        ] {
            session.metadata.insert(k.to_string(), v.to_string());
        }
        state.save_and_cache_session(&mut session).await;

        let _ = super::handle_goal_command(&state, session_id, &cmd).await;

        let reloaded = state
            .storage
            .load_session(session_id)
            .await
            .expect("load")
            .expect("session exists");
        assert!(
            !reloaded.metadata.contains_key("goal.state"),
            "goal.state must be cleared after /goal {cmd:?}"
        );
        assert!(
            !reloaded.metadata.keys().any(|k| k.starts_with("gold.")),
            "no gold.* runtime keys may remain after /goal {cmd:?}"
        );
        // The config (key `gold_config`, no dot) is managed by the handler and
        // must still be present — the prefix wipe must not remove it.
        assert!(
            reloaded.metadata.contains_key("gold_config"),
            "gold_config must be preserved after /goal {cmd:?}"
        );
    }
}

#[test]
fn resolve_model_errors_when_neither_request_nor_default_resolve() {
    let response = resolve_model(Some("   "), None).expect_err("no model should be required error");
    assert_eq!(response.status(), actix_web::http::StatusCode::BAD_REQUEST);
}

#[test]
fn resolve_model_trims_whitespace_from_request_model() {
    let model = resolve_model(Some("  gpt-5  "), None).expect("model should be accepted");
    assert_eq!(model, "gpt-5");
}

/// #480: an absent/blank request model falls back to the server's resolved
/// default rather than erroring, as long as a default is available.
#[test]
fn resolve_model_falls_back_to_default_when_request_model_absent() {
    let model = resolve_model(None, Some("gpt-default")).expect("default should be used");
    assert_eq!(model, "gpt-default");
}

#[test]
fn resolve_model_falls_back_to_default_when_request_model_blank() {
    let model = resolve_model(Some("   "), Some("gpt-default")).expect("default should be used");
    assert_eq!(model, "gpt-default");
}

#[test]
fn resolve_model_prefers_explicit_request_model_over_default() {
    let model =
        resolve_model(Some("gpt-explicit"), Some("gpt-default")).expect("request model wins");
    assert_eq!(model, "gpt-explicit");
}

#[test]
fn optional_non_empty_returns_none_for_blank_string() {
    let value = optional_non_empty(Some("   "));
    assert_eq!(value, None);
}

#[test]
fn resolve_session_id_uses_provided_value_without_trimming() {
    let session_id = resolve_session_id(Some("  existing-id  "));
    assert_eq!(session_id, "  existing-id  ");
}

#[test]
fn resolve_base_prompt_prefers_request_and_persists_metadata() {
    let mut session = Session::new("session-1", "model");
    let base_prompt = resolve_base_prompt(&mut session, Some("request prompt"), "", "fallback");
    assert_eq!(base_prompt, "request prompt");
    assert_eq!(
        session
            .metadata
            .get("base_system_prompt")
            .map(String::as_str),
        Some("request prompt")
    );
}

#[test]
fn resolve_base_prompt_falls_back_to_existing_metadata() {
    let mut session = Session::new("session-1", "model");
    session.metadata.insert(
        "base_system_prompt".to_string(),
        "stored prompt".to_string(),
    );

    let base_prompt = resolve_base_prompt(&mut session, None, "", "fallback");
    assert_eq!(base_prompt, "stored prompt");
}

#[test]
fn resolve_base_prompt_falls_back_to_existing_system_message_before_global_default() {
    let mut session = Session::new("session-1", "model");
    session.add_message(bamboo_agent_core::Message::system("Existing system"));

    let base_prompt = resolve_base_prompt(&mut session, None, "", "global default");
    assert_eq!(base_prompt, "Existing system");
    assert_eq!(
        session
            .metadata
            .get("base_system_prompt")
            .map(String::as_str),
        Some("Existing system")
    );
}

#[test]
fn resolve_base_prompt_uses_global_default_when_missing_everywhere() {
    let mut session = Session::new("session-1", "model");
    let base_prompt = resolve_base_prompt(&mut session, None, "", "global default");
    assert_eq!(base_prompt, "global default");
    assert_eq!(
        session
            .metadata
            .get("base_system_prompt")
            .map(String::as_str),
        Some("global default")
    );
}

#[test]
fn resolve_workspace_path_uses_request_then_metadata() {
    let mut session = Session::new("session-1", "model");

    let from_request = resolve_workspace_path(&mut session, Some("/tmp/workspace"), None);
    assert_eq!(from_request.as_deref(), Some("/tmp/workspace"));
    assert_eq!(
        session.metadata.get("workspace_path").map(String::as_str),
        Some("/tmp/workspace")
    );

    let from_metadata = resolve_workspace_path(&mut session, None, None);
    assert_eq!(from_metadata.as_deref(), Some("/tmp/workspace"));
}

// NOTE: the default-work-area disk fallback used to be tested here, but it's now
// gated on NO workspace provider being registered (#38/#131) — and the provider
// is a process-global first-wins OnceLock that sibling AppState tests populate,
// so a fallback assertion can't be deterministic in the server test binary. The
// disk fallback is unit-tested directly + deterministically in bamboo-engine's
// session_app::chat (default_workspace_from_data_dir_reads_configured_work_area).

#[test]
fn sync_runtime_workspace_persists_workspace_for_tools() {
    let temp_dir = tempfile::tempdir().expect("temp dir should be created");
    let workspace = temp_dir.path().join("workspace");
    std::fs::create_dir_all(&workspace).expect("workspace should exist");
    let session_id = "session-runtime-workspace";

    sync_runtime_workspace(session_id, Some(workspace.to_string_lossy().as_ref()));

    let resolved = bamboo_tools::tools::workspace_state::get_workspace(session_id)
        .expect("workspace should be stored");
    assert_eq!(resolved, workspace.canonicalize().unwrap_or(workspace));
}

#[test]
fn resolve_enhance_prompt_stores_and_clears_metadata() {
    let mut session = Session::new("session-1", "model");

    resolve_enhance_prompt(&mut session, Some("Extra guidance"));
    assert_eq!(
        session.metadata.get("enhance_prompt").map(String::as_str),
        Some("Extra guidance")
    );

    resolve_enhance_prompt(&mut session, None);
    assert!(!session.metadata.contains_key("enhance_prompt"));
}

#[test]
fn resolve_copilot_conclusion_with_options_enhancement_enabled_stores_and_clears_metadata() {
    let mut session = Session::new("session-1", "model");

    resolve_copilot_conclusion_with_options_enhancement(&mut session, Some(true));
    assert_eq!(
        session
            .metadata
            .get("copilot_conclusion_with_options_enhancement_enabled")
            .map(String::as_str),
        Some("true")
    );

    resolve_copilot_conclusion_with_options_enhancement(&mut session, Some(false));
    assert_eq!(
        session
            .metadata
            .get("copilot_conclusion_with_options_enhancement_enabled")
            .map(String::as_str),
        Some("false")
    );

    resolve_copilot_conclusion_with_options_enhancement(&mut session, None);
    assert!(!session
        .metadata
        .contains_key("copilot_conclusion_with_options_enhancement_enabled"));
}

#[test]
fn resolve_selected_skill_ids_prefers_structured_request_and_persists_as_json() {
    let mut session = Session::new("session-1", "model");
    resolve_selected_skill_ids(
        &mut session,
        Some(&[
            "pdf".to_string(),
            "skill-creator".to_string(),
            "pdf".to_string(),
        ]),
        "hello",
    );

    let stored = session
        .metadata
        .get("selected_skill_ids")
        .map(String::as_str);
    assert_eq!(stored, Some("[\"pdf\",\"skill-creator\"]"));
}

#[test]
fn resolve_selected_skill_ids_falls_back_to_legacy_hint_when_structured_field_absent() {
    let mut session = Session::new("session-1", "model");
    resolve_selected_skill_ids(
        &mut session,
        None,
        "[User explicitly selected skill: PDF Skill (ID: pdf)]\n\nPlease parse this file",
    );

    let stored = session
        .metadata
        .get("selected_skill_ids")
        .map(String::as_str);
    assert_eq!(stored, Some("[\"pdf\"]"));
}

#[test]
fn resolve_selected_skill_ids_clears_stale_metadata_when_no_selection_provided() {
    let mut session = Session::new("session-1", "model");
    session
        .metadata
        .insert("selected_skill_ids".to_string(), "[\"pdf\"]".to_string());

    resolve_selected_skill_ids(&mut session, None, "normal prompt");
    assert!(!session.metadata.contains_key("selected_skill_ids"));
}

#[test]
fn clear_skill_runtime_state_removes_loaded_skill_markers() {
    let mut session = Session::new("session-1", "model");
    session.metadata.insert(
        "skill_runtime_loaded_skill_ids".to_string(),
        r#"["demo"]"#.to_string(),
    );
    session.metadata.insert(
        "skill_runtime_last_loaded_skill_id".to_string(),
        "demo".to_string(),
    );

    clear_skill_runtime_state(&mut session);

    assert!(!session
        .metadata
        .contains_key("skill_runtime_loaded_skill_ids"));
    assert!(!session
        .metadata
        .contains_key("skill_runtime_last_loaded_skill_id"));
}

// ---- #480: POST /chat with an omitted `model` end-to-end ----

mod optional_model_e2e {
    use actix_web::{http::StatusCode, test, web, App};
    use bamboo_agent_core::Session;
    use serde_json::Value;
    use tempfile::tempdir;

    use crate::routes::configure_routes;
    use crate::AppState;

    async fn new_state() -> web::Data<AppState> {
        let temp_dir = tempdir().expect("tempdir").keep();
        bamboo_config::paths::init_bamboo_dir(temp_dir.clone());
        web::Data::new(AppState::new(temp_dir).await.expect("app state"))
    }

    /// #480: omitting `model` on `POST /chat` falls back to the server's
    /// resolved default (the same resolution `GET /execute/defaults` and the
    /// connect bridge use) — the session ends up with the CONFIGURED default
    /// model, not an error and not an empty model.
    #[actix_web::test]
    async fn chat_without_model_uses_resolved_default_model() {
        let state = new_state().await;
        {
            let mut config = state.config.write().await;
            config.provider = "openai".to_string();
            config.providers_mut().openai = Some(bamboo_config::OpenAIConfig {
                model: Some("gpt-configured-default".to_string()),
                ..Default::default()
            });
        }

        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let resp = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({ "message": "hello" }))
                .to_request(),
        )
        .await;

        assert_eq!(resp.status(), StatusCode::CREATED);
        let body: Value = test::read_body_json(resp).await;
        let session_id = body["session_id"].as_str().expect("session_id").to_string();

        let session = state
            .storage
            .load_session(&session_id)
            .await
            .expect("load")
            .expect("session exists");
        assert_eq!(session.model, "gpt-configured-default");
    }

    /// An explicit `model` on `POST /chat` is unchanged by #480 — it is used
    /// as-is even when a different server default is configured.
    #[actix_web::test]
    async fn chat_with_explicit_model_is_unchanged() {
        let state = new_state().await;
        {
            let mut config = state.config.write().await;
            config.provider = "openai".to_string();
            config.providers_mut().openai = Some(bamboo_config::OpenAIConfig {
                model: Some("gpt-configured-default".to_string()),
                ..Default::default()
            });
        }

        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let resp = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "message": "hello",
                    "model": "gpt-explicit-override"
                }))
                .to_request(),
        )
        .await;

        assert_eq!(resp.status(), StatusCode::CREATED);
        let body: Value = test::read_body_json(resp).await;
        let session_id = body["session_id"].as_str().expect("session_id").to_string();

        let session = state
            .storage
            .load_session(&session_id)
            .await
            .expect("load")
            .expect("session exists");
        assert_eq!(session.model, "gpt-explicit-override");
    }

    /// No request model AND no server default configured → 400, not a silent
    /// empty-model session.
    #[actix_web::test]
    async fn chat_without_model_and_without_default_errors() {
        let state = new_state().await;

        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let resp = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({ "message": "hello" }))
                .to_request(),
        )
        .await;

        assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
    }

    #[actix_web::test]
    async fn chat_checks_nested_workspace_owner_before_creating_session() {
        let state = new_state().await;
        let workspace = tempdir().expect("workspace");
        let nested = workspace.path().join("nested");
        std::fs::create_dir_all(&nested).expect("nested");
        let owner = state
            .project_store
            .create_with_bindings(
                "Owner",
                None,
                vec![bamboo_domain::WorkspaceBinding {
                    path: workspace.path().to_string_lossy().to_string(),
                    label: None,
                    git_common_dir: None,
                }],
            )
            .expect("Project");
        let nested = nested.to_string_lossy().to_string();
        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let conflict = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": "chat-cross-project",
                    "message": "must not persist",
                    "model": "test-model",
                    "workspace_path": nested.clone(),
                }))
                .to_request(),
        )
        .await;
        assert_eq!(conflict.status(), StatusCode::CONFLICT);
        let conflict: Value = test::read_body_json(conflict).await;
        assert_eq!(conflict["error"]["code"], "project_workspace_conflict");
        assert!(
            state
                .storage
                .load_session("chat-cross-project")
                .await
                .expect("load")
                .is_none(),
            "ownership failure must happen before session persistence"
        );

        let mut feed = state.account_sink.subscribe();
        let created = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": "chat-owned-project",
                    "project_id": owner.id.to_string(),
                    "message": "hello",
                    "model": "test-model",
                    "workspace_path": nested,
                }))
                .to_request(),
        )
        .await;
        assert_eq!(created.status(), StatusCode::CREATED);
        let created_event = tokio::time::timeout(std::time::Duration::from_secs(1), feed.recv())
            .await
            .expect("SessionCreated timeout")
            .expect("SessionCreated event");
        assert!(matches!(
            &created_event.event,
            bamboo_agent_core::AgentEvent::SessionCreated {
                session_id,
                project_id: Some(project_id),
                ..
            } if session_id == "chat-owned-project" && project_id == owner.id.as_str()
        ));
        let replay = bamboo_engine::events::journal::read_since(
            state.account_sink.events_dir(),
            created_event.seq.saturating_sub(1),
        )
        .expect("journal replay");
        assert!(replay.iter().any(|change| matches!(
            &change.event,
            bamboo_agent_core::AgentEvent::SessionCreated {
                session_id,
                project_id: Some(project_id),
                ..
            } if session_id == "chat-owned-project" && project_id == owner.id.as_str()
        )));
        let session = state
            .storage
            .load_session("chat-owned-project")
            .await
            .expect("load")
            .expect("session");
        let resolved = state
            .project_context_resolver
            .resolve(&session, None)
            .await
            .expect("resolve persisted Project context")
            .expect("assigned Project context");
        assert_eq!(
            resolved.binding_status,
            bamboo_engine::project_context::WorkspaceBindingStatus::Registered
        );
        let snapshot = session.prompt_snapshot.expect("immediate prompt snapshot");
        assert!(snapshot
            .project_context
            .as_deref()
            .is_some_and(|context| context.contains(owner.id.as_str())));
        assert_eq!(
            snapshot
                .effective_system_prompt
                .matches("<!-- BAMBOO_PROJECT_CONTEXT_START -->")
                .count(),
            1
        );
        assert!(
            snapshot
                .workspace_context
                .as_deref()
                .is_some_and(|context| context.contains("Binding status: registered")),
            "unexpected workspace context: {:?}",
            snapshot.workspace_context
        );
    }

    #[actix_web::test]
    async fn chat_invalid_workspace_is_400_and_has_no_session_side_effect() {
        let state = new_state().await;
        let fixture = tempdir().expect("fixture");
        let missing = fixture.path().join("missing");
        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let response = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": "chat-invalid-workspace",
                    "message": "must not persist",
                    "model": "test-model",
                    "workspace_path": missing,
                }))
                .to_request(),
        )
        .await;
        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
        let body: Value = test::read_body_json(response).await;
        assert_eq!(body["error"]["code"], "workspace_not_found");
        assert!(state
            .storage
            .load_session("chat-invalid-workspace")
            .await
            .expect("load")
            .is_none());
    }

    #[actix_web::test]
    async fn queued_chat_omitting_workspace_preserves_authoritative_workspace_update() {
        let state = new_state().await;
        let fixture = tempdir().expect("fixture");
        let workspace_a = fixture.path().join("workspace-a");
        let workspace_b = fixture.path().join("workspace-b");
        std::fs::create_dir_all(&workspace_a).unwrap();
        std::fs::create_dir_all(&workspace_b).unwrap();
        let session_id = "chat-workspace-lock-barrier";
        let mut session = Session::new(session_id, "test-model");
        session.set_workspace_path_meta(workspace_a.to_string_lossy().into_owned());
        state.storage.save_session(&session).await.unwrap();
        state.sessions.insert(
            session_id.to_string(),
            std::sync::Arc::new(parking_lot::RwLock::new(session)),
        );
        bamboo_agent_core::workspace_state::set_workspace(
            session_id,
            workspace_a.canonicalize().unwrap(),
        );
        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        // Hold the same lock used by Workspace/PATCH writes. Poll chat until it
        // reaches the lock after its lock-free preflight, then commit workspace
        // B before allowing chat's authoritative reload to proceed.
        let guard = state.persistence.acquire_lock(session_id).await;
        let chat = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": session_id,
                    "message": "workspace field intentionally omitted",
                    "model": "test-model"
                }))
                .to_request(),
        );
        tokio::pin!(chat);
        assert!(
            tokio::time::timeout(std::time::Duration::from_millis(200), &mut chat)
                .await
                .is_err(),
            "chat should wait at the per-session transaction lock"
        );

        let mut latest = state
            .persistence
            .storage()
            .load_session(session_id)
            .await
            .unwrap()
            .unwrap();
        latest.set_workspace_path_meta(workspace_b.to_string_lossy().into_owned());
        state
            .persistence
            .storage()
            .save_session(&latest)
            .await
            .unwrap();
        state.sessions.insert(
            session_id.to_string(),
            std::sync::Arc::new(parking_lot::RwLock::new(latest)),
        );
        bamboo_agent_core::workspace_state::set_workspace(
            session_id,
            workspace_b.canonicalize().unwrap(),
        );
        drop(guard);

        let response = chat.await;
        assert_eq!(response.status(), StatusCode::CREATED);
        let persisted = state
            .storage
            .load_session(session_id)
            .await
            .unwrap()
            .unwrap();
        let workspace_b = workspace_b.canonicalize().unwrap();
        assert_eq!(
            persisted.workspace_path_meta().as_deref(),
            Some(bamboo_config::paths::path_to_display_string(&workspace_b).as_str())
        );
        assert_eq!(
            bamboo_agent_core::workspace_state::get_workspace(session_id).as_deref(),
            Some(workspace_b.as_path())
        );
    }

    #[actix_web::test]
    async fn chat_membership_authority_is_durable_storage_not_stale_cache() {
        let state = new_state().await;
        let project_a = state.project_store.create("Project A", None).unwrap();
        let project_b = state.project_store.create("Project B", None).unwrap();
        let session_id = "chat-authoritative-project-storage";
        let mut durable = Session::new(session_id, "test-model");
        durable.set_project_id_meta(project_b.id.to_string());
        state.storage.save_session(&durable).await.unwrap();
        let mut stale_cache = durable.clone();
        stale_cache.set_project_id_meta(project_a.id.to_string());
        stale_cache.updated_at = chrono::Utc::now() + chrono::Duration::hours(1);
        state.sessions.insert(
            session_id.to_string(),
            std::sync::Arc::new(parking_lot::RwLock::new(stale_cache)),
        );
        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let response = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": session_id,
                    "message": "use durable membership",
                    "model": "test-model"
                }))
                .to_request(),
        )
        .await;
        assert_eq!(response.status(), StatusCode::CREATED);
        let persisted = state
            .storage
            .load_session(session_id)
            .await
            .unwrap()
            .unwrap();
        assert_eq!(
            persisted.project_id_meta().as_deref(),
            Some(project_b.id.as_str())
        );
    }

    #[actix_web::test]
    async fn chat_validates_configured_default_workspace_before_session_side_effects() {
        let state = new_state().await;
        let workspace = tempdir().expect("default workspace");
        let owner = state
            .project_store
            .create_with_bindings(
                "Default Owner",
                None,
                vec![bamboo_domain::WorkspaceBinding {
                    path: workspace.path().to_string_lossy().into_owned(),
                    label: None,
                    git_common_dir: None,
                }],
            )
            .expect("owner Project");
        let other = state
            .project_store
            .create("Other Project", None)
            .expect("other Project");
        state.config.write().await.default_work_area = Some(bamboo_config::DefaultWorkAreaConfig {
            path: Some(workspace.path().to_string_lossy().into_owned()),
        });
        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let response = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": "chat-default-conflict",
                    "project_id": other.id.to_string(),
                    "message": "must not persist",
                    "model": "test-model"
                }))
                .to_request(),
        )
        .await;
        assert_eq!(response.status(), StatusCode::CONFLICT);
        let body: Value = test::read_body_json(response).await;
        assert_eq!(body["error"]["code"], "project_workspace_conflict");
        assert_eq!(body["owner_project_id"], owner.id.as_str());
        assert!(state
            .storage
            .load_session("chat-default-conflict")
            .await
            .expect("load")
            .is_none());
        assert!(
            bamboo_agent_core::workspace_state::peek_workspace("chat-default-conflict").is_none()
        );
    }

    #[actix_web::test]
    async fn chat_persists_same_project_configured_default_and_prompt_marker() {
        let state = new_state().await;
        let workspace = tempdir().expect("default workspace");
        let project = state
            .project_store
            .create_with_bindings(
                "Default Owner",
                None,
                vec![bamboo_domain::WorkspaceBinding {
                    path: workspace.path().to_string_lossy().into_owned(),
                    label: None,
                    git_common_dir: None,
                }],
            )
            .expect("Project");
        state.config.write().await.default_work_area = Some(bamboo_config::DefaultWorkAreaConfig {
            path: Some(workspace.path().to_string_lossy().into_owned()),
        });
        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;

        let response = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": "chat-default-owned",
                    "project_id": project.id.to_string(),
                    "message": "hello",
                    "model": "test-model"
                }))
                .to_request(),
        )
        .await;
        assert_eq!(response.status(), StatusCode::CREATED);
        let canonical = workspace.path().canonicalize().expect("canonical");
        let canonical_display = bamboo_config::paths::path_to_display_string(&canonical);
        let session = state
            .storage
            .load_session("chat-default-owned")
            .await
            .expect("load")
            .expect("session");
        assert_eq!(
            session.workspace_path_meta().as_deref(),
            Some(canonical_display.as_str())
        );
        assert_eq!(
            bamboo_agent_core::workspace_state::get_workspace("chat-default-owned").as_deref(),
            Some(canonical.as_path())
        );
        let snapshot = session.prompt_snapshot.expect("prompt snapshot");
        assert!(snapshot
            .workspace_context
            .as_deref()
            .is_some_and(|value| value.contains("Binding status: registered")));
        assert_eq!(
            snapshot
                .effective_system_prompt
                .matches("BAMBOO_WORKSPACE_CONTEXT_START")
                .count(),
            1
        );
    }

    #[actix_web::test]
    async fn user_prompt_submit_block_returns_reason_and_persists_no_user_message() {
        let state = new_state().await;
        {
            let mut config = state.config.write().await;
            config.lifecycle_hooks = bamboo_config::LifecycleHooksConfig {
                enabled: true,
                user_prompt_submit: vec![bamboo_config::LifecycleHookGroup {
                    enabled: true,
                    matcher: None,
                    hooks: vec![bamboo_config::LifecycleHookCommand {
                        hook_type: bamboo_config::LifecycleHookType::Command,
                        command: "printf 'prompt rejected by policy' >&2; exit 2".to_string(),
                        timeout_ms: bamboo_config::DEFAULT_LIFECYCLE_HOOK_TIMEOUT_MS,
                    }],
                }],
                ..Default::default()
            };
        }

        let app = test::init_service(
            App::new()
                .app_data(state.clone())
                .configure(configure_routes),
        )
        .await;
        let response = test::call_service(
            &app,
            test::TestRequest::post()
                .uri("/api/v1/chat")
                .set_json(serde_json::json!({
                    "session_id": "blocked-user-prompt",
                    "message": "must not persist",
                    "model": "test-model"
                }))
                .to_request(),
        )
        .await;

        assert_eq!(response.status(), StatusCode::BAD_REQUEST);
        let body: Value = test::read_body_json(response).await;
        assert!(body.to_string().contains("prompt rejected by policy"));
        assert_eq!(body["hook_event"], "UserPromptSubmit");

        let session = state
            .storage
            .load_session("blocked-user-prompt")
            .await
            .expect("load")
            .expect("prepared session is persisted for hook observability");
        assert!(session
            .messages
            .iter()
            .all(|message| !matches!(message.role, bamboo_agent_core::Role::User)));
        assert_eq!(
            session
                .agent_runtime_state
                .as_ref()
                .map(|state| state.checkpoints.len()),
            Some(1)
        );
    }
}