a3s 0.10.8

use super::*;

struct TuiTestSandbox {
    workspace: PathBuf,
}

struct ConfirmationEscalatingTool {
    executed: Arc<std::sync::atomic::AtomicBool>,
}

#[async_trait::async_trait]
impl a3s_code_core::tools::Tool for ConfirmationEscalatingTool {
    fn name(&self) -> &str {
        "mcp__test__external_side_effect_probe"
    }

    fn description(&self) -> &str {
        "Test-only external side effect."
    }

    fn parameters(&self) -> serde_json::Value {
        serde_json::json!({
            "type": "object",
            "additionalProperties": false
        })
    }

    fn requires_confirmation(&self, _args: &serde_json::Value) -> bool {
        true
    }

    async fn execute(
        &self,
        _args: &serde_json::Value,
        _ctx: &a3s_code_core::tools::ToolContext,
    ) -> anyhow::Result<a3s_code_core::tools::ToolOutput> {
        self.executed
            .store(true, std::sync::atomic::Ordering::SeqCst);
        Ok(a3s_code_core::tools::ToolOutput::success("executed"))
    }
}

#[async_trait::async_trait]
impl a3s_code_core::sandbox::BashSandbox for TuiTestSandbox {
    async fn exec_command(
        &self,
        command: &str,
        _guest_workspace: &str,
    ) -> anyhow::Result<a3s_code_core::sandbox::SandboxOutput> {
        let output = tokio::process::Command::new("bash")
            .arg("-c")
            .arg(command)
            .current_dir(&self.workspace)
            .output()
            .await?;
        Ok(a3s_code_core::sandbox::SandboxOutput {
            stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
            stderr: String::from_utf8_lossy(&output.stderr).into_owned(),
            exit_code: output.status.code().unwrap_or(-1),
        })
    }

    async fn shutdown(&self) {}
}

fn sandboxed_tui_execution_policy(mode: Mode, workspace: &Path) -> TuiExecutionPolicy {
    TuiExecutionPolicy::for_workspace(
        mode,
        workspace.to_path_buf(),
        Some(Arc::new(TuiTestSandbox {
            workspace: workspace.to_path_buf(),
        })),
    )
}

#[test]
fn ultracode_tick_state_chain_is_time_bounded() {
    assert_eq!(
        ultracode_tick_action(Some(Duration::ZERO), None),
        UltracodeTickAction::ContinueConfirm
    );
    assert_eq!(
        ultracode_tick_action(Some(ULTRACODE_CONFIRM_ANIMATION), None),
        UltracodeTickAction::BeginRebuild
    );
    assert_eq!(
        ultracode_tick_action(None, Some(Duration::ZERO)),
        UltracodeTickAction::ContinueBorder
    );
    assert_eq!(
        ultracode_tick_action(None, Some(ULTRACODE_BORDER_ANIMATION)),
        UltracodeTickAction::ClearBorder
    );
    assert_eq!(ultracode_tick_action(None, None), UltracodeTickAction::Idle);
}

#[test]
fn ultracode_epoch_rejects_a_tick_from_before_cancel_and_reopen() {
    let mut current_epoch = 0;
    let stale_tick = advance_ultracode_animation_epoch(&mut current_epoch);
    let cancelled_epoch = advance_ultracode_animation_epoch(&mut current_epoch);
    let active_tick = advance_ultracode_animation_epoch(&mut current_epoch);

    assert_ne!(cancelled_epoch, active_tick);
    assert!(!ultracode_tick_is_current(current_epoch, stale_tick));
    assert!(ultracode_tick_is_current(current_epoch, active_tick));
}

#[test]
fn ultracode_border_starts_only_after_a_successful_matching_rebuild() {
    assert!(ultracode_rebuild_starts_border(Some(ULTRACODE), true));
    assert!(!ultracode_rebuild_starts_border(Some(ULTRACODE), false));
    assert!(!ultracode_rebuild_starts_border(
        Some(ULTRACODE.saturating_sub(1)),
        true
    ));
    assert!(!ultracode_rebuild_starts_border(None, true));
}

#[test]
fn history_recall_restores_scratch_draft_after_navigation() {
    let history = vec!["first".to_string(), "second".to_string()];
    let mut position = None;
    let mut draft = None;

    assert_eq!(
        history_recall_value(&history, &mut position, &mut draft, "unfinished", true),
        Some("second".to_string())
    );
    assert_eq!(position, Some(1));
    assert_eq!(draft.as_deref(), Some("unfinished"));

    assert_eq!(
        history_recall_value(&history, &mut position, &mut draft, "edited", true),
        Some("first".to_string())
    );
    assert_eq!(
        history_recall_value(&history, &mut position, &mut draft, "first", false),
        Some("second".to_string())
    );
    assert_eq!(
        history_recall_value(&history, &mut position, &mut draft, "second", false),
        Some("unfinished".to_string())
    );
    assert_eq!(position, None);
    assert_eq!(draft, None);
}

#[test]
fn history_recall_restores_an_empty_scratch_draft() {
    let history = vec!["last".to_string()];
    let mut position = None;
    let mut draft = None;

    assert_eq!(
        history_recall_value(&history, &mut position, &mut draft, "", true),
        Some("last".to_string())
    );
    assert_eq!(
        history_recall_value(&history, &mut position, &mut draft, "last", false),
        Some(String::new())
    );
    assert_eq!(position, None);
    assert_eq!(draft, None);
}

#[test]
fn history_recall_down_is_a_noop_when_not_browsing() {
    let history = vec!["last".to_string()];
    let mut position = None;
    let mut draft = Some("kept".to_string());

    assert_eq!(
        history_recall_value(&history, &mut position, &mut draft, "current", false),
        None
    );
    assert_eq!(position, None);
    assert_eq!(draft.as_deref(), Some("kept"));
}

#[test]
fn prompt_mode_escape_yields_to_streaming_interrupt() {
    let escape = KeyEvent {
        code: KeyCode::Esc,
        modifiers: KeyModifiers::NONE,
    };

    assert!(!should_exit_prompt_mode(
        &State::Streaming,
        true,
        false,
        &escape
    ));
    assert!(should_exit_prompt_mode(&State::Idle, true, false, &escape));
    assert!(should_exit_prompt_mode(&State::Idle, false, true, &escape));
}

fn rgb(color: Color) -> (u8, u8, u8) {
    match color {
        Color::Rgb(r, g, b) => (r, g, b),
        other => panic!("expected RGB color, got {other:?}"),
    }
}

fn contains_cjk(s: &str) -> bool {
    s.chars().any(|ch| {
        ('\u{3400}'..='\u{4dbf}').contains(&ch)
            || ('\u{4e00}'..='\u{9fff}').contains(&ch)
            || ('\u{f900}'..='\u{faff}').contains(&ch)
    })
}

#[test]
fn deep_research_digest_uses_reader_facing_ellipsis() {
    let truncated = deep_research_truncate_chars("abcdef", 3);
    assert_eq!(truncated, "abc…");
    assert!(!truncated.contains("[truncated]"));
}

#[test]
fn resumed_history_reconstructs_tool_cells_in_message_order() {
    let history = vec![
        Message::user("inspect the workspace"),
        Message {
            role: "assistant".to_string(),
            content: vec![
                ContentBlock::Text {
                    text: "I'll inspect it.".to_string(),
                },
                ContentBlock::ToolUse {
                    id: "call-1".to_string(),
                    name: "bash".to_string(),
                    input: serde_json::json!({"command": "pwd"}),
                },
            ],
            reasoning_content: None,
        },
        Message::tool_result("call-1", "/tmp/project\n", false),
        Message::assistant("Done."),
    ];

    let entries = resumed_transcript_entries(&history);
    let kinds = entries
        .iter()
        .map(|entry| match entry {
            TranscriptEntry::User { .. } => "user",
            TranscriptEntry::AssistantMarkdown { .. } => "assistant",
            TranscriptEntry::Reasoning { .. } => "reasoning",
            TranscriptEntry::Tool(_) => "tool",
            TranscriptEntry::Subagent(_) => "subagent",
            TranscriptEntry::Preformatted(_) | TranscriptEntry::Notice { .. } => "notice",
        })
        .collect::<Vec<_>>();
    assert_eq!(kinds, ["user", "assistant", "tool", "assistant"]);

    let mut transcript = Transcript::from_entries(entries);
    let plain = a3s_tui::style::strip_ansi(&transcript.render(100, 99).join("\n\n"));
    assert!(plain.contains("inspect the workspace"), "{plain}");
    assert!(plain.contains("I'll inspect it."), "{plain}");
    assert!(plain.contains("• Ran pwd"), "{plain}");
    assert!(plain.contains("/tmp/project"), "{plain}");
    assert!(plain.contains("Done."), "{plain}");
}

#[test]
fn stale_background_watcher_cannot_write_into_rebuilt_session() {
    assert!(subagent_watch_is_current("session-a", 4, "session-a", 4));
    assert!(!subagent_watch_is_current("session-b", 4, "session-a", 4));
    assert!(!subagent_watch_is_current("session-a", 5, "session-a", 4));
}

#[test]
fn late_subagent_snapshot_cannot_restore_footer_after_deep_research_settlement() {
    let snapshot_request_before_settlement = 7;
    let invalidated_request = 8;

    assert!(!subagent_snapshot_is_current(
        "session-a",
        4,
        invalidated_request,
        false,
        "session-a",
        4,
        snapshot_request_before_settlement,
    ));
    assert!(!subagent_snapshot_is_current(
        "session-a",
        4,
        invalidated_request,
        true,
        "session-a",
        4,
        invalidated_request,
    ));
    assert!(subagent_snapshot_is_current(
        "session-a",
        4,
        invalidated_request,
        false,
        "session-a",
        4,
        invalidated_request,
    ));
}

#[test]
fn use_subagent_capability_identity_reaches_live_and_completed_tui_surfaces() {
    let mut projection = RuntimeProjection::default();
    let now = Instant::now();
    projection.restore_subagent(
        "use-restored".into(),
        "use".into(),
        "Inspect the application".into(),
        now,
        false,
    );
    projection.record_subagent_progress(
        "use-restored",
        &serde_json::json!({
            "tool": "mcp__use_browser__agent_browser_open",
            "exit_code": 0
        }),
    );

    let live = projection.subagents()[0];
    let live_view = a3s_tui::components::SubagentTracker::new("Application work")
        .row(a3s_tui::components::SubagentRow::new(
            live.display_agent(),
            live.description.clone(),
        ))
        .view(80);
    let live_plain = a3s_tui::style::strip_ansi(&live_view);
    assert!(live_plain.contains("Using Browser"), "{live_plain}");
    assert!(!live_plain.contains("mcp__use_"), "{live_plain}");

    let completed = projection.end_subagent(
        "use-restored".into(),
        "use".into(),
        "Browser evidence collected.".into(),
        true,
        now,
    );
    let mut transcript = Transcript::default();
    transcript.finish_subagent_with_outcome(
        completed.task_id,
        completed.display_agent,
        completed.description,
        completed.outcome,
        completed.output,
        true,
    );
    let completed_plain = a3s_tui::style::strip_ansi(
        &transcript
            .render_transcript_with_activity(80, 76, false)
            .join("\n"),
    );
    assert!(
        completed_plain.contains("Used Browser"),
        "{completed_plain}"
    );
    assert!(!completed_plain.contains("mcp__use_"), "{completed_plain}");
}

async fn deep_research_settlement_test_session(label: &str) -> (Arc<AgentSession>, PathBuf) {
    let dir = std::env::temp_dir().join(format!(
        "a3s-deep-research-settlement-{label}-{}-{}",
        std::process::id(),
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("clock")
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).expect("temp workspace");
    let cfg = dir.join("config.acl");
    test_config(&cfg);
    let agent = Agent::new(cfg.to_string_lossy().to_string())
        .await
        .expect("agent");
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), None)
        .await
        .expect("session");
    (Arc::new(session), dir)
}

#[tokio::test]
async fn deep_research_completion_cancels_live_children_before_closing_footer() {
    use a3s_code_core::SubagentStatus;
    use tokio_util::sync::CancellationToken;

    let (session, dir) = deep_research_settlement_test_session("cancel").await;
    let parent_session_id = session.session_id().to_string();
    let tracker = session.subagent_tracker();
    tracker
        .record_event(&AgentEvent::SubagentStart {
            task_id: "research-live".to_string(),
            session_id: "research-child".to_string(),
            parent_session_id: parent_session_id.clone(),
            agent: "deep-research".to_string(),
            description: "Research route A".to_string(),
            started_ms: 1,
        })
        .await;
    let cancellation = CancellationToken::new();
    tracker
        .register_canceller("research-live", cancellation.clone())
        .await;

    let result = settle_deep_research_subagents(
        Arc::clone(&session),
        parent_session_id.clone(),
        7,
        vec!["research-live".to_string()],
        DeepResearchSettlementExit::ReportReady,
    )
    .await;
    let a3s_tui::cmd::CmdResult::Msg(Msg::DeepResearchSubagentsSettled {
        session_id,
        generation,
        exit,
        settlements,
    }) = result
    else {
        panic!("expected DeepResearchSubagentsSettled");
    };

    assert_eq!(session_id, parent_session_id);
    assert_eq!(generation, 7);
    assert_eq!(exit, DeepResearchSettlementExit::ReportReady);
    assert!(exit.opens_report());
    assert!(cancellation.is_cancelled());
    assert_eq!(settlements.len(), 1);
    assert_eq!(settlements[0].task_id, "research-live");
    assert_eq!(settlements[0].outcome, SubagentOutcome::Cancelled);
    assert_eq!(
        tracker.get("research-live").await.unwrap().status,
        SubagentStatus::Cancelled
    );
    let _ = std::fs::remove_dir_all(dir);
}

#[tokio::test]
async fn deep_research_completion_terminalizes_a_child_whose_tracking_was_lost() {
    use a3s_code_core::SubagentStatus;

    let (session, dir) = deep_research_settlement_test_session("tracking-lost").await;
    let parent_session_id = session.session_id().to_string();
    let tracker = session.subagent_tracker();
    tracker
        .record_event(&AgentEvent::SubagentStart {
            task_id: "research-orphan".to_string(),
            session_id: "orphan-child".to_string(),
            parent_session_id: parent_session_id.clone(),
            agent: "deep-research".to_string(),
            description: "Research route B".to_string(),
            started_ms: 1,
        })
        .await;

    let result = settle_deep_research_subagents(
        Arc::clone(&session),
        parent_session_id,
        8,
        vec!["research-orphan".to_string()],
        DeepResearchSettlementExit::ReportReady,
    )
    .await;
    let a3s_tui::cmd::CmdResult::Msg(Msg::DeepResearchSubagentsSettled { settlements, .. }) =
        result
    else {
        panic!("expected DeepResearchSubagentsSettled");
    };

    assert_eq!(settlements.len(), 1);
    assert_eq!(settlements[0].task_id, "research-orphan");
    assert_eq!(settlements[0].outcome, SubagentOutcome::TrackingLost);
    assert_ne!(
        tracker.get("research-orphan").await.unwrap().status,
        SubagentStatus::Running,
        "a tracker orphan must not resurrect the live footer later"
    );
    let _ = std::fs::remove_dir_all(dir);
}

#[tokio::test]
async fn deep_research_interruption_settles_only_current_children_and_never_opens_report() {
    use a3s_code_core::SubagentStatus;
    use tokio_util::sync::CancellationToken;

    let (session, dir) = deep_research_settlement_test_session("interrupt").await;
    let parent_session_id = session.session_id().to_string();
    let tracker = session.subagent_tracker();
    for task_id in ["current-research-child", "unrelated-background-child"] {
        tracker
            .record_event(&AgentEvent::SubagentStart {
                task_id: task_id.to_string(),
                session_id: format!("{task_id}-session"),
                parent_session_id: parent_session_id.clone(),
                agent: "deep-research".to_string(),
                description: task_id.to_string(),
                started_ms: 1,
            })
            .await;
    }
    let current_cancellation = CancellationToken::new();
    let unrelated_cancellation = CancellationToken::new();
    tracker
        .register_canceller("current-research-child", current_cancellation.clone())
        .await;
    tracker
        .register_canceller("unrelated-background-child", unrelated_cancellation.clone())
        .await;

    let result = settle_deep_research_subagents(
        Arc::clone(&session),
        parent_session_id,
        9,
        vec!["current-research-child".to_string()],
        DeepResearchSettlementExit::Interrupted,
    )
    .await;
    let a3s_tui::cmd::CmdResult::Msg(Msg::DeepResearchSubagentsSettled {
        exit, settlements, ..
    }) = result
    else {
        panic!("expected DeepResearchSubagentsSettled");
    };

    assert_eq!(exit, DeepResearchSettlementExit::Interrupted);
    assert!(!exit.opens_report());
    assert_eq!(settlements.len(), 1);
    assert!(settlements[0].output.contains("interrupted"));
    assert!(!settlements[0].output.contains("report completed"));
    assert!(current_cancellation.is_cancelled());
    assert_eq!(
        tracker.get("current-research-child").await.unwrap().status,
        SubagentStatus::Cancelled
    );
    assert!(!unrelated_cancellation.is_cancelled());
    assert_eq!(
        tracker
            .get("unrelated-background-child")
            .await
            .unwrap()
            .status,
        SubagentStatus::Running
    );
    let _ = std::fs::remove_dir_all(dir);
}

#[test]
fn resumed_subagent_snapshot_distinguishes_parent_owned_and_background_results() {
    let snapshot = a3s_code_core::SubagentTaskSnapshot {
        task_id: "task-1".to_string(),
        parent_session_id: "parent".to_string(),
        child_session_id: "child".to_string(),
        agent: "review".to_string(),
        description: "audit".to_string(),
        status: a3s_code_core::SubagentStatus::Completed,
        started_ms: 1,
        updated_ms: 2,
        finished_ms: Some(2),
        output: Some("result".to_string()),
        success: Some(true),
        source_anchors: Vec::new(),
        progress: Vec::new(),
    };
    let history_for = |background| {
        vec![Message {
            role: "assistant".to_string(),
            content: vec![ContentBlock::ToolUse {
                id: "parent-tool".to_string(),
                name: "task".to_string(),
                input: serde_json::json!({
                    "agent": "review",
                    "description": "audit",
                    "prompt": "audit it",
                    "background": background
                }),
            }],
            reasoning_content: None,
        }]
    };

    assert!(subagent_parent_result_expected_in_history(
        &history_for(false),
        &snapshot
    ));
    assert!(!subagent_parent_result_expected_in_history(
        &history_for(true),
        &snapshot
    ));
}

#[test]
fn inactivity_review_requires_a_real_user_turn_not_ui_status() {
    let ui_messages = ["  ⇄ Codex · gpt-5.6-sol", "  no flows in ~/.a3s/flows"];
    let empty_history = Vec::<Message>::new();
    let tool_only_history = vec![Message::tool_result("call-1", "result", false)];

    assert!(!ui_messages.is_empty());
    assert!(!auto_review_history_has_user_turn(&empty_history));
    assert!(!auto_review_history_has_user_turn(&tool_only_history));
    assert!(auto_review_history_has_user_turn(&[Message::user("hello")]));
}

#[test]
fn inactivity_review_is_once_per_conversation_revision() {
    let mut tracker = AutoReviewTracker::new(0);

    // Empty history is marked as considered without launching a review.
    assert!(tracker.begin("session", false).is_none());
    assert!(tracker.current_is_reviewed("session"));

    tracker.on_user_turn();
    let ticket = tracker.begin("session", true).unwrap();
    assert!(tracker.accept(&ticket, "session"));

    // Keyboard/navigation activity has no tracker mutation, so it cannot
    // re-arm the same revision.
    assert!(tracker.begin("session", true).is_none());
}

#[test]
fn inactivity_review_rearms_on_new_user_turn_and_rejects_stale_result() {
    let mut tracker = AutoReviewTracker::new(1);
    let old = tracker.begin("session", true).unwrap();

    tracker.on_user_turn();
    let current = tracker.begin("session", true).unwrap();

    assert!(!tracker.accept(&old, "session"));
    assert_eq!(tracker.inflight.as_ref(), Some(&current));
    assert!(tracker.accept(&current, "session"));
}

#[test]
fn inactivity_review_result_is_rejected_after_session_change() {
    let mut tracker = AutoReviewTracker::new(1);
    let ticket = tracker.begin("before-clear", true).unwrap();

    assert!(!tracker.accept(&ticket, "after-clear"));
}

#[test]
fn deep_research_smoke_remaining_budget_is_absolute() {
    let started_at = Instant::now();
    let run_deadline = deep_research_smoke_run_deadline(started_at);
    let hard_timeout = Duration::from_millis(DEEP_RESEARCH_RUN_HARD_TIMEOUT_MS);

    assert_eq!(
        deep_research_smoke_remaining_budget(run_deadline, started_at),
        hard_timeout
    );
    assert_eq!(
        deep_research_smoke_remaining_budget(run_deadline, started_at + Duration::from_secs(90),),
        hard_timeout.saturating_sub(Duration::from_secs(90))
    );
    assert!(deep_research_smoke_remaining_budget(run_deadline, run_deadline).is_zero());
    assert!(deep_research_smoke_remaining_budget(
        run_deadline,
        run_deadline + Duration::from_secs(1),
    )
    .is_zero());
}

#[test]
fn deep_research_hard_fuse_covers_the_standalone_engine_transaction() {
    let required = DEEP_RESEARCH_EVIDENCE_FIRST_HOST_TIMEOUT_MS
        + (2 * DEEP_RESEARCH_ABORT_GRACE_MS)
        + DEEP_RESEARCH_SMOKE_FINALIZATION_RESERVE_MS;

    assert_eq!(DEEP_RESEARCH_RUN_HARD_TIMEOUT_MS, required);
}

#[test]
fn deep_research_smoke_phase_deadlines_reserve_finalization_budget() {
    let started_at = Instant::now();
    let run_deadline = deep_research_smoke_run_deadline(started_at);
    let finalization_reserve = Duration::from_millis(DEEP_RESEARCH_SMOKE_FINALIZATION_RESERVE_MS);
    let execution_deadline = deep_research_smoke_execution_deadline(run_deadline);
    assert_eq!(
        deep_research_smoke_remaining_budget(run_deadline, execution_deadline),
        finalization_reserve
    );

    for phase in ["workflow", "artifact validation"] {
        let deadline = deep_research_smoke_phase_deadline(
            run_deadline,
            started_at,
            Duration::from_secs(5 * 60),
            phase,
        )
        .expect("each execution phase has an initial budget");
        assert_eq!(deadline.selected_timeout, Duration::from_secs(5 * 60));
        assert_eq!(
            deadline.phase_deadline,
            started_at + Duration::from_secs(5 * 60),
            "{phase}"
        );
        assert!(deadline.phase_deadline <= execution_deadline, "{phase}");
    }

    let workflow = deep_research_smoke_phase_deadline(
        run_deadline,
        started_at,
        Duration::from_millis(DEEP_RESEARCH_EVIDENCE_FIRST_HOST_TIMEOUT_MS),
        "workflow",
    )
    .expect("workflow has run budget");
    assert_eq!(
        workflow.selected_timeout,
        Duration::from_millis(DEEP_RESEARCH_EVIDENCE_FIRST_HOST_TIMEOUT_MS)
    );

    let delayed_start = started_at + Duration::from_secs(90);
    let delayed_workflow = deep_research_smoke_phase_deadline(
        run_deadline,
        delayed_start,
        Duration::from_millis(DEEP_RESEARCH_EVIDENCE_FIRST_HOST_TIMEOUT_MS),
        "workflow",
    )
    .expect("workflow has the remaining run budget");
    assert_eq!(
        delayed_workflow.selected_timeout,
        execution_deadline.saturating_duration_since(delayed_start)
    );
    assert_eq!(delayed_workflow.phase_deadline, execution_deadline);
    assert!(deep_research_smoke_phase_deadline(
        run_deadline,
        run_deadline,
        Duration::from_millis(DEEP_RESEARCH_EVIDENCE_FIRST_HOST_TIMEOUT_MS),
        "workflow",
    )
    .is_none());

    let abort = deep_research_smoke_finalization_phase_deadline(
        run_deadline,
        execution_deadline,
        Duration::from_millis(DEEP_RESEARCH_ABORT_GRACE_MS),
        "abort",
    )
    .expect("the reserved finalization window includes cancellation grace");
    assert_eq!(
        abort.selected_timeout,
        Duration::from_millis(DEEP_RESEARCH_ABORT_GRACE_MS)
    );
    assert_eq!(
        deep_research_smoke_remaining_budget(run_deadline, abort.phase_deadline),
        finalization_reserve.saturating_sub(Duration::from_millis(DEEP_RESEARCH_ABORT_GRACE_MS))
    );
}

#[test]
fn deep_research_smoke_reserved_budget_can_publish_degraded_artifacts() {
    let workspace = std::env::temp_dir().join(format!(
        "a3s-deepresearch-smoke-finalization-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .expect("system clock after Unix epoch")
            .as_nanos()
    ));
    std::fs::create_dir_all(&workspace).expect("create smoke finalization workspace");
    let query = "reserved recovery artifact";
    let workflow_output = serde_json::json!({
        "mode": "smoke_execution_deadline_exceeded",
        "research": {
            "status": "degraded",
            "results": [],
            "warnings": ["bounded execution deadline reached"]
        }
    })
    .to_string();
    let run_deadline =
        Instant::now() + Duration::from_millis(DEEP_RESEARCH_SMOKE_FINALIZATION_RESERVE_MS);

    let artifacts =
        run_deep_research_smoke_artifact_step(run_deadline, "reserved recovery artifact", || {
            materialize_deep_research_recovery_report(
                &workspace,
                query,
                deep_research_smoke_exhausted_phase_message("synthesis").as_str(),
                &workflow_output,
                None,
            )
        })
        .expect("the reserved run budget must permit artifact publication")
        .expect("degraded artifacts should materialize");

    let markdown =
        std::fs::read_to_string(&artifacts.markdown).expect("read reserved recovery Markdown");
    let html = std::fs::read_to_string(&artifacts.html).expect("read reserved recovery HTML");
    assert!(markdown.contains("# DeepResearch Recovery Report"));
    assert!(html.contains("report-degraded"));

    let _ = std::fs::remove_dir_all(workspace);
}


#[test]
fn dynamic_workflow_event_and_completion_share_one_terminal_card() {
    let call_id = "host-dynamic_workflow-stable";
    let start_args = serde_json::json!({"run_id": "research-42"});
    let complete_args = serde_json::json!({
        "run_id": "research-42",
        "query": "Nimbus support status",
        "local_max_steps": 12
    });
    let start = AgentEvent::ToolExecutionStart {
        id: call_id.to_string(),
        name: "dynamic_workflow".to_string(),
        args: start_args.clone(),
    };
    let mut captured = None;
    capture_host_dynamic_workflow_call_id(true, &mut captured, &start);
    assert_eq!(captured.as_deref(), Some(call_id));

    // Nested activity is carried by the same host progress channel. It must
    // not replace the outer call ID used by the completion callback.
    for nested in [
        AgentEvent::ToolExecutionStart {
            id: "nested-parallel-task".to_string(),
            name: "parallel_task".to_string(),
            args: serde_json::json!({"tasks": []}),
        },
        AgentEvent::ToolExecutionStart {
            id: "nested-dynamic-workflow".to_string(),
            name: "dynamic_workflow".to_string(),
            args: serde_json::json!({"run_id": "nested"}),
        },
    ] {
        capture_host_dynamic_workflow_call_id(true, &mut captured, &nested);
    }
    assert_eq!(captured.as_deref(), Some(call_id));

    let mut runtime = RuntimeProjection::default();
    let mut transcript = Transcript::default();
    runtime.start_execution(
        call_id.to_string(),
        "dynamic_workflow".to_string(),
        start_args.clone(),
    );
    transcript.start_tool_execution(
        call_id.to_string(),
        "dynamic_workflow".to_string(),
        start_args,
        true,
    );

    // First the progress channel delivers ToolEnd.
    let progress_end = AgentEvent::ToolEnd {
        id: call_id.to_string(),
        name: "dynamic_workflow".to_string(),
        args: Some(complete_args.clone()),
        output: "raw progress result".to_string(),
        exit_code: 0,
        metadata: None,
        error_kind: None,
    };
    capture_host_dynamic_workflow_call_id(true, &mut captured, &progress_end);
    let AgentEvent::ToolEnd {
        id,
        name,
        args,
        output,
        exit_code,
        metadata,
        ..
    } = progress_end
    else {
        unreachable!();
    };
    let completed = runtime.end_tool(&id, name.clone(), args, output.clone(), exit_code);
    assert!(completed.first_terminal);
    transcript.finish_tool(&id, name, completed.args, output, exit_code, metadata, true);

    // Then the host completion callback supplies the card-safe output and
    // final structured metadata. It must mutate that same semantic entry.
    let callback_id = captured.take().expect("stable outer workflow call ID");
    let final_metadata = serde_json::json!({
        "dynamic_workflow": {
            "run_id": "research-42",
            "snapshot": {
                "steps": {
                    "collect": {"status": "completed"}
                }
            }
        }
    });
    let display_output = "Evidence collected from 3 sources.".to_string();
    let completed = runtime.end_tool(
        &callback_id,
        "dynamic_workflow".to_string(),
        Some(complete_args.clone()),
        display_output.clone(),
        0,
    );
    let transcript_args = transcript.finish_tool(
        &callback_id,
        "dynamic_workflow".to_string(),
        completed.args,
        display_output.clone(),
        0,
        Some(final_metadata),
        true,
    );

    assert_eq!(transcript_args, Some(complete_args.clone()));
    assert!(!completed.first_terminal, "duplicate terminal delivery");
    let projected = runtime.tool(call_id).expect("workflow projection");
    assert_eq!(projected.state, ToolCallState::Succeeded);
    assert_eq!(projected.args(), Some(complete_args));
    assert_eq!(projected.output(), display_output);
    assert_eq!(
        transcript
            .iter()
            .filter(|entry| matches!(entry, TranscriptEntry::Tool(_)))
            .count(),
        1
    );
    let plain = a3s_tui::style::strip_ansi(&transcript.render(80, 79).join("\n"));
    assert_eq!(
        plain.matches("Ran workflow research-42").count(),
        1,
        "{plain}"
    );
    assert!(plain.contains("✓ collect · completed"), "{plain}");
    assert!(!plain.contains("raw progress result"), "{plain}");
}

#[test]
fn dynamic_workflow_terminal_event_backfills_missing_call_id() {
    let event = AgentEvent::ToolEnd {
        id: "host-dynamic_workflow-terminal".to_string(),
        name: "dynamic_workflow".to_string(),
        args: Some(serde_json::json!({"run_id": "research-42"})),
        output: String::new(),
        exit_code: 0,
        metadata: None,
        error_kind: None,
    };
    let mut captured = None;

    capture_host_dynamic_workflow_call_id(true, &mut captured, &event);

    assert_eq!(captured.as_deref(), Some("host-dynamic_workflow-terminal"));
}

#[test]
fn tui_palette_tracks_design_tokens() {
    assert_eq!(rgb(CANVAS), (21, 25, 31));
    assert_eq!(rgb(ACCENT), (125, 182, 255));
    assert_eq!(rgb(TN_GREEN), (78, 201, 139));
    assert_ne!(TN_GREEN, ACCENT);
    assert_eq!(rgb(TN_YELLOW), (215, 168, 75));
    assert_eq!(rgb(TN_RED), (224, 108, 117));
    assert_eq!(rgb(TN_CYAN), (110, 198, 217));
    assert_eq!(rgb(TN_FG), (220, 220, 220));
    assert_eq!(rgb(TN_GRAY), (120, 123, 125));
    assert_eq!(rgb(TN_SUBTLE), (95, 99, 104));
    assert_eq!(rgb(BORDER_SUBTLE), (52, 58, 64));
    assert_eq!(rgb(SURFACE_SOFT), (27, 31, 37));
    assert_eq!(rgb(SURFACE_USER), (49, 53, 58));
    assert_eq!(rgb(SURFACE_SELECTED), (42, 46, 52));
    assert_eq!(rgb(COMPOSER_CHROME.primary), (210, 214, 220));
    assert_eq!(rgb(COMPOSER_CHROME.secondary), (139, 147, 158));
    assert_eq!(rgb(COMPOSER_CHROME.faint), (94, 103, 114));
    assert_eq!(rgb(COMPOSER_CHROME.active), (137, 161, 199));
    assert_eq!(rgb(COMPOSER_CHROME.success), (126, 164, 143));
    assert_eq!(rgb(COMPOSER_CHROME.warning), (188, 157, 105));
    assert_eq!(rgb(COMPOSER_CHROME.error), (197, 120, 128));
    assert_ne!(COMPOSER_CHROME.active, ACCENT);
}

#[test]
fn agent_chrome_theme_maps_tui_roles_to_code_palette() {
    let theme = agent_chrome_theme();
    assert_eq!(theme.primary, ACCENT);
    assert_eq!(theme.bg, CANVAS);
    assert_eq!(theme.fg, TN_FG);
    assert_eq!(theme.muted, TN_GRAY);
    assert_eq!(theme.border, BORDER_SUBTLE);
    assert_eq!(theme.success, TN_GREEN);
    assert_eq!(theme.warning, TN_ORANGE);
    assert_eq!(theme.error, TN_RED);
    assert_eq!(theme.surface, SURFACE_SOFT);
    assert_eq!(theme.highlight, SURFACE_SELECTED);

    let chrome = agent_chrome(&theme);
    let rendered = chrome.tool_status("Running").view(24);
    assert!(
        rendered.contains(&ACCENT.fg_ansi()),
        "agent chrome should render code primary color: {rendered:?}"
    );
}

#[test]
fn remote_view_button_is_styled_but_clickable_by_marker() {
    let rendered = remote_view_button("click to open");
    let plain = a3s_tui::style::strip_ansi(&rendered);
    assert!(plain.contains(VIEW_BUTTON_MARKER), "{plain}");
    assert!(plain.contains("click to open"), "{plain}");
    assert!(
        rendered.contains("\x1b["),
        "button should carry ANSI styling"
    );
}

#[test]
fn remote_view_click_tolerates_small_terminal_mouse_drift() {
    let rendered = remote_view_button("click to open");
    let view = format!("plain transcript\n{rendered}\nnext line");

    assert!(is_remote_view_click(
        &view,
        Selection::from_cells((1, 4), (1, 6))
    ));
    assert!(!is_remote_view_click(
        &view,
        Selection::from_cells((1, 4), (1, 12))
    ));
    assert!(!is_remote_view_click(
        &view,
        Selection::from_cells((1, 4), (2, 4))
    ));
    assert!(!is_remote_view_click(
        &view,
        Selection::from_cells((0, 4), (0, 4))
    ));
}

#[test]
fn remote_view_click_marker_is_case_insensitive_after_ansi_strip() {
    let view = format!(
        "  {}\n",
        Style::new()
            .fg(Color::BrightWhite)
            .bg(ACCENT)
            .render(" ↗ Open View ")
    );

    assert!(is_remote_view_click(
        &view,
        Selection::from_cells((0, 3), (0, 3))
    ));
}

#[test]
fn quit_key_accepts_control_c_terminal_variants() {
    let key = |code, modifiers| KeyEvent { code, modifiers };

    assert!(is_quit_key(&key(KeyCode::Char('c'), KeyModifiers::CONTROL)));
    assert!(is_quit_key(&key(
        KeyCode::Char('C'),
        KeyModifiers::CONTROL | KeyModifiers::SHIFT
    )));
    assert!(!is_quit_key(&key(KeyCode::Char('c'), KeyModifiers::NONE)));
    assert!(!is_quit_key(&key(
        KeyCode::Char('v'),
        KeyModifiers::CONTROL
    )));
}

#[test]
fn tool_output_key_accepts_control_t_terminal_variants() {
    let key = |code, modifiers| KeyEvent { code, modifiers };

    assert!(is_tool_output_key(&key(
        KeyCode::Char('t'),
        KeyModifiers::CONTROL
    )));
    assert!(is_tool_output_key(&key(
        KeyCode::Char('T'),
        KeyModifiers::CONTROL | KeyModifiers::SHIFT
    )));
    assert!(!is_tool_output_key(&key(
        KeyCode::Char('t'),
        KeyModifiers::NONE
    )));
    assert!(!is_tool_output_key(&key(
        KeyCode::Char('v'),
        KeyModifiers::CONTROL
    )));
}

#[test]
fn quit_confirmation_requires_second_press_inside_window() {
    let now = Instant::now();

    assert!(!quit_is_confirmed(None, now));
    if let Some(recent) = now.checked_sub(Duration::from_millis(500)) {
        assert!(quit_is_confirmed(Some(recent), now));
    }
    if let Some(stale) = now.checked_sub(Duration::from_secs(3)) {
        assert!(!quit_is_confirmed(Some(stale), now));
    }
}

#[tokio::test]
async fn graceful_quit_settles_a_completed_stream() {
    let stream_join = tokio::spawn(async {});

    assert!(
        settle_stream_join_for_quit(stream_join, Duration::from_secs(1)).await,
        "an already-completed stream should settle without forced abort"
    );
}

#[tokio::test]
async fn graceful_quit_settles_a_completed_session_close() {
    assert!(
        settle_session_close_for_quit(async {}, Duration::from_secs(1)).await,
        "an already-completed session close should settle without forced abort"
    );
}

#[tokio::test]
async fn graceful_quit_aborts_a_session_close_after_its_deadline() {
    struct DropFlag(Arc<std::sync::atomic::AtomicBool>);

    impl Drop for DropFlag {
        fn drop(&mut self) {
            self.0.store(true, Ordering::SeqCst);
        }
    }

    let dropped = Arc::new(std::sync::atomic::AtomicBool::new(false));
    let close = {
        let dropped = Arc::clone(&dropped);
        async move {
            let _drop_flag = DropFlag(dropped);
            std::future::pending::<()>().await;
        }
    };

    assert!(
        !settle_session_close_for_quit(close, Duration::from_millis(10)).await,
        "a stuck session close must be force-aborted after the host deadline"
    );
    assert!(
        dropped.load(Ordering::SeqCst),
        "the aborted close task must run its cancellation destructors"
    );
}

#[tokio::test]
async fn graceful_quit_aborts_a_stream_after_its_own_deadline() {
    struct DropFlag(Arc<std::sync::atomic::AtomicBool>);

    impl Drop for DropFlag {
        fn drop(&mut self) {
            self.0.store(true, Ordering::SeqCst);
        }
    }

    let dropped = Arc::new(std::sync::atomic::AtomicBool::new(false));
    let stream_join = tokio::spawn({
        let dropped = Arc::clone(&dropped);
        async move {
            let _drop_flag = DropFlag(dropped);
            std::future::pending::<()>().await;
        }
    });

    assert!(
        !settle_stream_join_for_quit(stream_join, Duration::from_millis(10)).await,
        "a stuck stream must be force-aborted after the quit-specific grace period"
    );
    assert!(
        dropped.load(Ordering::SeqCst),
        "the aborted stream task must run its cancellation destructors"
    );
}

fn footer_for_width(width: usize) -> String {
    render_session_status_line(
        "/Users/roylin/code/a3s",
        Some("main"),
        Some("openai/gpt-5"),
        128_000,
        90_000,
        0,
        [
            mode_status_chip(Mode::Auto),
            SessionStatusChip::new("◎", "goal · 1m 05s").color(COMPOSER_CHROME.active),
        ],
        width,
    )
}

fn assert_fixed_width_footer(status: &str, width: usize) -> String {
    let plain = a3s_tui::style::strip_ansi(status);
    assert_eq!(a3s_tui::style::visible_len(status), width);
    assert!(!plain.contains('\n'), "footer must remain one row");
    assert!(
        !plain.starts_with(' '),
        "footer must be full-bleed: {plain:?}"
    );
    assert!(status.contains("\x1b["), "status should be styled");
    plain
}

#[test]
fn footer_wide_width_keeps_all_optional_detail_after_mode_and_context() {
    let status = footer_for_width(128);
    let plain = assert_fixed_width_footer(&status, 128);

    assert!(plain.contains("⏵⏵ auto mode"), "{plain}");
    assert!(plain.contains("ctx:70%"), "{plain}");
    assert!(plain.contains("a3s"), "{plain}");
    assert!(plain.contains("git:(main)"), "{plain}");
    assert!(plain.contains("gpt-5 (128k context)"), "{plain}");
    assert!(plain.contains("◎ goal · 1m 05s"), "{plain}");
    assert!(
        plain.find("⏵⏵ auto mode") < plain.find("git:(main)"),
        "mandatory permission mode must precede optional detail: {plain}"
    );
    assert!(
        plain.find("ctx:70%") < plain.find("gpt-5"),
        "mandatory context must precede optional detail: {plain}"
    );
}

#[test]
fn footer_medium_width_keeps_live_goal_before_optional_identity() {
    let status = footer_for_width(64);
    let plain = assert_fixed_width_footer(&status, 64);

    assert!(plain.contains("⏵⏵ auto mode"), "{plain}");
    assert!(plain.contains("ctx:70%"), "{plain}");
    assert!(plain.contains("◎ goal · 1m 05s"), "{plain}");
    assert!(!plain.contains("gpt-5"), "{plain}");
}

#[test]
fn footer_narrow_width_uses_compact_mode_and_context_fallback() {
    let status = footer_for_width(18);
    let plain = assert_fixed_width_footer(&status, 18);

    assert!(plain.contains("⏵⏵ auto"), "{plain}");
    assert!(plain.contains("ctx:70%"), "{plain}");
    assert!(!plain.contains("auto mode"), "{plain}");
    assert!(
        !plain.contains("▰"),
        "meter should be dropped first: {plain}"
    );
    assert!(!plain.contains("a3s"), "{plain}");
    assert!(!plain.contains("git:("), "{plain}");
    assert!(!plain.contains("gpt-5"), "{plain}");
    assert!(!plain.contains("goal · 1m 05s"), "{plain}");
}

#[test]
fn footer_uses_low_chroma_color_anchors_with_neutral_detail() {
    let status = render_session_status_line(
        "/Users/roylin/code/a3s",
        Some("main"),
        Some("openai/gpt-5"),
        128_000,
        40_000,
        0,
        [
            mode_status_chip(Mode::Plan),
            SessionStatusChip::new("◎", "goal · 1m 05s").color(COMPOSER_CHROME.active),
        ],
        128,
    );

    assert!(
        status.contains(&Style::new().fg(COMPOSER_CHROME.active).bold().render("a3s")),
        "workspace should be a visible blue identity anchor: {status:?}"
    );
    assert!(
        status.contains(&Style::new().fg(COMPOSER_CHROME.success).render("main")),
        "git branch should use a quiet green identity anchor: {status:?}"
    );
    assert!(
        status.contains(&Style::new().fg(COMPOSER_CHROME.active).render("ctx:31%")),
        "healthy context should keep a visible blue meter: {status:?}"
    );
    assert!(
        status.contains(&Style::new().fg(COMPOSER_CHROME.secondary).render("gpt-5")),
        "model should be secondary text: {status:?}"
    );
    assert!(
        status.contains(&Style::new().fg(COMPOSER_CHROME.active).render("✎"))
            && status.contains(&Style::new().fg(COMPOSER_CHROME.primary).render("plan mode")),
        "permission mode should separate its glyph from its label: {status:?}"
    );
    assert!(
        status.contains(&Style::new().fg(COMPOSER_CHROME.active).render("◎"))
            && status.contains(
                &Style::new()
                    .fg(COMPOSER_CHROME.secondary)
                    .render("goal · 1m 05s")
            ),
        "live chips should separate semantic glyphs from muted labels: {status:?}"
    );
    assert!(
        !status.contains(&COMPOSER_CHROME.warning.fg_ansi())
            && !status.contains(&COMPOSER_CHROME.error.fg_ansi())
            && !status.contains(&ACCENT.fg_ansi()),
        "ordinary footer state should avoid alert and global-accent colors: {status:?}"
    );
}

#[test]
fn auto_mode_reserves_warning_color_for_the_permission_glyph() {
    let segment = footer_mode_segment(&mode_status_chip(Mode::Auto));

    assert!(
        segment.contains(&Style::new().fg(COMPOSER_CHROME.warning).render("⏵⏵")),
        "auto-approval should remain visibly elevated: {segment:?}"
    );
    assert!(
        segment.contains(&Style::new().fg(COMPOSER_CHROME.primary).render("auto mode")),
        "warning color should not tint the full mode label: {segment:?}"
    );
    assert!(
        !segment.contains(&Style::new().fg(COMPOSER_CHROME.warning).render("auto mode")),
        "warning color should stay on the glyph only: {segment:?}"
    );
}

#[test]
fn jump_to_latest_hint_uses_shared_inline_action() {
    let hint = jump_to_latest_hint(48);
    let plain = a3s_tui::style::strip_ansi(&hint);

    assert_eq!(a3s_tui::style::visible_len(&hint), 48);
    assert!(plain.contains("↓ more below"), "{plain}");
    assert!(plain.contains("Shift+End"), "{plain}");
    let left_pad = plain.chars().take_while(|ch| *ch == ' ').count();
    let right_pad = plain.chars().rev().take_while(|ch| *ch == ' ').count();
    assert!(left_pad > 0, "{plain:?}");
    assert!(right_pad > 0, "{plain:?}");
    assert!(left_pad.abs_diff(right_pad) <= 1, "{plain:?}");
    assert!(hint.contains("\x1b["), "hint should be styled");
    assert_eq!(jump_to_latest_hint(0), "");
}

fn rendered_stream_rows_from_chunks(screen_width: u16, chunks: &[&str]) -> Vec<String> {
    let viewport_width = viewport_content_width_for(screen_width);
    let mut streaming = StreamingMarkdown::new(transcript_markdown_width_for(screen_width));
    for chunk in chunks {
        streaming.push(chunk);
    }
    let block = assistant_block(&streaming.final_view(), viewport_width);
    let mut viewport = Viewport::new(viewport_width as u16, 12).with_auto_scroll(false);
    viewport.set_content(&format!("\n{block}\n"));

    viewport
        .view()
        .lines()
        .map(a3s_tui::style::strip_ansi)
        .filter(|line| !line.trim().is_empty())
        .collect()
}

#[test]
fn streaming_and_finalized_assistant_blocks_keep_the_same_content_rows() {
    let width = 40_u16;
    let content_width = viewport_content_width_for(width);
    let source = "alpha line\nbeta line\n";
    let mut streaming = StreamingMarkdown::new(transcript_markdown_width_for(width));
    assert!(streaming.push(source));
    assert!(streaming.commit_tick(Instant::now() + Duration::from_secs(1)));

    let stable = streaming.visible_stable_view();
    assert!(!stable.is_empty());
    let (prefix, suffix) =
        assistant_stream_block_parts(&stable, &streaming.tail_view(), content_width)
            .expect("stream block");
    let live = a3s_tui::style::strip_ansi(&format!("{prefix}{suffix}"));
    let finalized = a3s_tui::style::strip_ansi(
        &TranscriptEntry::assistant_markdown(source).render(width, content_width),
    );

    assert_eq!(live.trim_end_matches('\n'), finalized);
    let rows = live.lines().collect::<Vec<_>>();
    assert_eq!(
        rows.iter().filter(|row| row.trim().is_empty()).count(),
        0,
        "{live:?}"
    );
}

#[test]
fn composer_and_transcript_share_the_scrollbar_aware_width_budget() {
    for width in [8, 16, 80] {
        let content = viewport_content_width_for(width);
        assert_eq!(content, width as usize);
        assert_eq!(
            textarea_width_for(width) as usize,
            content.saturating_sub(PAD + 2)
        );
        assert_eq!(
            transcript_markdown_width_for(width),
            textarea_width_for(width) as usize
        );
    }
}

fn rendered_stream_rows(screen_width: u16, text: &str) -> Vec<String> {
    rendered_stream_rows_from_chunks(screen_width, &[text])
}

fn assert_assistant_rows_aligned(rows: &[String], viewport_width: usize) {
    assert!(!rows.is_empty(), "stream should render at least one row");
    assert!(
        rows.first().is_some_and(|row| row.starts_with("• ")),
        "first assistant row should carry marker: {rows:?}"
    );
    for (idx, row) in rows.iter().enumerate() {
        assert!(
            a3s_tui::style::visible_len(row) <= viewport_width,
            "stream row exceeds viewport width {viewport_width}: {row:?}"
        );
        if idx > 0 {
            assert!(
                row.starts_with("  "),
                "assistant continuation row is misaligned: {row:?}"
            );
        }
    }
}

#[test]
fn streaming_transcript_rows_stay_gutter_aligned_on_narrow_widths() {
    let width = 16;
    let rows = rendered_stream_rows(width, "abcdefghijklmnopqrstuvwxyz");

    assert_assistant_rows_aligned(&rows, viewport_content_width_for(width));
}

#[test]
fn streaming_transcript_rows_stay_gutter_aligned_with_markdown_and_wide_text() {
    let width = 28;
    let rows = rendered_stream_rows(
        width,
        "中文消息流 ✅ keeps `inline code` aligned with a-very-long-token",
    );

    assert_assistant_rows_aligned(&rows, viewport_content_width_for(width));
    assert!(
        rows.iter().any(|row| contains_cjk(row)),
        "wide text should be present in rendered rows: {rows:?}"
    );
}

#[test]
fn streaming_transcript_rows_stay_gutter_aligned_across_widths_and_fragments() {
    let cases: &[&[&str]] = &[
        &["short"],
        &["alpha", " beta", " gamma", " delta"],
        &["**bold** and `inline code` with a-super-long-token"],
        &["- first item\n- second item with extra text"],
        &["```text\n", "abcdefghijklmnopqrstuvwxyz", "\n```"],
        &["中文消息流", " ✅ ", "keeps emoji and wide glyphs aligned"],
    ];

    for width in [9, 10, 11, 12, 13, 16, 20, 28, 40, 72] {
        let viewport_width = viewport_content_width_for(width);
        for chunks in cases {
            let rows = rendered_stream_rows_from_chunks(width, chunks);
            assert_assistant_rows_aligned(&rows, viewport_width);
        }
    }
}

#[test]
fn tui_session_options_sets_separate_tool_timeout() {
    let confirmation = a3s_code_core::hitl::ConfirmationPolicy::enabled()
        .with_timeout(HITL_CONFIRM_TIMEOUT_MS, TimeoutAction::Reject);
    let opts = tui_session_options(confirmation);
    let dbg = format!("{opts:?}");

    assert_ne!(HITL_CONFIRM_TIMEOUT_MS, TOOL_EXEC_TIMEOUT_MS);
    assert!(
        dbg.contains(&format!("tool_timeout_ms: Some({TOOL_EXEC_TIMEOUT_MS})")),
        "{dbg}"
    );
    assert!(
        dbg.contains(&format!(
            "duplicate_tool_call_threshold: Some({TUI_DUPLICATE_TOOL_CALL_THRESHOLD})"
        )),
        "{dbg}"
    );
}

#[test]
fn approval_menu_uses_decision_focused_semantic_surface() {
    let lines = approval_menu_lines(
        "Bash(cargo test very-long-filter-name-that-should-not-overflow)",
        1,
        72,
    );
    let plain = lines
        .iter()
        .map(|line| a3s_tui::style::strip_ansi(line))
        .collect::<Vec<_>>();

    assert!(plain[0].contains("◆ Permission required"), "{plain:?}");
    assert!(plain[1].contains("Run"), "{plain:?}");
    assert!(plain.iter().any(|line| line.contains("1  ↵ Allow once")));
    assert!(plain
        .iter()
        .any(|line| line.contains("2  ◎ Allow exact capability for this session")));
    assert!(plain
        .iter()
        .any(|line| line.contains("3  ⌘ Add exact capability rule to project")));
    assert!(plain
        .iter()
        .any(|line| line.contains("4  ⊘ Deny and tell the agent why")));
    assert!(plain.iter().any(|line| line.contains("Enter select")));
    assert!(
        lines
            .iter()
            .all(|line| a3s_tui::style::visible_len(line) <= 72),
        "{plain:?}"
    );
    assert!(
        lines
            .iter()
            .any(|line| line.contains(SURFACE_SELECTED.bg_ansi().as_str())),
        "selected row is styled"
    );
}

#[test]
fn approval_prompt_mouse_wheel_moves_selection_at_overlay_offset() {
    use a3s_tui::event::{MouseEvent, MouseEventKind};

    let width = 42;
    let lines = approval_menu_lines("Bash(cargo test)", 0, width);
    let y_offset = approval_overlay_y_offset(18, lines.len(), 5);
    let mut prompt = approval_prompt("Bash(cargo test)", 0);
    prompt.set_y_offset(y_offset);

    let msg = prompt.handle_mouse(
        &MouseEvent {
            kind: MouseEventKind::ScrollDown,
            column: 0,
            row: y_offset + 1,
            modifiers: KeyModifiers::NONE,
        },
        width,
    );

    assert_eq!(msg, None);
    assert_eq!(prompt.selected_index(), 1);
}

#[test]
fn approval_prompt_click_selects_choice_at_overlay_offset() {
    use a3s_tui::event::{MouseButton, MouseEvent, MouseEventKind};

    let width = 42;
    let lines = approval_menu_lines("Bash(cargo test)", 0, width);
    let y_offset = approval_overlay_y_offset(18, lines.len(), 5);
    let mut prompt = approval_prompt("Bash(cargo test)", 0);
    prompt.set_y_offset(y_offset);

    let choice_row = prompt.choice_start_row(width) + 1;
    let msg = prompt.handle_mouse(
        &MouseEvent {
            kind: MouseEventKind::Down(MouseButton::Left),
            column: 2,
            row: y_offset + choice_row as u16,
            modifiers: KeyModifiers::NONE,
        },
        width,
    );

    assert_eq!(msg, Some(ApprovalPromptMsg::Selected(1)));
}

#[test]
fn approval_overlay_moves_above_multiline_and_dynamic_bottom_rows() {
    assert_eq!(approval_overlay_y_offset(24, 6, 5), 13);
    assert_eq!(approval_overlay_y_offset(24, 6, 11), 7);
    assert_eq!(approval_rows_below_for(false, 11), 11);
    assert_eq!(approval_rows_below_for(true, 11), 1);
}

#[test]
fn effort_ladder_is_monotonic_and_well_formed() {
    // ULTRACODE indexes the last level, which is the ultracode profile.
    assert_eq!(ULTRACODE, EFFORT_LEVELS.len() - 1);
    assert_eq!(EFFORT_LEVELS[ULTRACODE].label, "ultracode");
    // Depth rises with effort: thinking budget and tool-round budget both
    // non-decreasing across low → max (so higher effort is never shallower).
    for w in EFFORT_LEVELS[..=ULTRACODE].windows(2) {
        assert!(
            w[1].thinking_budget >= w[0].thinking_budget,
            "thinking budget regressed"
        );
        assert!(
            w[1].max_tool_rounds >= w[0].max_tool_rounds,
            "tool-round budget regressed"
        );
        assert!(
            w[1].max_continuation_turns >= w[0].max_continuation_turns,
            "continuation budget regressed"
        );
    }
    // medium is the unsteered baseline; every other level carries a guideline
    // so effort is meaningful even on models with no thinking budget.
    assert!(
        EFFORT_LEVELS[1].guideline.is_none(),
        "medium should be the baseline"
    );
    for (i, p) in EFFORT_LEVELS.iter().enumerate() {
        if i != 1 {
            assert!(
                p.guideline.is_some(),
                "level {} has no depth steer",
                p.label
            );
        }
    }
}

use a3s_code_core::llm::{
    ContentBlock, LlmClient, LlmResponse, Message, StreamEvent, TokenUsage, ToolDefinition,
};
use async_trait::async_trait;
use std::collections::VecDeque;
use std::sync::{Arc, Mutex};
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;

#[derive(Clone, Default)]
struct CapturedLlmTurn {
    system: Option<String>,
    tools: Vec<String>,
}

struct CaptureLlmClient {
    turns: Mutex<Vec<CapturedLlmTurn>>,
    responses: Mutex<VecDeque<LlmResponse>>,
}

#[async_trait]
impl LlmClient for CaptureLlmClient {
    async fn complete(
        &self,
        _messages: &[Message],
        system: Option<&str>,
        tools: &[ToolDefinition],
    ) -> anyhow::Result<LlmResponse> {
        self.record(system, tools);
        Ok(self.next_response())
    }

    async fn complete_streaming(
        &self,
        _messages: &[Message],
        system: Option<&str>,
        tools: &[ToolDefinition],
        _cancel_token: CancellationToken,
    ) -> anyhow::Result<mpsc::Receiver<StreamEvent>> {
        self.record(system, tools);
        let response = self.next_response();
        let (tx, rx) = mpsc::channel(2);
        tokio::spawn(async move {
            let _ = tx.send(StreamEvent::Done(response)).await;
        });
        Ok(rx)
    }
}

impl CaptureLlmClient {
    fn new(responses: Vec<LlmResponse>) -> Self {
        Self {
            turns: Mutex::new(Vec::new()),
            responses: Mutex::new(responses.into()),
        }
    }

    fn record(&self, system: Option<&str>, tools: &[ToolDefinition]) {
        self.turns.lock().unwrap().push(CapturedLlmTurn {
            system: system.map(str::to_string),
            tools: tools.iter().map(|tool| tool.name.clone()).collect(),
        });
    }

    fn next_response(&self) -> LlmResponse {
        self.responses
            .lock()
            .unwrap()
            .pop_front()
            .unwrap_or_else(done_response)
    }

    fn turns(&self) -> Vec<CapturedLlmTurn> {
        self.turns.lock().unwrap().clone()
    }
}

fn tool_call_response(name: &str, input: serde_json::Value) -> LlmResponse {
    LlmResponse {
        message: Message {
            role: "assistant".into(),
            content: vec![ContentBlock::ToolUse {
                id: "toolu_test".into(),
                name: name.into(),
                input,
            }],
            reasoning_content: None,
        },
        usage: TokenUsage::default(),
        stop_reason: Some("tool_use".into()),
        token_logprobs: Vec::new(),
        meta: None,
    }
}

fn done_response() -> LlmResponse {
    LlmResponse {
        message: Message {
            role: "assistant".into(),
            content: vec![ContentBlock::Text {
                text: "DONE".into(),
            }],
            reasoning_content: None,
        },
        usage: TokenUsage::default(),
        stop_reason: Some("stop".into()),
        token_logprobs: Vec::new(),
        meta: None,
    }
}

fn test_config(path: &std::path::Path) {
    std::fs::write(
        path,
        "default_model = \"openai/x\"\n\
             providers \"openai\" {\n  apiKey = \"x\"\n  baseUrl = \"http://127.0.0.1:1\"\n  \
             models \"x\" { name = \"x\" }\n}\n",
    )
    .unwrap();
}

/// Guard: ultracode registers A3S Flow plus `task`/`parallel_task` in the
/// session tool surface (so dynamic workflows and fan-out have tools to call).
#[tokio::test]
async fn parallel_opts_register_parallel_task() {
    let dir = std::env::temp_dir().join(format!("a3s-ptask-{}", std::process::id()));
    let _ = std::fs::create_dir_all(&dir);
    let cfg = dir.join("config.acl");
    test_config(&cfg);
    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let budget = budget_plan_for_effort_index(ULTRACODE, None, BudgetWorkload::Interactive);
    // The FULL ultracode config (planning + goal + parallel fan-out).
    let opts = SessionOptions::new()
        .with_max_parallel_tasks(budget.max_parallel_tasks)
        .with_auto_delegation_enabled(true)
        .with_auto_parallel_delegation(true)
        .with_manual_delegation_enabled(true)
        .with_planning_mode(a3s_code_core::PlanningMode::Enabled)
        .with_goal_tracking(true)
        .with_max_tool_rounds(budget.max_tool_rounds);
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), Some(opts))
        .await
        .unwrap();
    let _ = session.register_dynamic_workflow_runtime();
    let names = session.tool_names();
    let _ = std::fs::remove_dir_all(&dir);
    assert!(
        names.contains(&"dynamic_workflow".to_string()),
        "dynamic_workflow registered; got {names:?}"
    );
    assert!(
        names.contains(&"parallel_task".to_string()),
        "parallel_task registered; got {names:?}"
    );
    assert!(
        names.contains(&"task".to_string()),
        "task registered; got {names:?}"
    );
}

#[test]
fn concurrent_tool_approvals_are_kept_in_fifo_order() {
    let mut pending = VecDeque::from([
        pending_approval("tool-a", "edit file"),
        pending_approval("tool-b", "run tests"),
    ]);

    assert_eq!(
        pending
            .front()
            .map(|pending| (pending.tool_id.as_str(), pending.label.as_str())),
        Some(("tool-a", "edit file"))
    );
    assert_eq!(
        take_pending_tool_for_confirmation(&mut pending, "tool-a")
            .map(|pending| (pending.tool_id, pending.label)),
        Some(("tool-a".to_string(), "edit file".to_string()))
    );
    assert_eq!(
        pending
            .front()
            .map(|pending| (pending.tool_id.as_str(), pending.label.as_str())),
        Some(("tool-b", "run tests"))
    );
}

#[test]
fn scoped_approval_never_grants_other_pending_requests() {
    let mut pending = VecDeque::from([
        pending_approval("tool-a", "edit file"),
        pending_approval("tool-b", "run tests"),
        pending_approval("tool-c", "write report"),
    ]);

    assert_eq!(
        take_pending_tool_for_confirmation(&mut pending, "tool-a").map(|pending| pending.tool_id),
        Some("tool-a".to_string())
    );
    assert_eq!(
        pending
            .iter()
            .map(|pending| pending.tool_id.as_str())
            .collect::<Vec<_>>(),
        vec!["tool-b", "tool-c"]
    );
}

#[test]
fn out_of_order_tool_terminal_events_do_not_skip_the_fifo_head() {
    let mut pending = VecDeque::from([
        pending_approval("tool-a", "edit file"),
        pending_approval("tool-b", "run tests"),
    ]);

    // A later request may be confirmed or time out before the prompt at
    // the head resolves. Remove that request without advancing the UI.
    assert_eq!(
        take_pending_tool_approval(&mut pending, "tool-b")
            .map(|(pending, was_front)| (pending.label, was_front)),
        Some(("run tests".to_string(), false))
    );
    assert_eq!(
        pending
            .front()
            .map(|pending| (pending.tool_id.as_str(), pending.label.as_str())),
        Some(("tool-a", "edit file"))
    );

    // Resolving the head then advances (and in this case drains) the queue.
    assert_eq!(
        take_pending_tool_approval(&mut pending, "tool-a")
            .map(|(pending, was_front)| (pending.label, was_front)),
        Some(("edit file".to_string(), true))
    );
    assert!(pending.is_empty());
}

#[test]
fn stale_modal_confirmation_cannot_apply_to_the_next_tool() {
    let mut pending = VecDeque::from([
        pending_approval("tool-a", "edit file"),
        pending_approval("tool-b", "run tests"),
    ]);

    // The head resolves externally after its prompt generated a UI message.
    assert_eq!(
        take_pending_tool_approval(&mut pending, "tool-a")
            .map(|(pending, was_front)| (pending.label, was_front)),
        Some(("edit file".to_string(), true))
    );

    // The stale response remains bound to tool-a rather than approving or
    // denying the new head, tool-b.
    assert!(take_pending_tool_for_confirmation(&mut pending, "tool-a").is_none());
    assert_eq!(
        pending.front().map(|pending| pending.tool_id.as_str()),
        Some("tool-b")
    );
}

#[test]
fn unknown_tool_terminal_event_does_not_mutate_pending_approvals() {
    let mut pending = VecDeque::from([
        pending_approval("tool-a", "edit file"),
        pending_approval("tool-b", "run tests"),
    ]);

    assert!(take_pending_tool_approval(&mut pending, "tool-c").is_none());
    assert_eq!(pending.len(), 2);
    assert_eq!(
        pending.front().map(|pending| pending.tool_id.as_str()),
        Some("tool-a")
    );
}

fn pending_approval(tool_id: &str, label: &str) -> PendingToolApproval {
    PendingToolApproval::new(
        tool_id.to_string(),
        "bash".to_string(),
        serde_json::json!({"command": label}),
        label.to_string(),
    )
}

#[tokio::test]
async fn confirmation_resume_rearms_spinner_and_stream_pump() {
    let cmd = resume_after_pending_confirmation_cmd(None);
    match cmd.await {
        a3s_tui::cmd::CmdResult::Batch(cmds) => {
            assert_eq!(
                cmds.len(),
                2,
                "spinner and stream commit clock should resume without an rx"
            );
        }
        _ => panic!("expected batched resume command"),
    }

    let (_tx, rx) = mpsc::channel::<AgentEvent>(1);
    let cmd = resume_after_pending_confirmation_cmd(Some(std::sync::Arc::new(
        tokio::sync::Mutex::new(rx),
    )));
    match cmd.await {
        a3s_tui::cmd::CmdResult::Batch(cmds) => {
            assert_eq!(
                cmds.len(),
                3,
                "spinner, stream commit clock, and stream pump should resume"
            );
        }
        _ => panic!("expected batched resume command"),
    }
}

// ── `?` deep-research mode ─────────────────────────────────────────────
fn write_completed_deep_research_test_artifacts(
    report_dir: &Path,
    query: &str,
    markdown: &str,
    html_markdown: &str,
) {
    const MARKER: &str = "<!-- A3S_DEEP_RESEARCH_ARTIFACT:synthesized:v1 -->";
    std::fs::write(
        report_dir.join("report.md"),
        format!("{markdown}\n\n{MARKER}\n"),
    )
    .unwrap();
    std::fs::write(
        report_dir.join("index.html"),
        format!(
            "{MARKER}\n{}",
            deep_research_completed_report_html_for_test(query, html_markdown)
        ),
    )
    .unwrap();
}

#[test]
fn deep_research_safety_envelope_is_query_agnostic() {
    let budget = deep_research_default_budget();
    let web = deep_research_safety_envelope(DeepResearchEvidenceScope::WebAndWorkspace, budget);
    let local = deep_research_safety_envelope(DeepResearchEvidenceScope::LocalOnly, budget);
    let mut non_parallel_budget = budget;
    non_parallel_budget.max_parallel_tasks = 1;
    let non_parallel = deep_research_safety_envelope(
        DeepResearchEvidenceScope::WebAndWorkspace,
        non_parallel_budget,
    );

    assert_eq!(web.max_tracks, 4);
    assert_eq!(
        non_parallel.max_tracks, web.max_tracks,
        "semantic plan shape must not depend on parallel-task capacity"
    );
    assert_eq!(web.max_steps_per_task, 2);
    assert_eq!(web.workflow_timeout_ms, 300_000);
    assert_eq!(local.workflow_timeout_ms, 210_000);
}

#[test]
fn research_report_marker_requires_workspace_index_html_and_markdown_pair() {
    let root = std::env::temp_dir().join(format!(
        "a3s-research-view-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    let report_dir = root.join(".a3s/research/rust-async");
    std::fs::create_dir_all(&report_dir).unwrap();
    let html = report_dir.join("index.html");
    let md = report_dir.join("report.md");
    let markdown = "# Rust Async\n\n## Findings\n\nThis source-backed report compares async runtime tradeoffs across scheduler behavior, ecosystem maturity, operational caveats, and confidence levels.\n\n## Sources\n\n- https://example.com/runtime-notes\n\n## Confidence\n\nConfidence is medium because evidence is concise but independently reviewable.\n";
    write_completed_deep_research_test_artifacts(&report_dir, "rust async", markdown, markdown);

    let spec = research_report_view_spec(
        "done\nA3S_RESEARCH_VIEW: .a3s/research/rust-async/index.html",
        &root,
    )
    .expect("trusted report marker should become a view");
    assert!(spec.url.starts_with("http://127.0.0.1:"), "{spec:?}");
    assert!(spec.url.contains("/a3s-local-view/"), "{spec:?}");
    assert!(spec.url.ends_with("/index.html"));
    assert!(spec.embeddable);
    let artifacts = research_report_artifacts_from_output(
        "done\nA3S_RESEARCH_VIEW: .a3s/research/rust-async/index.html",
        &root,
    )
    .expect("trusted report marker should resolve artifacts");
    assert_eq!(artifacts.html, html.canonicalize().unwrap());
    assert_eq!(artifacts.markdown, md.canonicalize().unwrap());
    assert!(
        research_report_artifacts_from_output_for_query(
            "done\nA3S_RESEARCH_VIEW: .a3s/research/rust-async/index.html",
            &root,
            "rust async",
        )
        .is_some(),
        "DeepResearch markers should resolve when the slug matches the query"
    );
    assert!(
        research_report_artifacts_from_output_for_query(
            "done\nA3S_RESEARCH_VIEW: .a3s/research/rust-async/index.html",
            &root,
            "old unrelated query",
        )
        .is_none(),
        "DeepResearch markers must not reuse a report slug from another query"
    );

    let incomplete_dir = root.join(".a3s/research/incomplete");
    std::fs::create_dir_all(&incomplete_dir).unwrap();
    std::fs::write(incomplete_dir.join("index.html"), "<!doctype html>").unwrap();
    std::fs::write(incomplete_dir.join("report.md"), "# Incomplete").unwrap();
    assert!(
        research_report_view_spec(
            "A3S_RESEARCH_VIEW: .a3s/research/incomplete/index.html",
            &root,
        )
        .is_none(),
        "formal report markers require a complete standalone HTML document"
    );

    let draft_dir = root.join(".a3s/research/draft");
    std::fs::create_dir_all(&draft_dir).unwrap();
    std::fs::write(
        draft_dir.join("index.html"),
        "<!doctype html><html><body><h1>DeepResearch Fallback Draft</h1></body></html>",
    )
    .unwrap();
    std::fs::write(
        draft_dir.join("report.md"),
        "# DeepResearch Fallback Draft\n\nNot a completed DeepResearch report.",
    )
    .unwrap();
    assert!(
        research_report_view_spec("A3S_RESEARCH_VIEW: .a3s/research/draft/index.html", &root,)
            .is_none(),
        "fallback draft artifacts must not be accepted as completed report markers"
    );

    let protocol_words_dir = root.join(".a3s/research/protocol-words");
    std::fs::create_dir_all(&protocol_words_dir).unwrap();
    let protocol_words_markdown = "# Protocol Words Report\n\n## Findings\n\nThe cited source documents the literal phrase DynamicWorkflowRuntime output and the path .a3s/workflow/run-123.jsonl as ordinary subject matter. These words do not act as Host control data.\n\n## Sources\n\n- https://example.com/protocol-words\n\n## Confidence\n\nConfidence is bounded by the cited source and its explicit scope.\n";
    write_completed_deep_research_test_artifacts(
        &protocol_words_dir,
        "protocol words",
        protocol_words_markdown,
        protocol_words_markdown,
    );
    assert!(
        research_report_view_spec(
            "A3S_RESEARCH_VIEW: .a3s/research/protocol-words/index.html",
            &root,
        )
        .is_some(),
        "reader prose must not act as the artifact-classification protocol"
    );

    assert!(research_report_view_spec(
        "A3S_RESEARCH_VIEW: .a3s/research/rust-async/report.md",
        &root,
    )
    .is_none());
    let non_index = report_dir.join("summary.html");
    std::fs::write(&non_index, "<!doctype html>").unwrap();
    assert!(research_report_view_spec(
        "A3S_RESEARCH_VIEW: .a3s/research/rust-async/summary.html",
        &root,
    )
    .is_none());
    let nested_dir = report_dir.join("nested");
    std::fs::create_dir_all(&nested_dir).unwrap();
    std::fs::write(nested_dir.join("index.html"), "<!doctype html>").unwrap();
    assert!(research_report_view_spec(
        "A3S_RESEARCH_VIEW: .a3s/research/rust-async/nested/index.html",
        &root,
    )
    .is_none());
    let empty_dir = root.join(".a3s/research/empty");
    std::fs::create_dir_all(&empty_dir).unwrap();
    std::fs::write(empty_dir.join("index.html"), "").unwrap();
    std::fs::write(empty_dir.join("report.md"), "# Report").unwrap();
    assert!(
        research_report_view_spec("A3S_RESEARCH_VIEW: .a3s/research/empty/index.html", &root,)
            .is_none()
    );
    let shallow_dir = root.join(".a3s/research/shallow");
    std::fs::create_dir_all(&shallow_dir).unwrap();
    std::fs::write(
        shallow_dir.join("index.html"),
        "<!doctype html><html><body><h1>Report</h1><p>Completed.</p></body></html>",
    )
    .unwrap();
    std::fs::write(shallow_dir.join("report.md"), "# Report\n\nCompleted.").unwrap();
    assert!(
        research_report_view_spec("A3S_RESEARCH_VIEW: .a3s/research/shallow/index.html", &root,)
            .is_none(),
        "completed report markers require more than placeholder-level content"
    );
    let keyword_only_dir = root.join(".a3s/research/keyword-only");
    std::fs::create_dir_all(&keyword_only_dir).unwrap();
    std::fs::write(
            keyword_only_dir.join("index.html"),
            "<!doctype html><html><body><h1>Report</h1><section><h2>Findings</h2><p>This report has fluent analysis and claims that evidence exists, but it deliberately avoids any traceable source anchor.</p></section><section><h2>Sources</h2><p>The source material is described only in prose without a URL or local path.</p></section><section><h2>Confidence</h2><p>Confidence is medium because limitations and risks are discussed in general terms.</p></section></body></html>",
        )
        .unwrap();
    std::fs::write(
            keyword_only_dir.join("report.md"),
            "# Report\n\n## Findings\n\nThis report has fluent analysis and claims that evidence exists, but it deliberately avoids any traceable source anchor.\n\n## Sources\n\nThe source material is described only in prose without a URL or local path.\n\n## Confidence\n\nConfidence is medium because limitations and risks are discussed in general terms.\n",
        )
        .unwrap();
    assert!(
        research_report_view_spec(
            "A3S_RESEARCH_VIEW: .a3s/research/keyword-only/index.html",
            &root,
        )
        .is_none(),
        "completed report markers require at least one traceable source URL or local path"
    );
    std::fs::remove_file(&md).unwrap();
    assert!(research_report_view_spec(
        "A3S_RESEARCH_VIEW: .a3s/research/rust-async/index.html",
        &root,
    )
    .is_none());
    assert!(research_report_view_spec("A3S_RESEARCH_VIEW: /etc/passwd", &root).is_none());
    assert!(research_report_view_spec("A3S_RESEARCH_VIEW: file:///etc/passwd", &root,).is_none());

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_completed_report_sources_must_trace_workflow_evidence() {
    let root = std::env::temp_dir().join(format!(
        "a3s-research-source-trace-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    let report_dir = root.join(".a3s/research/source-trace");
    std::fs::create_dir_all(&report_dir).unwrap();
    let marker = "done\nA3S_RESEARCH_VIEW: .a3s/research/source-trace/index.html";
    let workflow_output = serde_json::json!({
        "mode": "local_parallel_task",
        "research": {
            "status": "success",
            "results": [{
                "success": true,
                "structured": {
                    "summary": "Workflow evidence names the traceable source.",
                    "sources": [{
                        "title": "Workflow Source",
                        "url_or_path": "https://example.com/workflow-source",
                        "quote_or_fact": "The evidence source that the report must cite."
                    }],
                    "key_evidence": ["traceable source"],
                    "contradictions": [],
                    "confidence": "high",
                    "gaps": []
                }
            }]
        }
    })
    .to_string();

    let markdown = "# Source Trace\n\n## Findings\n\nThis report has polished analysis, conclusions, and confidence notes, but it cites an unrelated source instead of the gathered evidence.\n\n## Sources\n\n- https://example.com/fabricated-source\n\n## Confidence\n\nConfidence is low because source traceability should fail.\n";
    write_completed_deep_research_test_artifacts(&report_dir, "source trace", markdown, markdown);
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            marker,
            &root,
            "source trace",
            "",
            None,
        )
        .is_none(),
        "a report cannot be marked completed when this run captured no source anchors"
    );
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            marker,
            &root,
            "source trace",
            &workflow_output,
            None,
        )
        .is_none(),
        "DeepResearch reports must cite only sources traced to workflow evidence"
    );

    let markdown = "# Source Trace\n\n## Findings\n\nThis substantive report mentions one gathered source but also cites an unobserved suffixed source, so exact traceability must reject the whole completed report.\n\n## Sources\n\n- https://example.com/workflow-source\n- https://example.com/workflow-source-fabricated\n\n## Confidence\n\nConfidence is low because one explicit citation was never observed.\n";
    write_completed_deep_research_test_artifacts(&report_dir, "source trace", markdown, markdown);
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            marker,
            &root,
            "source trace",
            &workflow_output,
            None,
        )
        .is_none(),
        "every explicit report citation must exactly trace to observed workflow evidence"
    );

    let markdown = "# Source Trace\n\n## Findings\n\nThis substantive report has enough analysis and caveats, and its Markdown source list cites only the observed workflow evidence.\n\n## Sources\n\n- https://example.com/workflow-source\n\n## Confidence\n\nConfidence is medium because the gathered source is directly traceable.\n";
    let html_markdown = "# Source Trace\n\n## Findings\n\nThis substantive HTML has enough analysis and caveats but adds an unobserved citation.\n\n## Sources\n\n- https://example.com/workflow-source\n- [Fabricated HTML source](https://example.com/html-only-fabricated)\n\n## Confidence\n\nConfidence is medium because only one source was observed.\n";
    write_completed_deep_research_test_artifacts(
        &report_dir,
        "source trace",
        markdown,
        html_markdown,
    );
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            marker,
            &root,
            "source trace",
            &workflow_output,
            None,
        )
        .is_none(),
        "a separately written HTML report must not add unobserved citations"
    );

    let markdown = "# Source Trace\n\n## Findings\n\nThis substantive report includes an [unobserved inline citation](https://example.com/inline-fabricated) outside its otherwise valid source list.\n\n## Sources\n\n- https://example.com/workflow-source\n\n## Confidence\n\nConfidence is medium because the report records evidence limitations and caveats.\n";
    write_completed_deep_research_test_artifacts(&report_dir, "source trace", markdown, markdown);
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            marker,
            &root,
            "source trace",
            &workflow_output,
            None,
        )
        .is_none(),
        "inline citations outside the Sources section must still trace workflow evidence"
    );

    let markdown = "# Source Trace\n\n## Findings\n\nThis substantive report has analysis and caveats but includes an unobserved local citation behind a descriptive source label.\n\n## Sources\n\n- https://example.com/workflow-source\n- [Fake source](docs/unobserved.md)\n\n## Confidence\n\nConfidence is medium because the report explicitly records its evidence limits.\n";
    write_completed_deep_research_test_artifacts(&report_dir, "source trace", markdown, markdown);
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            marker,
            &root,
            "source trace",
            &workflow_output,
            None,
        )
        .is_none(),
        "explicit local citation links must be verified without interpreting heading text"
    );

    let markdown = "# Source Trace\n\n## Findings\n\nThis report has polished analysis, conclusions, caveats, and confidence notes anchored to the gathered workflow source.\n\n## Sources\n\n- https://example.com/workflow-source\n\n## Confidence\n\nConfidence is medium because the source traceability check can match the workflow evidence source.\n";
    write_completed_deep_research_test_artifacts(&report_dir, "source trace", markdown, markdown);
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            marker,
            &root,
            "source trace",
            &workflow_output,
            None,
        )
        .is_some(),
        "DeepResearch reports should pass when every report source traces workflow evidence"
    );

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_clean_final_text_can_reuse_valid_report_artifacts() {
    let root = std::env::temp_dir().join(format!(
        "a3s-research-clean-final-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    let report_dir = root.join(".a3s/research/clean-final");
    std::fs::create_dir_all(&report_dir).unwrap();
    let markdown = "# Clean Final\n\n## Findings\n\nThis source-backed report gives the final answer, cites the gathered source, and avoids narrating artifact operations.\n\n## Sources\n\n- https://example.com/source\n\n## Confidence\n\nConfidence is high because source traceability is explicit.\n";
    write_completed_deep_research_test_artifacts(&report_dir, "clean final", markdown, markdown);
    let workflow_output = serde_json::json!({
        "mode": "local_parallel_task",
        "research": {
            "status": "success",
            "results": [{
                "success": true,
                "structured": {
                    "summary": "source-backed",
                    "sources": [{
                        "url_or_path": "https://example.com/source",
                        "quote_or_fact": "source trace"
                    }],
                    "key_evidence": ["The source trace was observed by the workflow."],
                    "contradictions": [],
                    "confidence": "high",
                    "gaps": []
                }
            }]
        }
    })
    .to_string();
    let transport_output = "DynamicWorkflowRuntime output: internal transport details withheld.\nA3S_RESEARCH_VIEW: .a3s/research/clean-final/index.html";
    let artifacts = deep_research_report_artifacts_from_output_for_query(
        transport_output,
        &root,
        "clean final",
        &workflow_output,
        None,
    )
    .expect("valid report files should still be discoverable from a dirty final marker");
    let clean = clean_deep_research_final_text_from_artifacts(&artifacts, &root)
        .expect("host should be able to rebuild clean final text from report.md");
    assert!(clean.contains("A3S_RESEARCH_VIEW: .a3s/research/clean-final/index.html"));

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_recovery_is_degraded_and_fails_smoke_validation() {
    let root = std::env::temp_dir().join(format!(
        "a3s-research-smoke-degraded-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&root).unwrap();
    let artifacts = materialize_deep_research_recovery_report(
        &root,
        "Smoke degraded",
        "Evidence collection failed before a supported conclusion was available.",
        r#"{"mode":"local_parallel_task_failed","research":{"status":"failed","results":[]}}"#,
        None,
    )
    .expect("recovery artifact should remain available for diagnosis");
    let outcome = DeepResearchRunOutcome::Degraded;

    assert!(!outcome.report_ready());
    let error = outcome
        .ensure_smoke_success(&artifacts)
        .expect_err("a recovery artifact must make smoke exit non-zero");
    assert!(error.to_string().contains("degraded recovery report"));
    assert!(DeepResearchRunOutcome::Completed.report_ready());
    assert!(DeepResearchRunOutcome::Qualified.report_ready());

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_workflow_timeout_materializes_recovery_report() {
    let root = std::env::temp_dir().join(format!(
        "a3s-research-tui-workflow-timeout-recovery-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&root).unwrap();
    let workflow_output =
        "dynamic_workflow timed out after 360000 ms while gathering DeepResearch evidence";

    let artifacts = materialize_deep_research_recovery_report(
        &root,
        "arbitrary research subject",
        "##",
        workflow_output,
        None,
    )
    .expect("workflow timeout should still produce a recovery report");

    let markdown = std::fs::read_to_string(&artifacts.markdown).unwrap();
    let html = std::fs::read_to_string(&artifacts.html).unwrap();
    assert!(
        markdown.contains("DeepResearch Recovery Report"),
        "{markdown}"
    );
    assert!(markdown.contains("Evidence Status"), "{markdown}");
    assert!(markdown.contains("Confidence And Limits"), "{markdown}");
    assert!(!looks_like_deep_research_fallback_draft(&markdown));
    assert!(!looks_like_deep_research_fallback_draft(&html));
    assert!(
        deep_research_report_artifacts_from_output_for_query(
            "A3S_RESEARCH_VIEW: .a3s/research/2026-1-4-39bfe28c22da/index.html",
            &root,
            "arbitrary research subject",
            workflow_output,
            None,
        )
        .is_none(),
        "recovery reports must not pass completed-report validation"
    );

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_workflow_timeout_recovers_evidence_without_bypassing_review() {
    let root = std::env::temp_dir().join(format!(
        "a3s-research-tui-flow-timeout-evidence-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    let store = dynamic_workflow_store_path(&root);
    std::fs::create_dir_all(&store).unwrap();
    let run_id = "deepresearch-timeout-flow-test";
    let query = "timeout recovered evidence";
    let evidence = serde_json::json!({
        "summary": "The Flow event log preserved source-backed research after the host-side workflow timeout fired.",
        "sources": [{
            "title": "Recovered Flow Evidence",
            "url": "https://example.com/recovered-flow-evidence",
            "publication_date": "2026-07-09",
            "evidence": "A completed parallel task result was available in the durable workflow log.",
            "publisher": "deterministic test fixture"
        }],
        "key_evidence": ["The completed step output contains valid structured evidence JSON."],
        "contradictions": [],
        "confidence": "high for this deterministic timeout recovery path",
        "gaps": []
    });
    let lines = [
        serde_json::json!({
            "run_id": run_id,
            "sequence": 1,
            "event": {
                "type": "run_created",
                "spec": { "version": "source-hash" },
                "input": { "query": query }
            }
        }),
        serde_json::json!({
            "run_id": run_id,
            "sequence": 2,
            "event": { "type": "run_started" }
        }),
        serde_json::json!({
            "run_id": run_id,
            "sequence": 3,
            "event": {
                "type": "step_created",
                "step_id": "local_research",
                "step_name": "parallel_task",
                "input": { "allow_partial_failure": true, "tasks": [] }
            }
        }),
        serde_json::json!({
            "run_id": run_id,
            "sequence": 4,
            "event": {
                "type": "step_completed",
                "step_id": "local_research",
                "output": {
                    "tool": "parallel_task",
                    "exit_code": 0,
                    "metadata": {
                        "timed_out": false,
                        "task_count": 1,
                        "success_count": 1,
                        "failed_count": 0,
                        "results": [{
                            "success": true,
                            "source_anchors": [{
                                "tool": "web_search",
                                "url_or_path": "https://example.com/recovered-flow-evidence"
                            }],
                            "output": format!(
                                "Task completed: task-1\nAgent: deep-research\nOutput:\n{}",
                                evidence
                            )
                        }]
                    }
                }
            }
        }),
        serde_json::json!({
            "run_id": run_id,
            "sequence": 5,
            "event": {
                "type": "run_completed",
                "output": {
                    "query": query,
                    "mode": "local_parallel_task",
                    "research": {
                        "status": "success",
                        "metadata": {
                            "task_count": 1,
                            "success_count": 1,
                            "failed_count": 0
                        },
                        "results": [{
                            "success": true,
                            "structured": evidence.clone()
                        }]
                    }
                }
            }
        }),
    ]
    .into_iter()
    .map(|line| serde_json::to_string(&line).unwrap())
    .collect::<Vec<_>>()
    .join("\n");
    std::fs::write(store.join(format!("{run_id}.jsonl")), format!("{lines}\n")).unwrap();

    let args = serde_json::json!({
        "run_id": run_id,
        "input": { "query": query }
    });
    let result = deep_research_workflow_timeout_tool_result(
        &root,
        &args,
        "dynamic_workflow timed out after 195000 ms while gathering DeepResearch evidence"
            .to_string(),
    )
    .expect("timeout handler should recover durable Flow metadata");

    assert_eq!(
        result.exit_code, 0,
        "the fixture now models a Flow run that durably completed before the host timeout"
    );
    assert_eq!(result.name, "dynamic_workflow");
    let metadata = result.metadata.expect("recovered metadata");
    assert_eq!(
        metadata["dynamic_workflow"]["snapshot"]["steps"]["local_research"]["status"],
        "completed"
    );

    let ledger = accepted_evidence_ledger(&result.output, Some(&metadata));
    assert_eq!(ledger.len(), 1);
    assert_eq!(
        ledger[0].sources[0].anchor,
        "https://example.com/recovered-flow-evidence"
    );
    assert!(
        !root
            .join(".a3s/research/timeout-recovered-evidence/report.md")
            .exists(),
        "retrieval recovery must resume at closed-evidence review instead of publishing mechanically"
    );

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_fallback_draft_uses_only_typed_workflow_projection() {
    let root = std::env::temp_dir().join(format!(
        "a3s-research-fallback-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&root).unwrap();

    let artifacts = materialize_deep_research_fallback_draft(
        &root,
        "Rust async runtimes: Tokio & async-std",
        "Final answer with <unsafe> characters & citations.",
        r#"{"mode":"local_parallel_task","research":"evidence"}"#,
    )
    .expect("fallback draft should be written");

    assert!(artifacts.markdown.is_file());
    assert!(artifacts.html.is_file());
    let expected_slug = deep_research_report_slug("Rust async runtimes: Tokio & async-std");
    assert!(artifacts
        .html
        .ends_with(format!(".a3s/research/{expected_slug}/index.html")));
    let markdown = std::fs::read_to_string(&artifacts.markdown).unwrap();
    assert!(markdown.contains("# DeepResearch Fallback Draft"));
    assert!(markdown.contains("not a completed DeepResearch report"));
    assert!(markdown.contains("collection_status"));
    assert!(!markdown.contains("local_parallel_task"));
    assert!(!markdown.contains("unsafe"));
    assert!(!markdown.contains(RESEARCH_VIEW_MARKER));
    let html = std::fs::read_to_string(&artifacts.html).unwrap();
    assert!(html.contains("DeepResearch Fallback Draft"));
    assert!(!html.contains("unsafe"));
    assert!(!html.contains(RESEARCH_VIEW_MARKER));

    let timeout_artifacts = materialize_deep_research_fallback_draft(
            &root,
            "Timeout fallback report",
            "DeepResearch synthesis model call timed out after 480000 ms.",
            r#"{"mode":"local_parallel_task","research":{"metadata":{"success_count":4,"task_count":4},"output":"README.md evidence"}}"#,
        )
        .expect("timeout fallback draft should be written");
    let timeout_markdown = std::fs::read_to_string(&timeout_artifacts.markdown).unwrap();
    let answer_section = timeout_markdown
        .split("## Workflow Evidence")
        .next()
        .unwrap_or_default();
    assert!(answer_section.contains("captured 4/4 delegated research tasks"));
    assert!(!answer_section.contains("README.md"));
    assert!(
        !answer_section.contains("timed out after 480000 ms"),
        "{answer_section}"
    );
    assert!(timeout_markdown.contains("typed publication contract"));
    assert!(!timeout_markdown.contains("Model synthesis status"));

    let dirty_artifacts = materialize_deep_research_fallback_draft(
            &root,
            "Dirty fallback report",
            "● Searched web example results\n⎿ [tool output truncated: showing first bytes]",
            r#"{"mode":"local_parallel_task","research":{"metadata":{"success_count":1,"task_count":1},"output":"● Searched web\n⎿ [tool output truncated]"}}"#,
        )
        .expect("dirty fallback draft should be written with sanitized content");
    let dirty_markdown = std::fs::read_to_string(&dirty_artifacts.markdown).unwrap();
    let dirty_html = std::fs::read_to_string(&dirty_artifacts.html).unwrap();
    assert!(
        dirty_markdown.contains("sanitized evidence digest"),
        "{dirty_markdown}"
    );
    assert!(!dirty_markdown.contains("[tool output truncated]"));
    assert!(!dirty_html.contains("[tool output truncated]"));

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_fallback_slug_handles_long_and_non_ascii_queries() {
    assert_eq!(
        deep_research_report_slug("Rust async runtimes"),
        "rust-async-runtimes"
    );
    let cpp = deep_research_report_slug("C++ overview");
    let csharp = deep_research_report_slug("C# overview");
    assert_ne!(cpp, csharp, "semantic punctuation must not collide");
    assert!(cpp.starts_with("c-overview-"), "{cpp}");
    assert!(csharp.starts_with("c-overview-"), "{csharp}");

    let chinese = deep_research_report_slug("帮我深入研究书小安本地 API 和 Web 版本");
    assert!(chinese.starts_with("api-web-"), "{chinese}");
    assert!(chinese.len() <= 93, "{chinese}");

    let long_query = "compare ".repeat(80);
    let long_slug = deep_research_report_slug(&long_query);
    assert!(long_slug.len() <= 93, "{long_slug}");
    assert!(long_slug.starts_with("compare-compare"), "{long_slug}");

    let root = std::env::temp_dir().join(format!(
        "a3s-research-fallback-slug-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&root).unwrap();
    let artifacts =
        materialize_deep_research_fallback_draft(&root, &long_query, "answer", "evidence")
            .expect("long query fallback draft should be written");
    assert!(artifacts.html.is_file());
    assert!(
        artifacts
            .html
            .parent()
            .and_then(|path| path.file_name())
            .and_then(|name| name.to_str())
            .is_some_and(|slug| slug.len() <= 93),
        "{}",
        artifacts.html.display()
    );

    let _ = std::fs::remove_dir_all(&root);
}

#[test]
fn deep_research_safe_source_anchor_preserves_query_without_key_vocabulary() {
    let first = deep_research_safe_source_anchor(
        "https://example.test/resource?view=complete&Revision=7#selected-fragment",
    )
    .expect("the source identity should remain traceable");
    assert_eq!(
        first,
        "https://example.test/resource?view=complete&Revision=7"
    );

    let second = deep_research_safe_source_anchor(
        "https://user:password@example.com/resource?beta=two&Alpha=one#section",
    )
    .expect("bounded source parameters should survive sanitization");
    assert_eq!(
        second,
        "https://example.com/resource?beta=two&Alpha=one"
    );
    for removed in ["user", "password", "section"] {
        assert!(!second.contains(removed), "{second}");
    }
}


#[test]
fn deep_research_workflow_args_are_minimal_and_scope_is_explicit() {
    let args = deep_research_workflow_args("rust async runtimes");
    let source = args["source"].as_str().expect("workflow source");
    let safety = deep_research_safety_envelope(
        DeepResearchEvidenceScope::WebAndWorkspace,
        deep_research_default_budget(),
    );

    assert_eq!(args["input"]["query"], "rust async runtimes");
    assert_eq!(args["input"]["inquiry_host_managed"], true);
    assert!(args["input"].get("os_runtime").is_none());
    assert_eq!(args["input"]["evidence_scope"], "web_and_workspace");
    assert_eq!(
        args["input"]["loop_contract"]["pattern"],
        "evidence-first-deep-research"
    );
    assert_eq!(args["input"]["loop_contract"]["quota"]["mode"], "bounded");
    assert!(args["input"]["current_date"]
        .as_str()
        .is_some_and(|date| date.len() == 10));
    assert!(args["input"]["run_started_at_ms"]
        .as_u64()
        .is_some_and(|started_at| started_at > 0));
    assert_eq!(args["input"]["local_max_steps"], safety.max_steps_per_task);
    assert!(args["input"].get("local_max_parallel_tasks").is_none());
    assert_eq!(args["limits"]["timeoutMs"], safety.workflow_timeout_ms);
    assert_eq!(
        args["limits"]["maxToolCalls"],
        safety.workflow_max_tool_calls
    );
    assert_eq!(
        args["limits"]["maxOutputBytes"],
        safety.workflow_max_output_bytes
    );
    for obsolete in [
        "complexity_score",
        "complexity_layers",
        "local_research_rounds",
        "max_iterations",
        "execution_route",
        "research_method",
        "scout_queries",
    ] {
        assert!(
            args["input"].get(obsolete).is_none(),
            "obsolete workflow input: {obsolete}"
        );
    }

    assert_eq!(
        parse_deep_research_tui_query("--local-only latest web release"),
        (
            "latest web release".to_string(),
            DeepResearchEvidenceScope::LocalOnly
        )
    );
    assert_eq!(
        parse_deep_research_tui_query("--web do not use web"),
        (
            "do not use web".to_string(),
            DeepResearchEvidenceScope::WebAndWorkspace
        )
    );
    assert_eq!(
        parse_deep_research_tui_query("--webhook behavior"),
        (
            "--webhook behavior".to_string(),
            DeepResearchEvidenceScope::WebAndWorkspace
        )
    );
    assert_eq!(
        deep_research_input_scope_hint(),
        "◇ deep research · --web | --local-only"
    );
    assert_eq!(
        deep_research_workflow_args("仅本地分析当前工作区，不要联网；这只是普通查询文本。")
            ["input"]["evidence_scope"],
        "web_and_workspace",
        "natural-language keyword matching must not choose the evidence scope"
    );

    assert!(source.contains("ctx.tool(\"batch\""), "{source}");
    assert!(source.contains("tool: \"web_search\""), "{source}");
    assert!(source.contains("tool: \"web_fetch\""), "{source}");
    assert!(source.contains("ctx.tool(\"task\""), "{source}");
    assert!(source.contains("ctx.tool(\"generate_object\""), "{source}");
    assert!(source.contains("semantic_chunk_ids"), "{source}");
    assert!(source.contains("select_evidence_chunks"), "{source}");
    assert!(
        source.len() <= a3s_code_core::tools::MAX_PROGRAM_SCRIPT_SOURCE_BYTES,
        "workflow source exceeds the active program limit"
    );
    for obsolete in [
        "followUpTracks",
        "maxResearchRounds",
        "aggregateResearchRounds",
        "queryTerms",
        "queryTermMatches",
        "sourceRelevanceScore",
        "ctx.tool(\"parallel_task\"",
    ] {
        assert!(
            !source.contains(obsolete),
            "obsolete workflow behavior: {obsolete}"
        );
    }
}


#[test]
fn deep_research_goal_is_a_research_north_star_with_query() {
    let g = deep_research_goal("rust async runtimes");
    assert!(g.contains("rust async runtimes"), "{g}");
    assert!(g.to_lowercase().contains("research"), "{g}");
}

// ── scroll + copy ──────────────────────────────────────────────────────
#[test]
fn hidden_scrollbar_keeps_the_full_canvas_width() {
    let out = append_scrollbar("a\nb\nc", 5, 3, 100);
    assert_eq!(out.lines().count(), 3);
    for line in out.lines() {
        assert_eq!(a3s_tui::style::visible_len(line), 5);
        assert!(!line.contains('█') && !line.contains('│'));
    }
}

#[test]
fn hidden_scrollbar_continues_a_full_width_surface_background() {
    let background = Color::Rgb(49, 53, 58);
    let surface = Style::new().bg(background).render("abcde");
    let out = append_scrollbar(&surface, 5, 1, 100);

    assert_eq!(a3s_tui::style::visible_len(&out), 5);
    assert_eq!(a3s_tui::style::strip_ansi(&out), "abcde");
    assert_eq!(
        a3s_tui::markdown::trailing_ansi_background(&out),
        Some(background)
    );
}

#[test]
fn scrollbar_thumb_tracks_position() {
    let view = "r0\nr1\nr2\nr3"; // 4 visible rows, far more total
    let top = append_scrollbar(view, 4, 40, 0);
    assert!(top.lines().next().unwrap().contains('█'), "thumb at top");
    let bottom = append_scrollbar(view, 4, 40, 100);
    assert!(
        bottom.lines().last().unwrap().contains('█'),
        "thumb at bottom"
    );
    // every row carries the bar (thumb or track) once content overflows
    assert!(top.lines().all(|l| l.contains('█') || l.contains('│')));
    assert!(
        top.lines()
            .chain(bottom.lines())
            .all(|line| a3s_tui::style::visible_len(line) == 4),
        "overlay scrollbar must not grow the terminal canvas"
    );
}

#[test]
fn scrollbar_rows_with_emoji_graphemes_stay_within_the_terminal_canvas() {
    let canvas_width = 138usize;
    let headings = [
        "## ✏️ 代码编辑与生成",
        "## ⚙️ 执行与验证",
        "## 🛠️ 专项技能（Skills）",
        "## 👩‍💻 Agent collaboration",
    ];
    let view = headings
        .iter()
        .map(|heading| fit_viewport_row(heading, canvas_width))
        .collect::<Vec<_>>()
        .join("\n");
    let rendered = append_scrollbar(&view, canvas_width, headings.len() + 20, 37);

    for row in rendered.lines() {
        assert_eq!(
            a3s_tui::style::visible_len(row),
            canvas_width,
            "scrollbar row exceeded the terminal canvas: {row:?}"
        );
        assert!(
            matches!(
                a3s_tui::style::strip_ansi(row).chars().next_back(),
                Some('█' | '│')
            ),
            "scrollbar left the final column: {row:?}"
        );
    }
}

#[test]
fn streamed_markdown_table_keeps_the_scrollbar_in_the_final_canvas_column() {
    let canvas_width = 48usize;
    let markdown_width = transcript_markdown_width_for(canvas_width as u16);
    let link = "https://example.com/src/compact/compaction.rs";
    let mut streaming = StreamingMarkdown::new(markdown_width);
    assert!(streaming.push(&format!(
        "| 状态 | ✏️修改 | [compaction.rs]({link}) | 中文说明 |\n"
    )));

    let table = streaming.tail_view();
    let block = gutter(TN_GRAY, &table);
    let visible_rows = block.lines().count();
    let rendered = append_scrollbar(&block, canvas_width, visible_rows + 20, 37);

    assert!(!strip_ansi(&table).contains('|'), "{}", strip_ansi(&table));
    assert!(
        rendered.contains(&format!("\x1b]8;;{link}")),
        "{rendered:?}"
    );
    for row in rendered.lines() {
        assert_eq!(a3s_tui::style::visible_len(row), canvas_width, "{row:?}");
        let plain = a3s_tui::style::strip_ansi(row);
        assert!(
            matches!(plain.chars().next_back(), Some('█' | '│')),
            "scrollbar left the final column: {plain:?}"
        );
    }
}

#[test]
fn osc52_wraps_base64_in_envelope() {
    let s = osc52_copy("hi");
    assert!(s.starts_with("\u{1b}]52;c;") && s.ends_with('\u{7}'));
    assert!(s.contains("aGk=")); // base64("hi")
}

#[test]
fn osc52_bounds_utf8_bytes_without_splitting_a_character() {
    use base64::Engine;

    let source = "界".repeat(OSC52_PAYLOAD_BYTE_LIMIT);
    let envelope = osc52_copy(&source);
    let encoded = envelope
        .strip_prefix("\u{1b}]52;c;")
        .and_then(|value| value.strip_suffix('\u{7}'))
        .unwrap();
    let payload = base64::engine::general_purpose::STANDARD
        .decode(encoded)
        .unwrap();

    assert!(payload.len() <= OSC52_PAYLOAD_BYTE_LIMIT);
    assert!(std::str::from_utf8(&payload).is_ok());
    assert!(payload.len() < source.len());
}

#[test]
fn slice_cols_handles_ascii_and_wide() {
    assert_eq!(slice_cols("hello", 1, 4), "ell");
    assert_eq!(slice_cols("hello", 0, 100), "hello");
    // Wide glyphs are width-2: "あい" spans columns 0..4.
    assert_eq!(slice_cols("あい", 0, 2), "あ");
    assert_eq!(slice_cols("あい", 2, 4), "い");
}

#[test]
fn selection_to_text_extracts_span_across_rows() {
    let view = "  hello world\n  second line\n  third";
    // row0 col2..end, through row1 col0..8 — trailing padding trimmed.
    let t = selection_to_text(view, 0, 2, 1, 8);
    assert_eq!(t, "hello world\n  second");
}

#[test]
fn mouse_selection_uses_release_position_clamped_to_viewport() {
    assert_eq!(viewport_mouse_cell(2, 40, 4, 20), Some((2, 20)));
    assert_eq!(viewport_mouse_cell(4, 2, 4, 20), None);
    assert_eq!(viewport_mouse_cell_clamped(9, 40, 4, 20), Some((3, 20)));
    assert_eq!(viewport_mouse_cell_clamped(0, 1, 0, 20), None);
}

#[test]
fn highlight_selection_touches_only_selected_rows() {
    let view = "row zero\nrow one\nrow two";
    let out = highlight_selection(view, 1, 0, 1, 7);
    let lines: Vec<&str> = out.split('\n').collect();
    assert_eq!(lines[0], "row zero"); // untouched
    assert_eq!(lines[2], "row two"); // untouched
    assert!(lines[1].contains("row one")); // selected text preserved
    assert!(lines[1].contains('\u{1b}')); // wrapped in a style escape
}

/// `?` deep research is only meaningful if the agent actually has the web
/// tools to call — guard that they're registered in the session surface.
#[tokio::test]
async fn web_tools_registered_for_q_research_mode() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-research-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let cfg = dir.join("config.acl");
    test_config(&cfg);
    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), None)
        .await
        .unwrap();
    let names = session.tool_names();
    let _ = std::fs::remove_dir_all(&dir);
    assert!(
        names.contains(&"web_search".to_string()) && names.contains(&"web_fetch".to_string()),
        "the `?` deep-research mode relies on web_search + web_fetch; got {names:?}"
    );
}

#[test]
fn tui_default_policy_allows_readonly_research_tools() {
    use a3s_code_core::permissions::PermissionDecision;

    let policy = tui_permission_policy();

    assert_eq!(
        policy.check(
            "web_fetch",
            &serde_json::json!({"url": "https://example.com"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        policy.check("web_search", &serde_json::json!({"query": "a3s"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        policy.check("read", &serde_json::json!({"file_path": "README.md"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        policy.check(
            "write",
            &serde_json::json!({
                "file_path": ".a3s/research/rust-async/report.md",
                "content": "# Report"
            })
        ),
        PermissionDecision::Ask,
        "the live DeepResearch gate, not the base policy, owns confirmation-free report writes"
    );
    assert_eq!(
        policy.check(
            "Write",
            &serde_json::json!({
                "file_path": "/tmp/workspace/.a3s/research/rust-async/index.html",
                "content": "<!doctype html>"
            })
        ),
        PermissionDecision::Deny,
        "absolute report paths must not bypass the workspace boundary"
    );
    assert_eq!(
        policy.check(
            "write",
            &serde_json::json!({
                "file_path": ".a3s/research/rust-async/../../../README.md",
                "content": "path traversal"
            })
        ),
        PermissionDecision::Deny,
        "report-path traversal must be denied before the tool normalizes it"
    );
    assert_eq!(
        policy.check(
            "edit",
            &serde_json::json!({
                "file_path": ".a3s/research/rust-async/..\\..\\README.md",
                "old_string": "old",
                "new_string": "new"
            })
        ),
        PermissionDecision::Deny,
        "Windows-style report-path traversal must also be denied"
    );
    assert_eq!(
        policy.check(
            "edit",
            &serde_json::json!({
                "file_path": ".a3s/research/rust-async/report.md",
                "old_string": "old",
                "new_string": "new"
            })
        ),
        PermissionDecision::Ask,
        "the base policy must leave report edits to the scoped DeepResearch gate"
    );
    assert_eq!(
        policy.check(
            "write",
            &serde_json::json!({"file_path": "x", "content": "y"})
        ),
        PermissionDecision::Ask,
        "mutating tools must still go through TUI confirmation"
    );
    assert_eq!(
        policy.check(
            "edit",
            &serde_json::json!({
                "file_path": "README.md",
                "old_string": "old",
                "new_string": "new"
            })
        ),
        PermissionDecision::Ask,
        "non-report edits must still go through TUI confirmation"
    );
}

#[test]
fn tui_checker_uses_the_enforced_sandbox_instead_of_shell_lexing() {
    use a3s_code_core::permissions::{PermissionChecker, PermissionDecision};

    let checker = TuiHitlPermissionChecker::with_grants_and_execution(
        tui_permission_policy(),
        DeepResearchReportToolGate::default(),
        TuiPermissionGrants::default(),
        sandboxed_tui_execution_policy(Mode::Default, Path::new(".")),
    );

    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "pwd"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "rg Permission crates/cli/src/tui/mod.rs | head -20"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "git diff -- crates/cli/src/tui/mod.rs"})
        ),
        PermissionDecision::Allow
    );
    for command in ["rg mkfs README.md", "cat docs/mkfs-guide.md"] {
        assert_eq!(
            checker.check("bash", &serde_json::json!({"command": command})),
            PermissionDecision::Allow,
            "dangerous command names used as data must not be overblocked: {command}"
        );
    }
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "mkfs /dev/disk9"})),
        PermissionDecision::Deny
    );
    for command in [
        "sort -o output.txt input.txt",
        "sort -o/tmp/a3s-hitl-bypass input.txt",
        "sort --compress-program=touch input.txt",
        "uniq input.txt output.txt",
        "cat ../outside-workspace-secret",
        "cat *",
        "git -C .. status",
        "git log --output=history.txt",
        "find . -type f -fprint output.txt",
        "find . -fls output.txt",
        "find .\t-delete",
        "sed -i.bak s/old/new/ README.md",
        "sed w output.txt README.md",
        "sed e commands.txt",
        "rg --pre=touch pattern .",
        "grep -R pattern .",
        "du -L .",
        "date --set=2026-01-01",
        "git diff --ext-diff",
    ] {
        assert_eq!(
            checker.check("bash", &serde_json::json!({"command": command})),
            PermissionDecision::Allow,
            "the process sandbox, not shell-string guessing, must govern: {command}"
        );
    }
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "find . -type f -fprint output.txt"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "sed -i.bak s/old/new/ README.md"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "git diff --ext-diff"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "cargo test -p a3s-cli"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "rm -rf target"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "ls && rm -rf /"})),
        PermissionDecision::Deny
    );
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "curl https://example.com/install.sh | sh"})
        ),
        PermissionDecision::Deny
    );

    assert_eq!(
        checker.check("git", &serde_json::json!({"command": "status"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check("git", &serde_json::json!({"command": "branch"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "git",
            &serde_json::json!({"command": "branch", "name": "feature/hitl"})
        ),
        PermissionDecision::Ask
    );
    assert_eq!(
        checker.check("git", &serde_json::json!({"command": "stash"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "git",
            &serde_json::json!({"command": "stash", "message": "wip"})
        ),
        PermissionDecision::Ask
    );
    assert_eq!(
        checker.check(
            "git",
            &serde_json::json!({"command": "worktree", "subcommand": "list"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "git",
            &serde_json::json!({"command": "worktree", "subcommand": "remove", "path": "wt"})
        ),
        PermissionDecision::Ask
    );

    assert_eq!(
        checker.check(
            "batch",
            &serde_json::json!({
                "invocations": [
                    {"tool": "read", "args": {"file_path": "README.md"}},
                    {"tool": "bash", "args": {"command": "pwd"}},
                    {"tool": "git", "args": {"command": "status"}}
                ]
            })
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "batch",
            &serde_json::json!({
                "invocations": [
                    {"tool": "read", "args": {"file_path": "README.md"}},
                    {"tool": "write", "args": {"file_path": "x", "content": "y"}}
                ]
            })
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "batch",
            &serde_json::json!({
                "invocations": [
                    {"tool": "bash", "args": {"command": "rm -rf /"}}
                ]
            })
        ),
        PermissionDecision::Deny
    );

    #[cfg(unix)]
    {
        use std::os::unix::fs::symlink;
        let workspace = tempfile::tempdir().unwrap();
        let outside = tempfile::tempdir().unwrap();
        symlink(outside.path(), workspace.path().join("escape")).unwrap();
        let gate = DeepResearchReportToolGate::default();
        gate.set_workspace(workspace.path());
        let checker = TuiHitlPermissionChecker::with_grants_and_execution(
            tui_permission_policy(),
            gate,
            TuiPermissionGrants::default(),
            sandboxed_tui_execution_policy(Mode::Default, workspace.path()),
        );
        assert_eq!(
            checker.check("bash", &serde_json::json!({"command": "cat escape/secret"})),
            PermissionDecision::Deny
        );
    }
}

#[test]
fn exact_permission_grants_survive_checker_clones_without_bypassing_hard_denies() {
    use a3s_code_core::permissions::{PermissionChecker, PermissionDecision};

    let workspace = tempfile::tempdir().unwrap();
    let gate = DeepResearchReportToolGate::default();
    gate.set_workspace(workspace.path());
    let grants = TuiPermissionGrants::default();
    let checker =
        TuiHitlPermissionChecker::with_grants(tui_permission_policy(), gate, grants.clone());
    let allowed = serde_json::json!({"command": "cargo test -p a3s"});

    assert_eq!(checker.check("bash", &allowed), PermissionDecision::Ask);
    grants.allow_for_session(ExactPermissionGrant::from_invocation("bash", &allowed));
    assert_eq!(checker.check("bash", &allowed), PermissionDecision::Allow);
    assert_eq!(
        checker.check(
            "bash",
            &serde_json::json!({"command": "cargo test --workspace"})
        ),
        PermissionDecision::Ask
    );
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "rm -rf /"})),
        PermissionDecision::Deny
    );
}

#[test]
fn tui_auto_rejects_any_confirmation_event_after_the_permission_floor() {
    use a3s_code_core::permissions::{
        InteractiveToolGuardrail, PermissionChecker, PermissionDecision, ToolRiskAction,
        ToolRiskLevel,
    };

    let checker = InteractiveToolGuardrail::for_mode("auto").with_workspace(Path::new("."));
    let execution = sandboxed_tui_execution_policy(Mode::Auto, Path::new("."));
    for (tool, args, level, action, permission, auto_decision) in [
        (
            "read",
            serde_json::json!({"file_path": "README.md"}),
            ToolRiskLevel::Routine,
            ToolRiskAction::Allow,
            PermissionDecision::Allow,
            false,
        ),
        (
            "write",
            serde_json::json!({"file_path": "README.md"}),
            ToolRiskLevel::Bounded,
            ToolRiskAction::Allow,
            PermissionDecision::Allow,
            false,
        ),
        (
            "bash",
            serde_json::json!({"command": "cargo test"}),
            ToolRiskLevel::High,
            ToolRiskAction::ReviewByLlm,
            PermissionDecision::Ask,
            false,
        ),
        (
            "bash",
            serde_json::json!({"command": "rm -rf /"}),
            ToolRiskLevel::Critical,
            ToolRiskAction::RuleDeny,
            PermissionDecision::Deny,
            false,
        ),
    ] {
        assert_eq!(checker.assess(tool, &args).level, level);
        assert_eq!(checker.risk_action(tool, &args), action);
        assert_eq!(checker.check(tool, &args), permission);
        assert_eq!(
            execution.auto_confirmation_decision(tool, &args, Path::new(".")),
            Some(auto_decision),
            "TUI auto routing drifted from the shared guardrail for {tool}"
        );
    }
}

#[test]
fn auto_mode_rejects_every_unexpected_confirmation_without_hitl() {
    let execution = sandboxed_tui_execution_policy(Mode::Auto, Path::new("."));

    for (tool, args) in [
        ("write", serde_json::json!({"file_path": "README.md"})),
        (
            "git",
            serde_json::json!({"command": "checkout", "ref": "feature"}),
        ),
        (
            "batch",
            serde_json::json!({"invocations": [
                {"tool": "write", "args": {"file_path": "README.md"}}
            ]}),
        ),
        ("bash", serde_json::json!({"command": "cargo test"})),
        ("runtime", serde_json::json!({"tasks": ["external work"]})),
        ("program", serde_json::json!({"source": "return 1"})),
        ("task", serde_json::json!({"prompt": "inspect"})),
        (
            "parallel_task",
            serde_json::json!({"tasks": [{"prompt": "inspect"}]}),
        ),
        (
            "dynamic_workflow",
            serde_json::json!({"source": "async function run() {}"}),
        ),
        ("Skill", serde_json::json!({"skill_name": "review"})),
        (
            "mcp__github__create_issue",
            serde_json::json!({"title": "side effect"}),
        ),
        (
            "batch",
            serde_json::json!({"invocations": [
                {"tool": "bash", "args": {"command": "cargo test"}}
            ]}),
        ),
    ] {
        assert_eq!(
            execution.auto_confirmation_decision(tool, &args, Path::new(".")),
            Some(false),
            "an emitted confirmation means {tool} crossed the Auto boundary"
        );
    }
    assert_eq!(
        execution.auto_confirmation_decision(
            "bash",
            &serde_json::json!({"command": "rm -rf /"}),
            Path::new("."),
        ),
        Some(false),
        "a hard denial must be rejected without entering HITL"
    );
    assert_eq!(
        execution.auto_confirmation_decision(
            "bash",
            &serde_json::json!({
                "command": "cargo test",
                "sandbox_permissions": "require_escalated",
                "justification": "Needs the host."
            }),
            Path::new("."),
        ),
        Some(false),
        "Auto must reject sandbox escape without entering HITL"
    );
    let unavailable = TuiExecutionPolicy::for_workspace(Mode::Auto, PathBuf::from("."), None);
    assert_eq!(
        unavailable.auto_confirmation_decision(
            "bash",
            &serde_json::json!({"command": "cargo test"}),
            Path::new("."),
        ),
        Some(false),
        "Auto must fail closed when the process sandbox is unavailable"
    );
}

#[test]
fn deep_research_synthesis_gate_hides_and_denies_all_tools() {
    use a3s_code_core::permissions::{PermissionChecker, PermissionDecision};

    let gate = DeepResearchReportToolGate::default();
    gate.set_synthesis_only();
    let checker = TuiHitlPermissionChecker::new(tui_permission_policy(), gate);
    let args = serde_json::json!({});

    for tool in [
        "read",
        "write",
        "edit",
        "patch",
        "grep",
        "glob",
        "ls",
        "bash",
        "git",
        "web_search",
        "web_fetch",
        "batch",
        "program",
        "task",
        "parallel_task",
        "dynamic_workflow",
        "runtime",
        "generate_object",
        "Skill",
        "unknown_tool",
    ] {
        assert!(
            !checker.expose_to_model(tool),
            "{tool} must be hidden from a synthesis request"
        );
        assert_eq!(
            checker.check(tool, &args),
            PermissionDecision::Deny,
            "{tool} must be denied if invoked during synthesis"
        );
    }
}

#[test]
fn deep_research_evidence_gate_is_read_only_but_allows_bounded_orchestration() {
    use a3s_code_core::permissions::{PermissionChecker, PermissionDecision};

    let gate = DeepResearchReportToolGate::default();
    gate.set_evidence_scope(DeepResearchEvidenceScope::WebAndWorkspace);
    let checker = TuiHitlPermissionChecker::new(tui_permission_policy(), gate);

    for tool in ["read", "grep", "glob", "ls", "web_search", "web_fetch"] {
        assert!(
            checker.expose_to_model(tool),
            "{tool} should be visible during web evidence collection"
        );
    }
    for tool in [
        "write",
        "edit",
        "bash",
        "git",
        "batch",
        "task",
        "parallel_task",
        "dynamic_workflow",
        "Skill",
    ] {
        assert!(
            !checker.expose_to_model(tool),
            "{tool} should be hidden during evidence collection"
        );
    }

    assert_eq!(
        checker.check("read", &serde_json::json!({"file_path": "README.md"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check("web_search", &serde_json::json!({"query": "rust async"})),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "pwd"})),
        PermissionDecision::Deny
    );
    assert_eq!(
        checker.check(
            "parallel_task",
            &serde_json::json!({"tasks": [{"prompt": "collect evidence"}]})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "dynamic_workflow",
            &serde_json::json!({"source": "async function run() {}"})
        ),
        PermissionDecision::Allow
    );
    assert_eq!(
        checker.check(
            "write",
            &serde_json::json!({
                "file_path": ".a3s/research/rust/report.md",
                "content": "too early"
            })
        ),
        PermissionDecision::Deny,
        "evidence collectors must not write even the eventual report artifacts"
    );
    assert_eq!(
        checker.check(
            "write",
            &serde_json::json!({"file_path": "README.md", "content": "oops"})
        ),
        PermissionDecision::Deny
    );
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "touch injected"})),
        PermissionDecision::Deny
    );
    assert_eq!(
        checker.check("Skill", &serde_json::json!({"name": "untrusted"})),
        PermissionDecision::Deny
    );

    let local_gate = DeepResearchReportToolGate::default();
    let workspace = std::env::temp_dir().join(format!(
        "a3s-local-report-gate-{}-{}",
        std::process::id(),
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&workspace).unwrap();
    local_gate.set_workspace(&workspace);
    local_gate.set_evidence_scope(DeepResearchEvidenceScope::LocalOnly);
    let local_checker = TuiHitlPermissionChecker::new(tui_permission_policy(), local_gate.clone());
    assert_eq!(
        local_checker.check(
            "web_search",
            &serde_json::json!({"query": "must stay local"})
        ),
        PermissionDecision::Deny,
        "explicit local-only research must enforce the network boundary"
    );
    assert_eq!(
        local_checker.check(
            "web_fetch",
            &serde_json::json!({"url": "https://example.com"})
        ),
        PermissionDecision::Deny
    );
    assert!(!local_checker.expose_to_model("web_search"));
    assert!(!local_checker.expose_to_model("web_fetch"));
    let _ = std::fs::remove_dir_all(&workspace);
}

#[test]
fn tui_session_options_installs_smart_hitl_checker_and_persistable_policy() {
    use a3s_code_core::permissions::PermissionDecision;

    let confirmation = a3s_code_core::hitl::ConfirmationPolicy::enabled()
        .with_timeout(HITL_CONFIRM_TIMEOUT_MS, TimeoutAction::Reject);
    let opts = tui_session_options(confirmation);

    assert!(
        opts.permission_policy.is_some(),
        "the serializable fallback policy should still be persisted"
    );
    let checker = opts
        .permission_checker
        .as_ref()
        .expect("TUI sessions should install the smart HITL checker");
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "pwd"})),
        PermissionDecision::Ask
    );
    assert_eq!(
        checker.check(
            "write",
            &serde_json::json!({"file_path": "README.md", "content": "new"})
        ),
        PermissionDecision::Allow
    );
}

#[test]
fn tui_primary_model_hides_use_tools_but_keeps_worker_base_authorization() {
    use a3s_code_core::permissions::{PermissionChecker, PermissionDecision};

    let checker = TuiHitlPermissionChecker::new(
        tui_permission_policy(),
        DeepResearchReportToolGate::default(),
    );
    let tool = "mcp__use_browser__browser_snapshot";

    assert!(
        !checker.expose_to_model(tool),
        "the primary model must delegate application work to the Use worker"
    );
    assert_eq!(
        checker.check(tool, &serde_json::json!({"session": "fixture"})),
        PermissionDecision::Allow,
        "the explicit Use worker scope composes with this base authorization; MCP annotations perform escalation"
    );
}

#[test]
fn rebuilt_session_options_share_live_deep_research_gate_state() {
    use a3s_code_core::permissions::PermissionDecision;

    let gate = DeepResearchReportToolGate::default();
    let opts = tui_session_options_with_gate(
        a3s_code_core::hitl::ConfirmationPolicy::enabled(),
        gate.clone(),
    );
    let checker = opts
        .permission_checker
        .expect("rebuilt sessions should install the shared checker");

    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "pwd"})),
        PermissionDecision::Ask
    );
    gate.set_synthesis_only();
    assert_eq!(
        checker.check("bash", &serde_json::json!({"command": "pwd"})),
        PermissionDecision::Deny,
        "a gate transition in App must reach the rebuilt session checker"
    );
}

#[tokio::test]
async fn tui_session_policy_does_not_block_web_fetch() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-web-fetch-policy-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let cfg = dir.join("config.acl");
    test_config(&cfg);

    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let llm = Arc::new(CaptureLlmClient::new(vec![
        tool_call_response("web_fetch", serde_json::json!({"url": "not-a-url"})),
        done_response(),
    ]));
    let confirmation =
        a3s_code_core::hitl::ConfirmationPolicy::enabled().with_timeout(300, TimeoutAction::Reject);
    let opts = tui_session_options(confirmation)
        .with_llm_client(llm)
        .with_planning_mode(a3s_code_core::PlanningMode::Disabled);
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), Some(opts))
        .await
        .unwrap();

    let (mut rx, join) = session
        .stream("Fetch a URL for research.", None)
        .await
        .unwrap();
    let mut saw_fetch_end = None;
    while let Some(event) = rx.recv().await {
        match event {
            a3s_code_core::AgentEvent::ToolEnd {
                name,
                output,
                exit_code,
                ..
            } if name == "web_fetch" => {
                saw_fetch_end = Some((output, exit_code));
            }
            a3s_code_core::AgentEvent::PermissionDenied {
                tool_name, reason, ..
            } => panic!("{tool_name} was denied: {reason}"),
            a3s_code_core::AgentEvent::End { .. } => break,
            a3s_code_core::AgentEvent::Error { message } => panic!("{message}"),
            _ => {}
        }
    }
    join.await.unwrap();
    let _ = std::fs::remove_dir_all(&dir);

    let (output, exit_code) = saw_fetch_end.expect("web_fetch should run");
    assert_ne!(exit_code, 0, "invalid URL should fail validation");
    assert!(
        !output.contains("Permission denied"),
        "web_fetch should not be blocked by permission policy: {output}"
    );
}

#[tokio::test]
async fn auto_mode_executes_shell_side_effect_without_confirmation_event() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-auto-no-hitl-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let cfg = dir.join("config.acl");
    test_config(&cfg);

    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let llm = Arc::new(CaptureLlmClient::new(vec![
        tool_call_response(
            "bash",
            serde_json::json!({"command": "printf auto-mode-ok > auto-mode-probe.txt"}),
        ),
        done_response(),
    ]));
    let gate = DeepResearchReportToolGate::default();
    gate.set_workspace(&dir);
    let execution = sandboxed_tui_execution_policy(Mode::Auto, &dir);
    let opts = tui_session_options_with_gate_grants_and_execution(
        a3s_code_core::hitl::ConfirmationPolicy::enabled().with_timeout(300, TimeoutAction::Reject),
        gate,
        TuiPermissionGrants::default(),
        execution,
    )
    .with_llm_client(llm)
    .with_planning_mode(a3s_code_core::PlanningMode::Disabled);
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), Some(opts))
        .await
        .unwrap();

    let (mut rx, join) = session
        .stream("Create the requested probe file.", None)
        .await
        .unwrap();
    let mut shell_completed = false;
    while let Some(event) = rx.recv().await {
        match event {
            a3s_code_core::AgentEvent::ConfirmationRequired { tool_name, .. } => {
                panic!("Auto emitted an interactive confirmation for {tool_name}")
            }
            a3s_code_core::AgentEvent::PermissionDenied {
                tool_name, reason, ..
            } => panic!("{tool_name} was denied in Auto: {reason}"),
            a3s_code_core::AgentEvent::ToolEnd {
                name,
                output,
                exit_code,
                ..
            } if name == "bash" => {
                assert_eq!(exit_code, 0, "{output}");
                shell_completed = true;
            }
            a3s_code_core::AgentEvent::End { .. } => break,
            a3s_code_core::AgentEvent::Error { message } => panic!("{message}"),
            _ => {}
        }
    }
    join.await.unwrap();

    assert!(shell_completed, "the shell tool did not finish");
    assert_eq!(
        std::fs::read_to_string(dir.join("auto-mode-probe.txt")).unwrap(),
        "auto-mode-ok"
    );
    let _ = std::fs::remove_dir_all(&dir);
}

#[tokio::test]
async fn auto_mode_rejects_tool_owned_escalation_before_confirmation_event() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-auto-tool-escalation-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let cfg = dir.join("config.acl");
    test_config(&cfg);

    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let llm = Arc::new(CaptureLlmClient::new(vec![
        tool_call_response(
            "mcp__test__external_side_effect_probe",
            serde_json::json!({}),
        ),
        done_response(),
    ]));
    let gate = DeepResearchReportToolGate::default();
    gate.set_workspace(&dir);
    let execution = sandboxed_tui_execution_policy(Mode::Auto, &dir);
    let opts = tui_session_options_with_gate_grants_and_execution(
        a3s_code_core::hitl::ConfirmationPolicy::enabled().with_timeout(300, TimeoutAction::Reject),
        gate,
        TuiPermissionGrants::default(),
        execution,
    )
    .with_llm_client(llm)
    .with_planning_mode(a3s_code_core::PlanningMode::Disabled);
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), Some(opts))
        .await
        .unwrap();
    let executed = Arc::new(std::sync::atomic::AtomicBool::new(false));
    session
        .register_dynamic_tool(Arc::new(ConfirmationEscalatingTool {
            executed: Arc::clone(&executed),
        }))
        .unwrap();

    let (mut rx, join) = session
        .stream("Run the external side-effect probe.", None)
        .await
        .unwrap();
    let mut denied = false;
    while let Some(event) = rx.recv().await {
        match event {
            a3s_code_core::AgentEvent::ConfirmationRequired { tool_name, .. } => {
                panic!("Auto emitted an interactive confirmation for {tool_name}")
            }
            a3s_code_core::AgentEvent::PermissionDenied { tool_name, .. }
                if tool_name == "mcp__test__external_side_effect_probe" =>
            {
                denied = true;
            }
            a3s_code_core::AgentEvent::ToolExecutionStart { name, .. }
                if name == "mcp__test__external_side_effect_probe" =>
            {
                panic!("Auto executed an operation that requested boundary escalation")
            }
            a3s_code_core::AgentEvent::End { .. } => break,
            a3s_code_core::AgentEvent::Error { message } => panic!("{message}"),
            _ => {}
        }
    }
    join.await.unwrap();
    let _ = std::fs::remove_dir_all(&dir);

    assert!(denied, "the tool-owned escalation was not denied");
    assert!(
        !executed.load(std::sync::atomic::Ordering::SeqCst),
        "the external side effect ran despite the Auto boundary"
    );
}

#[tokio::test]
async fn hitl_wait_does_not_consume_tool_timeout_budget() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-hitl-timeout-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let cfg = dir.join("config.acl");
    test_config(&cfg);
    std::fs::write(dir.join("sample.txt"), "timeout sentinel").unwrap();

    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let llm = Arc::new(CaptureLlmClient::new(vec![
        tool_call_response("read", serde_json::json!({"file_path": "sample.txt"})),
        done_response(),
    ]));
    let confirmation = a3s_code_core::hitl::ConfirmationPolicy::enabled()
        .with_timeout(5_000, TimeoutAction::Reject);
    let opts = tui_session_options(confirmation)
        .with_tool_timeout(300)
        .with_llm_client(llm)
        .with_permission_policy(a3s_code_core::permissions::PermissionPolicy::new())
        .with_planning_mode(a3s_code_core::PlanningMode::Disabled);
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), Some(opts))
        .await
        .unwrap();

    let (mut rx, join) = session.stream("Read sample.txt.", None).await.unwrap();
    let mut saw_confirmation = false;
    let mut tool_output = None;
    while let Some(event) = rx.recv().await {
        match event {
            a3s_code_core::AgentEvent::ConfirmationRequired { tool_id, .. } => {
                saw_confirmation = true;
                tokio::time::sleep(Duration::from_millis(500)).await;
                assert!(session
                    .confirm_tool_use(&tool_id, true, None)
                    .await
                    .unwrap());
            }
            a3s_code_core::AgentEvent::ToolEnd {
                output, exit_code, ..
            } => {
                assert_eq!(exit_code, 0, "{output}");
                assert!(!output.contains("timed out"), "{output}");
                tool_output = Some(output);
            }
            a3s_code_core::AgentEvent::End { .. } => break,
            a3s_code_core::AgentEvent::Error { message } => panic!("{message}"),
            _ => {}
        }
    }
    join.await.unwrap();
    let _ = std::fs::remove_dir_all(&dir);

    assert!(saw_confirmation, "the tool call should require HITL");
    assert!(
        tool_output
            .as_deref()
            .is_some_and(|output| output.contains("timeout sentinel")),
        "tool output should come from read, got {tool_output:?}"
    );
}

/// Manual e2e guard for the TUI's natural-language asset creation prompts.
///
/// Runs against the real configured LLM and auto-approves the tool calls the
/// TUI would ask the user about. It is ignored by default because it spends
/// network/model time and writes a temporary asset workspace.
///
/// Run with:
/// `cargo test -q real_llm_natural_language_asset_creation -- --ignored --nocapture`
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
#[ignore = "hits the real configured LLM and writes temporary asset files"]
async fn real_llm_natural_language_asset_creation() {
    let home = std::env::var("HOME").expect("HOME");
    let config = format!("{home}/.a3s/config.acl");
    assert!(
        std::path::Path::new(&config).exists(),
        "no ~/.a3s/config.acl - configure a real model first"
    );

    let tmp = std::env::temp_dir().join(format!(
        "a3s-asset-realllm-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    let workspace = tmp.join("workspace");
    let roots = tmp.join("assets");
    let agent_root = roots.join("agents");
    let mcp_root = roots.join("mcps");
    let skill_root = roots.join("skills");
    let flow_root = roots.join("flows");
    for dir in [&workspace, &agent_root, &mcp_root, &skill_root, &flow_root] {
        std::fs::create_dir_all(dir).unwrap();
    }

    let agent = a3s_code_core::Agent::new(config)
        .await
        .expect("build agent from config.acl");
    let workspace_str = workspace.to_string_lossy().to_string();
    let only = std::env::var("A3S_REAL_LLM_ASSET_ONLY").ok().map(|value| {
        value
            .split(',')
            .map(str::trim)
            .filter(|value| !value.is_empty())
            .map(str::to_string)
            .collect::<std::collections::BTreeSet<_>>()
    });

    if only.as_ref().is_none_or(|only| only.contains("agent")) {
        eprintln!("\n[asset-e2e] creating agent");
        let dev = panels::agent::scaffold_agent_package(
                "Name it exactly a3s-e2e-review-agent. It reviews pull-request diffs for risky Rust changes and reports concise findings.",
                &agent_root,
            )
            .expect("scaffold agent asset package");
        let saved_path = verify_real_llm_agent_asset(&agent_root).expect("verify agent asset");
        eprintln!(
            "[asset-e2e] agent verified at {} scaffolded: {}",
            saved_path.display(),
            dev.package_path.display()
        );
    }

    let cases = vec![
            (
                "mcp",
                panels::mcp::mcp_gen_prompt(
                    "Name it exactly a3s-e2e-sql-checker. It exposes one stdio MCP tool that checks SQL text for obvious destructive statements.",
                    &mcp_root.to_string_lossy(),
                ),
            ),
            (
                "skill",
                panels::skill::skill_gen_prompt(
                    "Name it exactly a3s-e2e-incident-brief. It helps summarize incident notes into a customer-safe brief.",
                    &skill_root.to_string_lossy(),
                ),
            ),
            (
                "flow",
                panels::flow::flow_gen_prompt(
                    "Name it exactly a3s-e2e-triage-flow. It classifies an incoming support ticket, drafts a short answer, and ends.",
                    &flow_root.to_string_lossy(),
                ),
            ),
            (
                "okf",
                panels::okf::okf_package_gen_prompt(
                    "Name it exactly a3s-e2e-runbook-kb. It stores a small on-call runbook knowledge package for API outage triage.",
                    &workspace_str,
                ),
            ),
        ];

    for (label, prompt) in cases {
        if only.as_ref().is_some_and(|only| !only.contains(label)) {
            continue;
        }
        eprintln!("\n[asset-e2e] creating {label}");
        let session = real_llm_asset_session(&agent, &workspace, label).await;
        let (answer, saved_path) = real_llm_asset_turn(&session, label, &prompt, || match label {
            "agent" => verify_real_llm_agent_asset(&agent_root),
            "mcp" => verify_real_llm_mcp_asset(&mcp_root),
            "skill" => verify_real_llm_skill_asset(&skill_root),
            "flow" => verify_real_llm_flow_asset(&flow_root),
            "okf" => verify_real_llm_okf_asset(&workspace),
            _ => Err(format!("unknown asset e2e label {label}")),
        })
        .await;
        eprintln!(
            "[asset-e2e] {label} verified at {} final: {}",
            saved_path.display(),
            truncate(&answer, 500)
        );
    }

    if std::env::var_os("A3S_REAL_LLM_ASSET_KEEP").is_some() {
        eprintln!("[asset-e2e] kept {}", tmp.display());
    } else {
        let _ = std::fs::remove_dir_all(&tmp);
    }
}

async fn real_llm_asset_session(
    agent: &a3s_code_core::Agent,
    workspace: &std::path::Path,
    label: &str,
) -> a3s_code_core::AgentSession {
    let confirmation = a3s_code_core::hitl::ConfirmationPolicy::enabled()
        .with_timeout(HITL_CONFIRM_TIMEOUT_MS, TimeoutAction::Reject);
    let opts = tui_session_options(confirmation)
        .with_session_id(format!("asset-e2e-{label}-{}", std::process::id()))
        .with_auto_save(false)
        .with_tool_timeout(90_000)
        .with_planning_mode(a3s_code_core::PlanningMode::Disabled);
    agent
        .session_async(workspace.to_string_lossy().to_string(), Some(opts))
        .await
        .expect("real LLM asset session")
}

async fn real_llm_asset_turn<F>(
    session: &a3s_code_core::AgentSession,
    label: &str,
    prompt: &str,
    mut verify: F,
) -> (String, std::path::PathBuf)
where
    F: FnMut() -> Result<std::path::PathBuf, String>,
{
    let timeout_secs = std::env::var("A3S_REAL_LLM_ASSET_TIMEOUT_SECS")
        .ok()
        .and_then(|value| value.parse::<u64>().ok())
        .unwrap_or(240);
    let label_contract = if label == "agent" {
        "For the agent package, completeness means package files, prompts, examples, evals, \
             tests/checklists, and A3S metadata on disk; do not scaffold or run an application, \
             do not install dependencies, and do not execute the generated agent."
    } else {
        ""
    };
    let prompt = format!(
        "{prompt}\n\n\
             {label_contract}\n\
             E2E completion contract: create exactly one asset package. Use at most four tool \
             calls; if the asset root is outside the workspace, create every required file with \
             bash heredocs in the first tool call when possible. Once the files and JSON \
             validation are complete, stop using tools immediately and answer with \
             `ASSET_E2E_DONE: <saved package path>`."
    );
    let fut = async {
        let (mut rx, join) = session.stream(&prompt, None).await.expect("stream start");
        let mut final_text = String::new();
        let mut streamed = String::new();
        let mut tool_count = 0usize;
        let mut verified_path = None;
        let mut last_verify_error = "asset files were not checked yet".to_string();
        while let Some(event) = rx.recv().await {
            match event {
                a3s_code_core::AgentEvent::TextDelta { text } => streamed.push_str(&text),
                a3s_code_core::AgentEvent::ToolStart { name, .. } => {
                    tool_count += 1;
                    eprintln!("[asset-e2e:{label}] tool start: {name}");
                }
                a3s_code_core::AgentEvent::ToolEnd {
                    name,
                    output,
                    exit_code,
                    ..
                } => {
                    eprintln!(
                        "[asset-e2e:{label}] tool end: {name} exit {exit_code}: {}",
                        output.lines().take(2).collect::<Vec<_>>().join(" | ")
                    );
                    match verify() {
                        Ok(path) => {
                            eprintln!(
                                "[asset-e2e:{label}] verifier passed after {tool_count} tool(s)"
                            );
                            verified_path = Some(path);
                            let _ = session.cancel().await;
                            break;
                        }
                        Err(error) => {
                            last_verify_error = error;
                        }
                    }
                }
                a3s_code_core::AgentEvent::ConfirmationRequired {
                    tool_id, tool_name, ..
                } => {
                    eprintln!("[asset-e2e:{label}] auto-approving {tool_name}");
                    session
                        .confirm_tool_use(
                            &tool_id,
                            true,
                            Some("real LLM asset e2e auto-approval".to_string()),
                        )
                        .await
                        .expect("confirm tool use");
                }
                a3s_code_core::AgentEvent::PermissionDenied {
                    tool_name, reason, ..
                } => {
                    panic!("{label}: tool {tool_name} denied: {reason}");
                }
                a3s_code_core::AgentEvent::End { text, .. } => {
                    final_text = if text.trim().is_empty() {
                        streamed.clone()
                    } else {
                        text
                    };
                    match verify() {
                        Ok(path) => verified_path = Some(path),
                        Err(error) => last_verify_error = error,
                    }
                    break;
                }
                a3s_code_core::AgentEvent::Error { message } => {
                    panic!("{label}: real LLM turn errored: {message}");
                }
                _ => {}
            }
        }
        assert!(
            tool_count > 0,
            "{label}: expected the real LLM to use tools"
        );
        let verified_path = verified_path
            .unwrap_or_else(|| panic!("{label}: verifier never passed: {last_verify_error}"));
        tokio::time::timeout(Duration::from_secs(30), join)
            .await
            .unwrap_or_else(|_| panic!("{label}: stream worker did not stop after verifier pass"))
            .expect("stream task join");
        (final_text, verified_path)
    };
    tokio::time::timeout(Duration::from_secs(timeout_secs), fut)
        .await
        .unwrap_or_else(|_| panic!("{label}: real LLM turn timed out after {timeout_secs}s"))
}

fn verify_real_llm_agent_asset(root: &std::path::Path) -> Result<std::path::PathBuf, String> {
    let agent_md = find_required_file(root, "agent.md")?;
    let body = std::fs::read_to_string(&agent_md)
        .map_err(|e| format!("could not read {}: {e}", agent_md.display()))?;
    let def = a3s_code_core::subagent::parse_agent_md(&body)
        .map_err(|e| format!("{} is not a valid agent.md: {e}", agent_md.display()))?;
    if def.name.trim().is_empty() || def.description.trim().is_empty() {
        return Err("agent definition should carry name and description".to_string());
    }
    let package = agent_md.parent().unwrap();
    for rel in [
        "README.md",
        "prompts/system.md",
        "workflows/operating-procedure.md",
        "examples/example-input.md",
        "examples/example-output.md",
        "eval/smoke.md",
        "tests/smoke.md",
    ] {
        if !package.join(rel).is_file() {
            return Err(format!("agent package missing required file {rel}"));
        }
    }
    assert_asset_acl_only_metadata(package)?;
    assert_forbidden_asset_files(
        package,
        &[
            "agent.asset.json",
            "agent.config.json",
            "agent.runtime-binding.json",
            "runtime-binding.json",
            "package.json",
        ],
    )?;
    Ok(package.to_path_buf())
}

fn verify_real_llm_mcp_asset(root: &std::path::Path) -> Result<std::path::PathBuf, String> {
    let entrypoint = find_required_file(root, "server.js")
        .or_else(|_| find_required_file(root, "server.py"))
        .or_else(|_| find_required_file(root, "mcp.py"))?;
    let package = entrypoint.parent().unwrap();
    if !package.join("README.md").is_file() {
        return Err("missing MCP README.md".to_string());
    }
    assert_asset_acl_only_metadata(package)?;
    assert_forbidden_asset_files(
        package,
        &[
            "package.json",
            "mcp.asset.json",
            "mcp.server.json",
            "mcp.runtime-binding.json",
            "runtime-binding.json",
        ],
    )?;
    Ok(package.to_path_buf())
}

fn verify_real_llm_skill_asset(root: &std::path::Path) -> Result<std::path::PathBuf, String> {
    let skill_md = find_required_file(root, "SKILL.md")?;
    let skill = a3s_code_core::skills::Skill::from_file(&skill_md)
        .map_err(|e| format!("{} is not a valid SKILL.md: {e}", skill_md.display()))?;
    if skill.name.trim().is_empty() || skill.description.trim().is_empty() {
        return Err("skill should carry name and description".to_string());
    }
    let package = skill_md.parent().unwrap();
    if !package.join("README.md").is_file() {
        return Err("missing skill README.md".to_string());
    }
    assert_asset_acl_only_metadata(package)?;
    assert_forbidden_asset_files(
        package,
        &[
            "skill.asset.json",
            "skill.runtime-binding.json",
            "runtime-binding.json",
        ],
    )?;
    Ok(package.to_path_buf())
}

fn verify_real_llm_flow_asset(root: &std::path::Path) -> Result<std::path::PathBuf, String> {
    let flow_json = find_required_file(root, "flow.json")?;
    let flow = assert_json_file(&flow_json)?;
    let nodes = flow["nodes"]
        .as_array()
        .ok_or_else(|| "flow nodes must be an array".to_string())?;
    if !(nodes.iter().any(|node| node["kind"] == "start")
        && nodes.iter().any(|node| node["kind"] == "end"))
    {
        return Err("flow should have start and end nodes".to_string());
    }
    let package = flow_json.parent().unwrap();
    assert_asset_acl_only_metadata(package)?;
    assert_forbidden_asset_files(
        package,
        &[
            "workflow.design.json",
            "workflow.asset.json",
            "workflow.runtime-binding.json",
            "runtime-binding.json",
        ],
    )?;
    Ok(package.to_path_buf())
}

fn verify_real_llm_okf_asset(workspace: &std::path::Path) -> Result<std::path::PathBuf, String> {
    let root = workspace.join("okf");
    let readme = find_required_file(&root, "README.md")?;
    let package = readme.parent().unwrap().to_path_buf();
    if !package.join("README.md").is_file() {
        return Err("missing OKF README.md".to_string());
    }
    if !package.join("sources").is_dir() {
        return Err("missing OKF sources/".to_string());
    }
    if !package.join("wiki/index.md").is_file() {
        return Err("missing OKF wiki/index.md".to_string());
    }
    assert_asset_acl_only_metadata(&package)?;
    assert_forbidden_asset_files(
        &package,
        &[
            "package.okf.json",
            "knowledge.asset.json",
            "knowledge.runtime-binding.json",
            "runtime-binding.json",
        ],
    )?;
    Ok(package)
}

fn assert_asset_acl_only_metadata(package: &std::path::Path) -> Result<(), String> {
    let acl = package.join(".a3s/asset.acl");
    if !acl.is_file() {
        return Err(format!("missing {}", acl.display()));
    }
    let metadata_dir = package.join(".a3s");
    let entries = std::fs::read_dir(&metadata_dir)
        .map_err(|e| format!("could not read {}: {e}", metadata_dir.display()))?;
    for entry in entries.flatten() {
        let path = entry.path();
        let rel = path
            .strip_prefix(package)
            .unwrap_or(&path)
            .components()
            .map(|part| part.as_os_str().to_string_lossy())
            .collect::<Vec<_>>()
            .join("/");
        if rel != ".a3s/asset.acl" {
            return Err(format!(".a3s should contain only asset.acl, found {rel}"));
        }
    }
    Ok(())
}

fn assert_forbidden_asset_files(package: &std::path::Path, names: &[&str]) -> Result<(), String> {
    let mut files = Vec::new();
    collect_all_files(package, &mut files);
    for file in files {
        let rel = file
            .strip_prefix(package)
            .unwrap_or(&file)
            .components()
            .map(|part| part.as_os_str().to_string_lossy())
            .collect::<Vec<_>>()
            .join("/");
        let basename = file
            .file_name()
            .and_then(|name| name.to_str())
            .unwrap_or("");
        if names.iter().any(|name| *name == rel || *name == basename) {
            return Err(format!("asset package should not contain {rel}"));
        }
    }
    Ok(())
}

fn collect_all_files(dir: &std::path::Path, out: &mut Vec<std::path::PathBuf>) {
    let Ok(entries) = std::fs::read_dir(dir) else {
        return;
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.is_dir() {
            collect_all_files(&path, out);
        } else if path.is_file() {
            out.push(path);
        }
    }
}

fn find_required_file(root: &std::path::Path, name: &str) -> Result<std::path::PathBuf, String> {
    let mut matches = Vec::new();
    collect_files_named(root, name, &mut matches);
    matches.sort();
    matches
        .into_iter()
        .next()
        .ok_or_else(|| format!("expected {name} under {}", root.display()))
}

fn collect_files_named(root: &std::path::Path, name: &str, out: &mut Vec<std::path::PathBuf>) {
    let Ok(entries) = std::fs::read_dir(root) else {
        return;
    };
    for entry in entries.flatten() {
        let path = entry.path();
        if path.is_dir() {
            collect_files_named(&path, name, out);
        } else if path.file_name().and_then(|n| n.to_str()) == Some(name) {
            out.push(path);
        }
    }
}

fn assert_json_file(path: impl AsRef<std::path::Path>) -> Result<serde_json::Value, String> {
    let path = path.as_ref();
    let text = std::fs::read_to_string(path)
        .map_err(|e| format!("could not read JSON {}: {e}", path.display()))?;
    serde_json::from_str(&text).map_err(|e| format!("{} is not valid JSON: {e}", path.display()))
}

#[test]
fn asset_scaffolds_create_parseable_visible_file_formats() {
    let root = std::env::temp_dir().join(format!(
        "a3s-asset-format-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    let _ = std::fs::remove_dir_all(&root);
    std::fs::create_dir_all(&root).unwrap();

    let agent_root = root.join("agents");
    std::fs::create_dir_all(&agent_root).unwrap();
    let agent = panels::agent::scaffold_agent_package(
        "Name it exactly format-reviewer. It reviews asset file formats.",
        &agent_root,
    )
    .unwrap();
    assert_asset_acl_only_metadata(&agent.package_path).unwrap();
    assert_forbidden_asset_files(
        &agent.package_path,
        &[
            "agent.asset.json",
            "agent.config.json",
            "agent.runtime-binding.json",
            "runtime-binding.json",
            "package.json",
        ],
    )
    .unwrap();
    let agent_md = std::fs::read_to_string(agent.package_path.join("agent.md")).unwrap();
    let agent_def = a3s_code_core::subagent::parse_agent_md(&agent_md).unwrap();
    assert_eq!(agent_def.name, "format-reviewer");
    assert_eq!(agent_def.max_steps, Some(30));
    assert!(agent_def.description.contains("reviews asset file formats"));
    assert!(agent_def
        .prompt
        .as_deref()
        .is_some_and(|prompt| prompt.contains("# format-reviewer")));
    let agent_acl =
        std::fs::read_to_string(agent.package_path.join(asset_lifecycle::ASSET_ACL_PATH)).unwrap();
    assert_asset_acl_format(
        &agent_acl,
        "agent",
        &[
            "definition_path = \"agent.md\"",
            "package_path = \".\"",
            "runtime_kind = \"a3s-agent-service\"",
        ],
    );

    let mcp_root = root.join("mcps");
    std::fs::create_dir_all(&mcp_root).unwrap();
    let mcp = panels::mcp::scaffold_mcp_project(
        "Name it exactly format-tools. It exposes file format checks.",
        &mcp_root,
    )
    .unwrap();
    assert_asset_acl_only_metadata(&mcp.path).unwrap();
    assert_forbidden_asset_files(
        &mcp.path,
        &[
            "package.json",
            "mcp.asset.json",
            "mcp.server.json",
            "mcp.runtime-binding.json",
            "runtime-binding.json",
        ],
    )
    .unwrap();
    let server_js = std::fs::read_to_string(mcp.path.join("server.js")).unwrap();
    assert!(server_js.starts_with("const description = "));
    assert!(server_js.contains("process.stdin.on('data'"));
    assert!(server_js.contains("JSON.stringify(response)"));
    let mcp_acl = std::fs::read_to_string(mcp.path.join(asset_lifecycle::ASSET_ACL_PATH)).unwrap();
    assert_asset_acl_format(
        &mcp_acl,
        "mcp",
        &[
            "entrypoint = \"server.js\"",
            "package_root = \".\"",
            "runtime_kind = \"a3s-function-service\"",
            "protocol = \"mcp\"",
        ],
    );

    let skill_root = root.join("skills");
    std::fs::create_dir_all(&skill_root).unwrap();
    let skill = panels::skill::scaffold_skill_asset(
        "Name it exactly format-skill. It checks generated asset formats.",
        &skill_root,
    )
    .unwrap();
    let skill_package = skill.path.parent().unwrap();
    assert_asset_acl_only_metadata(skill_package).unwrap();
    assert_forbidden_asset_files(
        skill_package,
        &[
            "skill.asset.json",
            "skill.runtime-binding.json",
            "runtime-binding.json",
            "package.json",
        ],
    )
    .unwrap();
    let parsed_skill = a3s_code_core::skills::Skill::from_file(&skill.path).unwrap();
    assert_eq!(parsed_skill.name, "format-skill");
    assert!(matches!(
        parsed_skill.kind,
        a3s_code_core::skills::SkillKind::Instruction
    ));
    assert!(parsed_skill
        .allowed_tools
        .as_deref()
        .is_some_and(|tools| tools.contains("Read(*)")));
    let skill_acl =
        std::fs::read_to_string(skill_package.join(asset_lifecycle::ASSET_ACL_PATH)).unwrap();
    assert_asset_acl_format(
        &skill_acl,
        "skill",
        &[
            "definition_path = \"SKILL.md\"",
            "runtime_kind = \"a3s-function-service\"",
        ],
    );

    let flow_root = root.join("flows");
    std::fs::create_dir_all(&flow_root).unwrap();
    let flow_json = panels::flow::scaffold_flow_asset(
        "Name it exactly format-flow. It validates generated files.",
        &flow_root,
    )
    .unwrap();
    let flow_package = flow_json.parent().unwrap();
    assert_asset_acl_only_metadata(flow_package).unwrap();
    assert_forbidden_asset_files(
        flow_package,
        &[
            "workflow.design.json",
            "workflow.asset.json",
            "workflow.runtime-binding.json",
            "runtime-binding.json",
        ],
    )
    .unwrap();
    assert_eq!(
        flow_json.file_name().and_then(|name| name.to_str()),
        Some("flow.json")
    );
    let flow = assert_json_file(&flow_json).unwrap();
    assert_eq!(flow["version"], "a3s.workflow.design.v1");
    assert_eq!(flow["name"], "format-flow");
    let nodes = flow["nodes"].as_array().unwrap();
    assert_eq!(
        nodes.iter().filter(|node| node["kind"] == "start").count(),
        1
    );
    assert_eq!(nodes.iter().filter(|node| node["kind"] == "end").count(), 1);
    assert!(flow["edges"]
        .as_array()
        .unwrap()
        .iter()
        .all(|edge| edge.get("sourceNodeID").is_some() && edge.get("targetNodeID").is_some()));
    let flow_acl =
        std::fs::read_to_string(flow_package.join(asset_lifecycle::ASSET_ACL_PATH)).unwrap();
    assert_asset_acl_format(
        &flow_acl,
        "workflow",
        &[
            "design_document_path = \"flow.json\"",
            "runtime_kind = \"a3s-workflow-service\"",
            "protocol = \"workflow\"",
        ],
    );

    let okf_root = root.join("okf");
    std::fs::create_dir_all(&okf_root).unwrap();
    let okf = panels::okf::scaffold_okf_package(
        "Name it exactly format-knowledge. It documents asset formats.",
        &okf_root,
    )
    .unwrap();
    assert_asset_acl_only_metadata(&okf.path).unwrap();
    assert_forbidden_asset_files(
        &okf.path,
        &[
            "package.okf.json",
            "knowledge.asset.json",
            "knowledge.runtime-binding.json",
            "runtime-binding.json",
            "package.json",
        ],
    )
    .unwrap();
    assert!(std::fs::read_to_string(okf.path.join("README.md"))
        .unwrap()
        .starts_with("# format-knowledge\n\n"));
    assert!(okf.path.join("sources/overview.md").is_file());
    assert!(okf.path.join("wiki/index.md").is_file());
    assert!(okf.path.join("wiki/concepts/example.md").is_file());
    assert!(okf.path.join("eval/smoke.md").is_file());
    let okf_acl = std::fs::read_to_string(okf.path.join(asset_lifecycle::ASSET_ACL_PATH)).unwrap();
    assert_asset_acl_format(
        &okf_acl,
        "knowledge",
        &[
            "readme_path = \"README.md\"",
            "sources_path = \"sources\"",
            "wiki_path = \"wiki\"",
            "eval_path = \"eval\"",
            "runtime_kind = \"a3s-knowledge-service\"",
            "protocol = \"okf\"",
        ],
    );

    let _ = std::fs::remove_dir_all(&root);
}

fn assert_asset_acl_format(acl: &str, category: &str, required: &[&str]) {
    assert!(acl.starts_with("version = \"a3s.asset.v1\"\n"), "{acl}");
    assert!(acl.contains(&format!("category = \"{category}\"")), "{acl}");
    assert!(acl.contains("created_by = \"a3s-code-tui\""), "{acl}");
    assert!(acl.contains("source {\n"), "{acl}");
    assert!(acl.contains("metadata {\n"), "{acl}");
    assert!(acl.contains("asset_acl_path = \".a3s/asset.acl\""), "{acl}");
    assert!(acl.contains("runtime {\n"), "{acl}");
    for field in required {
        assert!(acl.contains(field), "missing {field} in:\n{acl}");
    }
}

#[tokio::test]
async fn claude_session_surface_passes_system_tools_and_skills_to_llm() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-claude-surface-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let cfg = dir.join("config.acl");
    test_config(&cfg);
    std::fs::write(
        dir.join("CLAUDE.md"),
        "Project rule: claude-session-surface-marker",
    )
    .unwrap();
    let skill_dir = dir.join(".claude/skills/inspect-surface");
    std::fs::create_dir_all(&skill_dir).unwrap();
    std::fs::write(
        skill_dir.join("SKILL.md"),
        "---\nname: inspect-surface\n\
             description: Inspect the Claude session surface\n\
             kind: instruction\n\
             allowed-tools:\n  - Read\n---\n\
             Use this skill marker: inspect-surface-skill-marker\n",
    )
    .unwrap();

    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let llm = Arc::new(CaptureLlmClient::new(vec![done_response()]));
    let opts = SessionOptions::new()
        .with_llm_client(llm.clone())
        .with_prompt_slots(
            SystemPromptSlots::default()
                .with_extra(project_instructions(dir.to_str().unwrap()).unwrap()),
        )
        .with_skill_dirs(agent_skill_dirs(dir.to_str().unwrap()))
        .with_manual_delegation_enabled(true)
        .with_auto_delegation_enabled(false)
        .with_planning_mode(a3s_code_core::PlanningMode::Disabled);
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), Some(opts))
        .await
        .unwrap();

    let (mut rx, join) = session
        .stream("Use available skills to inspect this project.", None)
        .await
        .unwrap();
    while let Some(event) = rx.recv().await {
        if matches!(event, a3s_code_core::AgentEvent::End { .. }) {
            break;
        }
    }
    join.await.unwrap();
    let turns = llm.turns();
    let captured = turns.first().unwrap();
    let system = captured.system.as_deref().unwrap();
    let _ = std::fs::remove_dir_all(&dir);

    assert!(
        system.contains("You are A3S Code"),
        "core system prompt should reach the LLM"
    );
    assert!(
        system.contains("claude-session-surface-marker"),
        "CLAUDE.md project instructions should reach the LLM"
    );
    assert!(
        system.contains("# Skills"),
        "skill catalog guidance should reach the LLM system prompt"
    );
    assert!(
        captured.tools.iter().any(|name| name == "read")
            && captured.tools.iter().any(|name| name == "Skill")
            && captured.tools.iter().any(|name| name == "search_skills")
            && captured.tools.iter().any(|name| name == "parallel_task"),
        "a3s tools and skill tools should be model-visible; got {:?}",
        captured.tools
    );
}

#[tokio::test]
async fn claude_can_invoke_skill_and_child_run_receives_skill_prompt() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-claude-skill-invoke-{}-{}",
        std::process::id(),
        std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap()
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).unwrap();
    let cfg = dir.join("config.acl");
    test_config(&cfg);
    let skill_dir = dir.join(".claude/skills/inspect-surface");
    std::fs::create_dir_all(&skill_dir).unwrap();
    std::fs::write(
        skill_dir.join("SKILL.md"),
        "---\nname: inspect-surface\n\
             description: Inspect the Claude session surface\n\
             kind: instruction\n\
             allowed-tools:\n  - Read\n---\n\
             Use this skill marker: inspect-surface-skill-marker\n",
    )
    .unwrap();

    let agent = a3s_code_core::Agent::new(cfg.to_string_lossy().to_string())
        .await
        .unwrap();
    let llm = Arc::new(CaptureLlmClient::new(vec![
        tool_call_response(
            "Skill",
            serde_json::json!({
                "skill_name": "inspect-surface",
                "prompt": "Apply the inspect-surface skill."
            }),
        ),
        done_response(),
        done_response(),
    ]));
    let opts = SessionOptions::new()
        .with_llm_client(llm.clone())
        .with_skill_dirs(agent_skill_dirs(dir.to_str().unwrap()))
        .with_manual_delegation_enabled(true)
        .with_auto_delegation_enabled(false)
        .with_permission_policy(
            a3s_code_core::permissions::PermissionPolicy::new().allow("Skill(*)"),
        )
        .with_planning_mode(a3s_code_core::PlanningMode::Disabled)
        .with_max_tool_rounds(5);
    let session = agent
        .session_async(dir.to_string_lossy().to_string(), Some(opts))
        .await
        .unwrap();

    let result = session
        .send("Use the inspect-surface skill.", None)
        .await
        .unwrap();
    let turns = llm.turns();
    let _ = std::fs::remove_dir_all(&dir);

    assert_eq!(result.text.trim(), "DONE");
    let system_snippets = turns
        .iter()
        .enumerate()
        .map(|(index, turn)| {
            format!(
                "#{index}: {}",
                turn.system
                    .as_deref()
                    .unwrap_or("<none>")
                    .chars()
                    .take(220)
                    .collect::<String>()
            )
        })
        .collect::<Vec<_>>()
        .join("\n");
    assert!(
        turns
            .iter()
            .any(|turn| turn.system.as_deref().is_some_and(|system| {
                system.contains("You are executing the 'inspect-surface' skill")
                    && system.contains("inspect-surface-skill-marker")
            })),
        "Skill tool should start a child LLM run with the skill prompt; turns: {}",
        system_snippets
    );
}

#[test]
fn workflow_doc_captures_single_task_dispatch() {
    let args = serde_json::json!({
        "agent": "plan",
        "description": "Design the rendering architecture",
        "prompt": "Plan a layered renderer."
    });
    let (doc, label) = workflow_doc_for_tool("task", Some(&args)).unwrap();

    assert!(label.contains("delegated task"), "{label}");
    assert!(!label.contains("dynamic workflow"), "{label}");
    assert!(doc.starts_with("# Delegation\n\n"), "{doc}");
    assert!(doc.contains("Design the rendering architecture"));
    assert!(doc.contains("Agent: `plan`"));
    assert!(doc.contains("Plan a layered renderer."));
}

#[test]
fn workflow_doc_names_parallel_task_as_delegation() {
    let args = serde_json::json!({
        "tasks": [
            {"agent": "explore", "description": "Inspect parser", "prompt": "Read parser.rs"},
            {"agent": "review", "description": "Review parser", "prompt": "Review parser.rs"}
        ]
    });
    let (doc, label) = workflow_doc_for_tool("parallel_task", Some(&args)).unwrap();

    assert_eq!(label, "delegation · 2 parallel tasks captured");
    assert!(doc.starts_with("# Parallel delegation\n\n"), "{doc}");
    assert!(!doc.contains("# Dynamic workflow"), "{doc}");
}

#[test]
fn workflow_doc_captures_semantic_intent_without_copying_program_source() {
    let args = serde_json::json!({
        "source": format!(
            "async function run(ctx, inputs) {{\n{}\n}}",
            "  const boilerplate = true;\n".repeat(1_601)
        ),
        "input": {
            "query": "Nimbus support status",
            "evidence_scope": "web_and_workspace",
            "inquiry_host_managed": true,
            "loop_contract": {
                "pattern": "minimal-deep-research",
                "hard_caps": {
                    "max_searches": 4,
                    "max_fetches": 8
                }
            }
        }
    });
    let (doc, label) = workflow_doc_for_tool("dynamic_workflow", Some(&args)).unwrap();

    assert!(
        label.contains("dynamic workflow intent captured"),
        "{label}"
    );
    assert!(!label.contains("/flow"), "{label}");
    assert!(
        doc.contains("DeepResearch “Nimbus support status”"),
        "{doc}"
    );
    assert!(
        doc.contains("≤2 typed-coverage passes · ≤4 searches · ≤8 fetches"),
        "{doc}"
    );
    assert!(!doc.contains("async function run"), "{doc}");
    assert!(!doc.contains("boilerplate"), "{doc}");
}

#[test]
fn synthesis_requires_activity_without_followup_text() {
    // Fires when a turn had agent activity but produced no final text — in
    // ANY mode (no effort gate), so a high-effort fan-out that ends silently
    // still gets a synthesized answer.
    assert!(needs_synthesis(false, false, true, false));
    // No final answer needed if the turn already produced text after activity.
    assert!(!needs_synthesis(false, false, true, true));
    // At most once per turn.
    assert!(!needs_synthesis(false, true, true, false));
    // Nothing to synthesize if no work happened (e.g. a bare greeting).
    assert!(!needs_synthesis(false, false, false, false));
    // Never while a synthesis turn is itself in flight.
    assert!(!needs_synthesis(true, false, true, false));
}

#[tokio::test]
async fn automatic_continuation_waits_for_previous_stream_join() {
    use std::sync::atomic::{AtomicBool, Ordering};

    let (session, dir) = deep_research_settlement_test_session("join-barrier").await;
    let worker_finished = Arc::new(AtomicBool::new(false));
    let (release_tx, release_rx) = tokio::sync::oneshot::channel();
    let worker_finished_for_join = Arc::clone(&worker_finished);
    let stream_join = tokio::spawn(async move {
        let _ = release_rx.await;
        worker_finished_for_join.store(true, Ordering::Release);
    });
    let synthesis = Some(("synthesis prompt".to_string(), "task".to_string()));
    let wait = tokio::spawn(wait_for_stream_join(
        session,
        stream_join,
        41,
        synthesis.clone(),
    ));

    tokio::task::yield_now().await;
    assert!(
        !wait.is_finished(),
        "continuation released before stream join"
    );

    release_tx.send(()).expect("release stream worker");
    let a3s_tui::cmd::CmdResult::Msg(Msg::StreamJoinSettled {
        token,
        synthesis: settled_synthesis,
    }) = wait.await.expect("stream wait task")
    else {
        panic!("expected StreamJoinSettled");
    };
    assert_eq!(token, 41);
    assert_eq!(settled_synthesis, synthesis);
    assert!(worker_finished.load(Ordering::Acquire));
    let _ = std::fs::remove_dir_all(dir);
}

#[tokio::test]
async fn escape_abort_releases_terminal_stream_wait_immediately() {
    let (session, dir) = deep_research_settlement_test_session("escape-join").await;
    let stream_join = tokio::spawn(std::future::pending::<()>());
    let abort = stream_join.abort_handle();
    let wait = tokio::spawn(wait_for_stream_join(session, stream_join, 42, None));

    tokio::task::yield_now().await;
    assert!(
        !wait.is_finished(),
        "the stale worker should still hold the barrier"
    );

    // This is the same abort handle used by the Esc path while a terminal
    // stream worker is still persisting or releasing the single-flight lease.
    abort.abort();
    let result = tokio::time::timeout(Duration::from_secs(1), wait)
        .await
        .expect("Esc should not wait for the normal two-second settle grace")
        .expect("stream-settle command");
    assert!(matches!(
        result,
        a3s_tui::cmd::CmdResult::Msg(Msg::StreamJoinSettled {
            token: 42,
            synthesis: None
        })
    ));
    let _ = std::fs::remove_dir_all(dir);
}

#[test]
fn queued_user_turns_are_fifo_within_priority() {
    fn queued(text: &str) -> Queued {
        Queued {
            text: text.to_string(),
            display: text.to_string(),
            images: Vec::new(),
            runtime_expectation: None,
            deep_research: None,
        }
    }

    let mut queue = PriorityQueue::new();
    queue.push(SYNTHETIC_TURN_PRIORITY, queued("autonomous continuation"));
    queue.push(USER_TURN_PRIORITY, queued("first"));
    queue.push(USER_TURN_PRIORITY, queued("second"));
    queue.push(USER_TURN_PRIORITY, queued("third"));
    let drained = std::iter::from_fn(|| {
        queue
            .pop()
            .map(PriorityItem::into_value)
            .map(|turn| turn.text)
    })
    .collect::<Vec<_>>();

    assert_eq!(
        drained,
        ["first", "second", "third", "autonomous continuation"]
    );
}

#[test]
fn interrupted_continuation_prioritizes_deep_research_then_goal_then_queue() {
    assert_eq!(
        App::interrupted_continuation(false, true),
        InterruptedContinuation::SettleDeepResearch
    );
    assert_eq!(
        App::interrupted_continuation(true, false),
        InterruptedContinuation::RestoreGoalMode
    );
    assert_eq!(
        App::interrupted_continuation(false, false),
        InterruptedContinuation::DrainQueue
    );
}

#[tokio::test]
async fn discarded_stream_start_releases_session_before_reuse() {
    let dir = std::env::temp_dir().join(format!(
        "a3s-discard-stream-{}-{}",
        std::process::id(),
        SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .expect("clock")
            .as_nanos()
    ));
    std::fs::create_dir_all(&dir).expect("temp workspace");
    let cfg = dir.join("config.acl");
    test_config(&cfg);
    let agent = Agent::new(cfg.to_string_lossy().to_string())
        .await
        .expect("agent");
    let llm = Arc::new(CaptureLlmClient::new(vec![
        done_response(),
        done_response(),
    ]));
    let session = Arc::new(
        agent
            .session_async(
                dir.to_string_lossy().to_string(),
                Some(SessionOptions::new().with_llm_client(llm)),
            )
            .await
            .expect("session"),
    );

    let (rx, join) = session.stream("first", None).await.expect("first stream");
    drop(rx);
    let result = tokio::time::timeout(
        Duration::from_secs(5),
        discard_started_stream(Arc::clone(&session), join, 17),
    )
    .await
    .expect("discard timeout");
    assert!(matches!(
        result,
        a3s_tui::cmd::CmdResult::Msg(Msg::DiscardedStreamSettled { token: 17 })
    ));

    let (mut rx, join) = session
        .stream("second", None)
        .await
        .expect("session admission should be released");
    while let Some(event) = rx.recv().await {
        if matches!(event, AgentEvent::End { .. }) {
            break;
        }
    }
    join.await.expect("second stream join");
    let _ = std::fs::remove_dir_all(&dir);
}

#[test]
fn estimate_tokens_counts_wide_unicode_heavier_than_ascii() {
    assert_eq!(estimate_tokens("abcd"), 1); // ASCII ~4 chars/token
    assert_eq!(estimate_tokens("かなテストあ"), 6); // wide text ~1 token/char
    assert_eq!(estimate_tokens("hi かな"), 2); // mixed: 3 ASCII -> 0, 2 wide -> 2
    assert_eq!(estimate_tokens(""), 0);
}

#[test]
fn ctx_limit_falls_back_when_undeclared() {
    let default_context_limit = resolve_ctx_limit(None);
    assert_eq!(resolve_ctx_limit(Some(200_000)), 200_000); // declared wins
    assert_eq!(resolve_ctx_limit(Some(0)), default_context_limit); // zero -> default
    assert_eq!(resolve_ctx_limit(None), default_context_limit); // missing -> default
}

#[test]
fn ctx_limit_prefers_declared_then_infers_account_models() {
    let mut ctx = std::collections::HashMap::new();
    ctx.insert("openai/gpt-5".to_string(), 256_000);

    assert_eq!(ctx_limit_for_model(&ctx, "openai/gpt-5"), 256_000);
    assert_eq!(
        crate::budget::inferred_context_limit_for_model("claude-sonnet-4-6"),
        Some(200_000)
    );
    assert_eq!(
        crate::budget::inferred_context_limit_for_model("claude-opus-4-8[1m]"),
        Some(1_000_000)
    );
    assert_eq!(
        crate::budget::inferred_context_limit_for_model("gpt-4.1"),
        Some(1_000_000)
    );
    assert_eq!(
        crate::budget::inferred_context_limit_for_model("glm-5.1"),
        Some(resolve_ctx_limit(None))
    );
    assert_eq!(
        ctx_limit_for_model(&ctx, "unknown-model"),
        resolve_ctx_limit(None)
    );
}

#[test]
fn auto_compact_threshold_uses_the_active_model_window() {
    assert!((AUTO_COMPACT_THRESHOLD - 0.85).abs() < f64::EPSILON);
}

#[test]
fn ctx_warn_tier_latches_once_and_rearms_on_drop() {
    // Climb: 0 → warn at 70 tier → no re-warn inside the tier → warn at 85.
    assert_eq!(ctx_warn_tier(40, 0), (0, None));
    assert_eq!(ctx_warn_tier(72, 0), (70, Some(70)));
    assert_eq!(ctx_warn_tier(79, 70), (70, None)); // same tier: silent
    assert_eq!(ctx_warn_tier(91, 70), (85, Some(85)));
    assert_eq!(ctx_warn_tier(100, 85), (85, None));
    // Drop (compaction, /clear, wider model): latch re-arms.
    assert_eq!(ctx_warn_tier(30, 85), (0, None));
    assert_eq!(ctx_warn_tier(72, 0), (70, Some(70)));
    // Jump straight past both tiers warns the top one only.
    assert_eq!(ctx_warn_tier(90, 0), (85, Some(85)));
}

#[test]
fn task_tool_empty_child_output_renders_useful_summary() {
    let args = serde_json::json!({
        "agent": "plan",
        "description": "Plan subsystem boundaries",
        "prompt": "Create the plan."
    });
    let meta = serde_json::json!({
        "task_id": "task-abc123",
        "session_id": "task-run-task-abc123",
        "agent": "plan",
        "success": true,
        "output_bytes": 0,
        "artifact_uri": "a3s://tasks/task-run-task-abc123/runs/task-abc123/output"
    });
    let output = "Task completed: task-abc123\n\
                      Agent: plan\n\
                      Session: task-run-task-abc123\n\
                      Task ID: task-abc123\n\
                      Artifact ID: task-output:task-abc123\n\
                      Artifact URI: a3s://tasks/task-run-task-abc123/runs/task-abc123/output\n\
                      Output:\n";
    let out = render_tool_end("task", 0, output, Some(&meta), Some(&args), 100);
    let plain = strip_ansi(&out);

    assert!(plain.contains("Delegated"));
    assert!(plain.contains("Task completed · plan · task-abc123"));
    assert!(plain.contains("no child text output"));
    assert!(plain.contains("artifact: a3s://tasks/task-run-task-abc123"));
}

#[test]
fn edit_metadata_renders_colored_diff() {
    let meta = serde_json::json!({
        "file_path": "src/x.rs",
        "before": "let a = 1;\nkeep;\n",
        "after": "let a = 2;\nkeep;\n",
    });
    let out = render_tool_end("edit", 0, "ok", Some(&meta), None, 80);
    // The diff code is syntax-highlighted (ANSI between tokens), so compare
    // against the ANSI-stripped text.
    let plain = strip_ansi(&out);
    assert!(plain.contains("src/x.rs"), "header has path");
    assert!(
        plain.contains("+1") && plain.contains("-1"),
        "add/del counts"
    );
    assert!(plain.contains("let a = 2;"), "shows inserted line");
    assert!(plain.contains("let a = 1;"), "shows deleted line");
    assert!(
        plain.contains("keep;"),
        "context lines are shown (unified diff)"
    );
    assert!(plain.contains("Edited src/x.rs"), "edit header with path");
}

/// Strip ANSI SGR sequences so tests can match the underlying text.
fn strip_ansi(s: &str) -> String {
    let mut out = String::new();
    let mut chars = s.chars();
    while let Some(c) = chars.next() {
        if c == '\x1b' {
            for c2 in chars.by_ref() {
                if c2 == 'm' {
                    break;
                }
            }
        } else {
            out.push(c);
        }
    }
    out
}

#[test]
fn non_edit_tool_renders_status_line() {
    let out = render_tool_end("bash", 0, "hello\nworld", None, None, 80);
    // Action-verb header ("Ran") + the output; no diff marker.
    assert!(out.contains("Ran") && out.contains("hello"));
    assert!(!out.contains('✎'), "no diff marker for non-edit tools");
}

#[test]
fn tool_end_shows_primary_arg_summary() {
    let args = serde_json::json!({ "command": "npm test", "timeout": 60 });
    let out = render_tool_end("bash", 0, "ok\n", None, Some(&args), 80);
    // Bash args are token-colored (program/flags/args), so check visible text.
    let plain = a3s_tui::style::strip_ansi(&out);
    assert!(plain.contains("Ran"), "action verb for bash");
    assert!(plain.contains("npm test"), "shows the command argument");
}

#[test]
fn arg_summary_extracts_known_keys() {
    assert_eq!(
        arg_summary(&serde_json::json!({ "command": "ls -la" })),
        Some("ls -la".to_string())
    );
    assert_eq!(
        arg_summary(&serde_json::json!({ "pattern": "TODO" })),
        Some("TODO".to_string())
    );
    assert_eq!(arg_summary(&serde_json::json!({ "unknown": "x" })), None);
}

#[test]
fn slash_tail_requires_a_token_boundary() {
    let parameterized = [
        "/login", "/island", "/ctx", "/kb", "/okf", "/goal", "/loop", "/sleep", "/flow", "/agent",
        "/mcp", "/skill", "/fork", "/use", "/copy", "/export",
    ];

    for cmd in parameterized {
        assert_eq!(slash_tail(cmd, cmd), Some(""), "{cmd} accepts bare form");
        assert_eq!(
            slash_tail(&format!("{cmd} argument"), cmd),
            Some(" argument"),
            "{cmd} accepts whitespace-delimited arguments"
        );
        assert_eq!(
            slash_tail(&format!("{cmd}x"), cmd),
            None,
            "{cmd}x must remain a normal message, not {cmd}"
        );
        assert_eq!(
            slash_tail(&format!("{cmd}-token"), cmd),
            None,
            "{cmd}-token must remain a normal message, not {cmd}"
        );
    }
}

#[test]
fn use_status_command_is_read_only_and_has_bounded_forms() {
    assert_eq!(app_submit::parse_use_status_command(""), Ok(false));
    assert_eq!(app_submit::parse_use_status_command(" status "), Ok(false));
    assert_eq!(app_submit::parse_use_status_command(" repair "), Ok(true));
    assert_eq!(
        app_submit::parse_use_status_command("install"),
        Err("usage: /use [status|repair]")
    );
}

#[test]
fn cloned_asset_focus_matches_only_paths_inside_the_clone_root() {
    let clone_root = std::path::Path::new("/tmp/a3s-assets/weather-agent");
    assert!(App::path_is_within(clone_root, clone_root));
    assert!(App::path_is_within(
        std::path::Path::new("/tmp/a3s-assets/weather-agent/agent.md"),
        clone_root
    ));
    assert!(App::path_is_within(
        std::path::Path::new("/tmp/a3s-assets/weather-agent/nested/asset.json"),
        clone_root
    ));
    assert!(!App::path_is_within(
        std::path::Path::new("/tmp/a3s-assets/weather-agent-2/agent.md"),
        clone_root
    ));
}

#[test]
fn runtime_asset_query_carries_asset_category_and_terms() {
    assert_eq!(
        runtime_asset_query("mcp", "Calc Tools", "failed calls"),
        "category:mcp Calc Tools failed calls"
    );
    assert_eq!(
        runtime_asset_query("workflow", "daily-flow", ""),
        "category:workflow daily-flow"
    );
    assert_eq!(runtime_asset_query("", "", "stale"), "stale");
}

#[test]
fn slash_command_registry_is_unique_english_and_idle_safe() {
    let mut seen = HashSet::new();
    for (cmd, desc) in SLASH_COMMANDS {
        assert!(cmd.starts_with('/'), "{cmd} should be a slash command");
        assert!(
            !cmd.contains(char::is_whitespace),
            "{cmd} should be the bare command token"
        );
        assert!(seen.insert(*cmd), "{cmd} should not be registered twice");
        assert!(
            !desc.trim().is_empty(),
            "{cmd} should have a menu description"
        );
        assert!(
            !contains_cjk(desc),
            "{cmd} description should stay English-only: {desc}"
        );
        assert!(
            !desc.to_ascii_lowercase().contains("repo"),
            "{cmd} slash-menu copy should not expose asset-workspace management: {desc}"
        );
    }

    for cmd in IDLE_ONLY {
        assert!(
            SLASH_COMMANDS
                .iter()
                .any(|(registered, _)| registered == cmd),
            "{cmd} is idle-only but missing from the slash registry"
        );
    }

    let removed_commands = [
        "im", "run", "deploy", "review", "list", "ps", "workflow", "repo", "git",
    ]
    .into_iter()
    .map(|name| format!("/{name}"))
    .chain([
        format!("/{}{}", "evo", "lve"),
        format!("/{}{}", "evo", "love"),
    ]);
    for removed in removed_commands {
        assert!(
            !SLASH_COMMANDS
                .iter()
                .any(|(cmd, _)| *cmd == removed.as_str()),
            "{removed} should stay removed from the slash registry"
        );
    }
}

#[test]
fn asset_root_commands_are_backed_by_lifecycle_services() {
    let asset_commands: HashSet<&str> = asset_lifecycle::ASSET_LIFECYCLES
        .iter()
        .map(|lifecycle| lifecycle.command)
        .collect();
    assert_eq!(
        asset_commands,
        HashSet::from(["/agent", "/mcp", "/skill", "/okf", "/flow"])
    );

    for command in asset_commands {
        let menu_desc = SLASH_COMMANDS
            .iter()
            .find_map(|(cmd, desc)| (*cmd == command).then_some(*desc))
            .unwrap_or_else(|| panic!("{command} should be registered in the slash menu"));
        let services: HashSet<&str> = asset_lifecycle::ASSET_LIFECYCLES
            .iter()
            .filter(|lifecycle| lifecycle.command == command)
            .map(|lifecycle| asset_lifecycle::service_label(lifecycle.service))
            .collect();

        for service in services {
            assert!(
                menu_desc.contains(service),
                "{command} slash-menu copy should name {service}: {menu_desc}"
            );
        }
        assert!(
                !menu_desc.contains("lifecycle"),
                "{command} slash-menu copy should name concrete OS services, not generic lifecycle wording: {menu_desc}"
            );
    }
}

#[test]
fn cancel_pending_picker_clears_panel_and_deferred_asset_command() {
    let mut picker = Some("agent selector");
    let mut pending = Some("review");

    cancel_pending_picker(&mut picker, &mut pending);

    assert!(picker.is_none());
    assert!(pending.is_none());
}

#[test]
fn registered_slash_commands_have_declared_handler_paths() {
    let parameterized = HashSet::from([
        "/login",
        "/island",
        "/ctx",
        "/kb",
        "/okf",
        "/goal",
        "/loop",
        "/sleep",
        "/flow",
        "/agent",
        "/mcp",
        "/skill",
        "/research",
        "/fork",
        "/use",
        "/copy",
        "/export",
    ]);
    let exact = HashSet::from([
        "/logout",
        "/exit",
        "/rewind",
        "/clear",
        "/init",
        "/compact",
        "/help",
        "/auto",
        "/config",
        "/terminal",
        "/checkup",
        "/queue",
        "/history",
        "/tasks",
        "/permissions",
        "/model",
        "/effort",
        "/ide",
        "/plugin",
        "/theme",
        "/reload",
        "/update",
        "/memory",
        "/evolution",
        "/relay",
        "/permissions",
        "/tasks",
        "/history",
        "/checkup",
    ]);

    for (cmd, _) in SLASH_COMMANDS {
        assert!(
            parameterized.contains(cmd) || exact.contains(cmd),
            "{cmd} is registered but not mapped to a handler category"
        );
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum SlashHandlerKind {
    Exact,
    Parameterized,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum SlashRuntimeScope {
    Local,
    OsAccount,
    RuntimeConditional,
}

#[derive(Clone, Copy, Debug)]
struct SlashAuditRow {
    command: &'static str,
    handler: SlashHandlerKind,
    idle_only: bool,
    scope: SlashRuntimeScope,
}

fn slash_audit_rows() -> Vec<SlashAuditRow> {
    use SlashHandlerKind::{Exact, Parameterized};
    use SlashRuntimeScope::{Local, OsAccount, RuntimeConditional};

    vec![
        SlashAuditRow {
            command: "/model",
            handler: Exact,
            idle_only: true,
            scope: OsAccount,
        },
        SlashAuditRow {
            command: "/init",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/config",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/terminal",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/checkup",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/queue",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/history",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/copy",
            handler: Parameterized,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/export",
            handler: Parameterized,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/tasks",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/permissions",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/use",
            handler: Parameterized,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/theme",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/island",
            handler: Parameterized,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/flow",
            handler: Parameterized,
            idle_only: true,
            scope: OsAccount,
        },
        SlashAuditRow {
            command: "/agent",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/mcp",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/skill",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/okf",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/login",
            handler: Parameterized,
            idle_only: false,
            scope: OsAccount,
        },
        SlashAuditRow {
            command: "/logout",
            handler: Exact,
            idle_only: false,
            scope: OsAccount,
        },
        SlashAuditRow {
            command: "/plugin",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/reload",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/update",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/ide",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/memory",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/evolution",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/research",
            handler: Parameterized,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/history",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/kb",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/ctx",
            handler: Parameterized,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/effort",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/compact",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/goal",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/loop",
            handler: Parameterized,
            idle_only: true,
            scope: RuntimeConditional,
        },
        SlashAuditRow {
            command: "/sleep",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/relay",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/help",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/fork",
            handler: Parameterized,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/rewind",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/clear",
            handler: Exact,
            idle_only: true,
            scope: Local,
        },
        SlashAuditRow {
            command: "/auto",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
        SlashAuditRow {
            command: "/exit",
            handler: Exact,
            idle_only: false,
            scope: Local,
        },
    ]
}

#[test]
fn slash_command_audit_matrix_matches_registry_and_policies() {
    let rows = slash_audit_rows();
    let registered = SLASH_COMMANDS
        .iter()
        .map(|(cmd, _)| *cmd)
        .collect::<HashSet<_>>();
    let audited = rows.iter().map(|row| row.command).collect::<HashSet<_>>();

    assert_eq!(
        registered, audited,
        "every registered command must have explicit audit metadata"
    );

    let idle_from_rows = rows
        .iter()
        .filter(|row| row.idle_only)
        .map(|row| row.command)
        .collect::<HashSet<_>>();
    let idle_from_const = IDLE_ONLY.iter().copied().collect::<HashSet<_>>();
    assert_eq!(
        idle_from_rows, idle_from_const,
        "idle-only policy should stay in sync with the audit matrix"
    );

    let parameterized_names = HashSet::from([
        "/login",
        "/island",
        "/ctx",
        "/kb",
        "/okf",
        "/goal",
        "/loop",
        "/sleep",
        "/flow",
        "/agent",
        "/mcp",
        "/skill",
        "/research",
        "/fork",
        "/use",
        "/copy",
        "/export",
    ]);
    for row in &rows {
        match row.handler {
            SlashHandlerKind::Parameterized => {
                assert!(
                    parameterized_names.contains(row.command),
                    "{} should be in the token-boundary handler set",
                    row.command
                );
                assert!(
                    slash_tail(row.command, row.command).is_some(),
                    "{} should be token-boundary parsed",
                    row.command
                );
            }
            SlashHandlerKind::Exact => {
                assert!(
                    !parameterized_names.contains(row.command),
                    "{} exact command should not be in the token-boundary handler set",
                    row.command
                );
            }
        }
    }

    let loop_row = rows.iter().find(|row| row.command == "/loop").unwrap();
    assert_eq!(loop_row.scope, SlashRuntimeScope::RuntimeConditional);
    for cmd in ["/agent", "/mcp", "/skill", "/okf", "/kb", "/ctx"] {
        let row = rows.iter().find(|row| row.command == cmd).unwrap();
        assert_eq!(row.scope, SlashRuntimeScope::Local);
    }
}

#[test]
fn permissions_is_non_idle_and_listed() {
    assert!(!IDLE_ONLY.contains(&"/permissions"));
    assert!(SLASH_COMMANDS
        .iter()
        .any(|(name, _)| *name == "/permissions"));
}

#[test]
fn removed_top_level_aliases_stay_unregistered() {
    let removed = [
        "/output".to_string(),
        "/top".to_string(),
        "/btw".to_string(),
        "/view".to_string(),
        "/mouse".to_string(),
        "/plugins".to_string(),
        "/quit".to_string(),
        format!("/{}{}", "re", "po"),
    ];
    for alias in removed {
        assert!(
            !SLASH_COMMANDS.iter().any(|(cmd, _)| *cmd == alias.as_str()),
            "{alias} should stay removed from the slash registry"
        );
    }
}

#[test]
fn ampersand_clone_review_syntax_stays_removed() {
    assert!(
        slash_candidates("&").is_empty(),
        "asset clone shortcuts must not return to the slash menu"
    );
    assert!(
        !SLASH_COMMANDS.iter().any(|(cmd, _)| cmd.starts_with('&')),
        "asset clone/review flows must stay under typed asset subcommands"
    );
}

#[test]
fn reload_is_idle_only_because_it_rebuilds_the_session() {
    assert!(IDLE_ONLY.contains(&"/reload"));
}

#[test]
fn fork_is_idle_only_and_listed() {
    // /fork swaps the active session, so it must not run mid-stream…
    assert!(IDLE_ONLY.contains(&"/fork"));
    // …and it's offered in the slash menu.
    assert!(SLASH_COMMANDS.iter().any(|(name, _)| *name == "/fork"));
}

#[test]
fn rewind_is_idle_only_and_listed() {
    assert!(IDLE_ONLY.contains(&"/rewind"));
    assert!(SLASH_COMMANDS.iter().any(|(name, _)| *name == "/rewind"));
}

#[test]
fn relay_is_idle_only_and_listed() {
    assert!(IDLE_ONLY.contains(&"/relay"));
    assert!(SLASH_COMMANDS.iter().any(|(name, _)| *name == "/relay"));
}

#[test]
fn tasks_is_non_idle_and_listed() {
    assert!(!IDLE_ONLY.contains(&"/tasks"));
    assert!(SLASH_COMMANDS.iter().any(|(name, _)| *name == "/tasks"));
}

#[test]
fn history_is_non_idle_and_listed() {
    assert!(!IDLE_ONLY.contains(&"/history"));
    assert!(SLASH_COMMANDS.iter().any(|(name, _)| *name == "/history"));
}

#[test]
fn asset_workflow_commands_are_idle_only_and_listed() {
    for cmd in ["/flow", "/agent", "/mcp", "/skill", "/okf"] {
        assert!(
            IDLE_ONLY.contains(&cmd),
            "{cmd} must not arm asset workflows while another turn is running"
        );
        assert!(
            SLASH_COMMANDS.iter().any(|(name, _)| *name == cmd),
            "{cmd} should be visible in the slash menu while idle"
        );
    }
}

#[test]
fn asset_lifecycle_slash_matrix_matches_parsers_categories_and_services() {
    struct AssetCommandContract<'a> {
        command: &'a str,
        category: &'a str,
        service_labels: &'a [&'a str],
        runtime_kinds: &'a [&'a str],
        valid_subcommands: &'a [&'a str],
        rejected_subcommands: &'a [&'a str],
    }

    let rows = [
        AssetCommandContract {
            command: "/flow",
            category: "workflow",
            service_labels: &["Workflow as a Service"],
            runtime_kinds: &["a3s-workflow-service"],
            valid_subcommands: &[
                "clone https://github.com/a/asset.git",
                "list stale",
                "review",
                "activity failed runs",
                "publish",
                "run",
                "deploy",
                "open",
                "logs",
                "status",
            ],
            rejected_subcommands: &[
                "ps",
                "debug",
                "workflow",
                "artifact",
                "inspect",
                "dashboard",
            ],
        },
        AssetCommandContract {
            command: "/agent",
            category: "agent",
            service_labels: &["Agent as a Service", "Function as a Service"],
            runtime_kinds: &["a3s-agent-service", "a3s-function-service"],
            valid_subcommands: &[
                "clone https://github.com/a/asset.git",
                "list stale",
                "review",
                "activity failed runs",
                "publish agentic",
                "publish application",
                "publish tool",
                "run",
                "deploy",
                "open",
                "logs",
                "status",
            ],
            rejected_subcommands: &["ps", "debug", "jobs", "inspect", "dashboard"],
        },
        AssetCommandContract {
            command: "/mcp",
            category: "mcp",
            service_labels: &["Function as a Service"],
            runtime_kinds: &["a3s-function-service"],
            valid_subcommands: &[
                "clone https://github.com/a/asset.git",
                "list stale",
                "review",
                "activity failed invocations",
                "publish",
                "run",
                "test",
                "deploy",
                "open",
                "logs",
                "status",
            ],
            rejected_subcommands: &[
                "ps",
                "debug",
                "invoke",
                "batch",
                "inspect",
                "jobs",
                "dashboard",
            ],
        },
        AssetCommandContract {
            command: "/skill",
            category: "skill",
            service_labels: &["Function as a Service"],
            runtime_kinds: &["a3s-function-service"],
            valid_subcommands: &[
                "clone https://github.com/a/asset.git",
                "list stale",
                "review",
                "activity failed invocations",
                "publish",
                "deploy",
                "open",
                "status",
            ],
            rejected_subcommands: &["ps", "run", "debug", "logs", "jobs", "inspect", "dashboard"],
        },
        AssetCommandContract {
            command: "/okf",
            category: "knowledge",
            service_labels: &["Knowledge service"],
            runtime_kinds: &["a3s-knowledge-service"],
            valid_subcommands: &[
                "clone https://github.com/a/asset.git",
                "list stale",
                "review",
                "activity stale indexes",
                "publish",
                "deploy",
                "status",
            ],
            rejected_subcommands: &[
                "ps",
                "run",
                "debug",
                "logs",
                "open",
                "view",
                "remote",
                "inspect",
                "dashboard",
                "add",
                "import",
                "search",
                "vault",
            ],
        },
    ];

    for row in rows {
        let lifecycles = asset_lifecycle::ASSET_LIFECYCLES
            .iter()
            .filter(|lifecycle| lifecycle.command == row.command)
            .collect::<Vec<_>>();
        assert!(!lifecycles.is_empty(), "{} has lifecycle rows", row.command);
        assert!(
            lifecycles
                .iter()
                .all(|lifecycle| lifecycle.os_category == row.category),
            "{} should map only to OS category `{}`",
            row.command,
            row.category
        );

        let actual_services = lifecycles
            .iter()
            .map(|lifecycle| asset_lifecycle::service_label(lifecycle.service))
            .collect::<HashSet<_>>();
        let expected_services = row.service_labels.iter().copied().collect::<HashSet<_>>();
        assert_eq!(
            actual_services, expected_services,
            "{} services",
            row.command
        );

        let actual_runtime_kinds = lifecycles
            .iter()
            .map(|lifecycle| lifecycle.runtime_binding.runtime_kind)
            .collect::<HashSet<_>>();
        let expected_runtime_kinds = row.runtime_kinds.iter().copied().collect::<HashSet<_>>();
        assert_eq!(
            actual_runtime_kinds, expected_runtime_kinds,
            "{} runtime bindings",
            row.command
        );

        assert!(
            !lifecycles
                .iter()
                .any(|lifecycle| lifecycle.os_category == "chat"),
            "{} must not use the removed chat category",
            row.command
        );
        assert_eq!(
            os_asset_category_query(row.category, "stale"),
            format!("category:{} stale", row.category),
            "{} list query",
            row.command
        );
        assert_eq!(
            runtime_asset_query(row.category, "asset-name", "failed"),
            format!("category:{} asset-name failed", row.category),
            "{} activity query",
            row.command
        );

        for input in row.valid_subcommands {
            assert!(
                asset_subcommand_is_valid(row.command, input),
                "{} should accept `{}`",
                row.command,
                input
            );
        }
        for input in row.rejected_subcommands {
            assert!(
                asset_subcommand_is_rejected(row.command, input),
                "{} should reject `{}`",
                row.command,
                input
            );
        }
    }

    for command in ["/flow", "/agent", "/mcp", "/skill"] {
        assert!(
            asset_subcommand_is_local_prototype(command, "draft a useful team asset"),
            "{command} should route natural language to local scaffold flow"
        );
    }
    assert!(
        matches!(
            panels::okf::parse_okf_command("draft a useful team knowledge package"),
            panels::okf::OkfCommand::Prototype(_)
        ),
        "/okf natural language should scaffold an OKF package, not become a legacy note"
    );
}

fn asset_subcommand_is_valid(command: &str, input: &str) -> bool {
    match command {
        "/flow" => matches!(panels::flow::parse_flow_subcommand(input), Some(Ok(_))),
        "/agent" => matches!(panels::agent::parse_agent_subcommand(input), Some(Ok(_))),
        "/mcp" => matches!(panels::mcp::parse_mcp_subcommand(input), Some(Ok(_))),
        "/skill" => matches!(panels::skill::parse_skill_subcommand(input), Some(Ok(_))),
        "/okf" => !matches!(
            panels::okf::parse_okf_command(input),
            panels::okf::OkfCommand::Usage(_) | panels::okf::OkfCommand::Prototype(_)
        ),
        other => panic!("unknown asset command {other}"),
    }
}

fn asset_subcommand_is_rejected(command: &str, input: &str) -> bool {
    match command {
        "/flow" => matches!(panels::flow::parse_flow_subcommand(input), Some(Err(_))),
        "/agent" => matches!(panels::agent::parse_agent_subcommand(input), Some(Err(_))),
        "/mcp" => matches!(panels::mcp::parse_mcp_subcommand(input), Some(Err(_))),
        "/skill" => matches!(panels::skill::parse_skill_subcommand(input), Some(Err(_))),
        "/okf" => matches!(
            panels::okf::parse_okf_command(input),
            panels::okf::OkfCommand::Usage(_)
        ),
        other => panic!("unknown asset command {other}"),
    }
}

fn asset_subcommand_is_local_prototype(command: &str, input: &str) -> bool {
    match command {
        "/flow" => panels::flow::parse_flow_subcommand(input).is_none(),
        "/agent" => panels::agent::parse_agent_subcommand(input).is_none(),
        "/mcp" => panels::mcp::parse_mcp_subcommand(input).is_none(),
        "/skill" => panels::skill::parse_skill_subcommand(input).is_none(),
        other => panic!("unknown local prototype asset command {other}"),
    }
}

#[test]
fn runtime_activity_are_asset_scoped_not_top_level() {
    let top_level_ps = format!("/{}", "ps");
    assert!(
        !SLASH_COMMANDS
            .iter()
            .any(|(name, _)| *name == top_level_ps.as_str()),
        "runtime activity browsing should stay asset-scoped"
    );
    assert!(matches!(
        panels::agent::parse_agent_subcommand("activity")
            .unwrap()
            .unwrap(),
        panels::agent::AgentSubcommand::Activity(_)
    ));
    assert!(panels::agent::parse_agent_subcommand("ps")
        .unwrap()
        .is_err());
    assert!(matches!(
        panels::mcp::parse_mcp_subcommand("activity")
            .unwrap()
            .unwrap(),
        panels::mcp::McpSubcommand::Activity(_)
    ));
    assert!(panels::mcp::parse_mcp_subcommand("ps").unwrap().is_err());
    assert!(matches!(
        panels::flow::parse_flow_subcommand("activity")
            .unwrap()
            .unwrap(),
        panels::flow::FlowSubcommand::Activity(_)
    ));
    assert!(panels::flow::parse_flow_subcommand("ps").unwrap().is_err());
    assert!(matches!(
        panels::skill::parse_skill_subcommand("activity")
            .unwrap()
            .unwrap(),
        panels::skill::SkillSubcommand::Activity(_)
    ));
    assert!(panels::skill::parse_skill_subcommand("ps")
        .unwrap()
        .is_err());
    assert!(matches!(
        panels::okf::parse_okf_command("activity"),
        panels::okf::OkfCommand::Activity(_)
    ));
    assert!(matches!(
        panels::okf::parse_okf_command("ps"),
        panels::okf::OkfCommand::Usage(_)
    ));
}

#[test]
fn runtime_expectation_warns_once_until_evidence_arrives() {
    let mut missing = RuntimeExpectation::required("deep research");
    let warning = missing.missing_warning().unwrap();
    assert!(warning.contains("Runtime evidence missing"), "{warning}");
    assert!(missing.missing_warning().is_none());

    let mut via_runtime = RuntimeExpectation::required("run");
    via_runtime.record_tool("runtime");
    assert!(via_runtime.is_satisfied());
    assert!(via_runtime.missing_warning().is_none());

    let mut via_parallel = RuntimeExpectation::required("review");
    via_parallel.record_tool("parallel_task");
    assert!(via_parallel.is_satisfied());

    let mut via_dynamic_workflow = RuntimeExpectation::required("research");
    via_dynamic_workflow.record_tool("dynamic_workflow");
    assert!(via_dynamic_workflow.is_satisfied());

    let mut via_view = RuntimeExpectation::required("deploy");
    via_view.record_remote_view();
    assert!(via_view.is_satisfied());

    let mut report_only_runtime = RuntimeExpectation::required_report_view("deep research");
    report_only_runtime.record_tool("runtime");
    assert!(!report_only_runtime.is_satisfied());
    let warning = report_only_runtime.missing_warning().unwrap();
    assert!(warning.contains("report"), "{warning}");
    assert!(warning.contains(".view"), "{warning}");
    let correction = report_only_runtime.corrective_prompt().unwrap();
    assert!(correction.contains("deep research"), "{correction}");
    assert!(correction.contains("dynamic_workflow"), "{correction}");
    assert!(correction.contains("OS Runtime"), "{correction}");
    assert!(correction.contains(".view"), "{correction}");
    assert!(correction.contains("viewUrl"), "{correction}");

    let mut report_only_view = RuntimeExpectation::required_report_view("loop daily-triage");
    report_only_view.record_remote_view();
    assert!(!report_only_view.is_satisfied());
    let warning = report_only_view.missing_warning().unwrap();
    assert!(warning.contains("fan-out"), "{warning}");
    let correction = report_only_view.corrective_prompt().unwrap();
    assert!(correction.contains("fan-out"), "{correction}");

    let mut full_report = RuntimeExpectation::required_report_view("deep research");
    full_report.record_tool("dynamic_workflow");
    full_report.record_remote_view();
    assert!(full_report.is_satisfied());
    assert!(full_report.missing_warning().is_none());
    assert!(full_report.corrective_prompt().is_none());
}

#[test]
fn remote_view_detection_only_marks_new_specs() {
    let spec = remote_ui::ViewSpec {
        url: "https://os.example.com/admin/runtime/jobs/1?embed=1".into(),
        width: Some(1200),
        height: Some(800),
        embeddable: true,
    };

    assert!(is_new_remote_view(None, &spec));
    assert!(!is_new_remote_view(Some(&spec), &spec));
}

#[test]
fn os_required_message_distinguishes_missing_config_from_missing_login() {
    let configured = os_required_message("/agent run", true);
    assert!(configured.contains("/login"));
    assert!(!configured.contains("configure `os"));

    let missing = os_required_message("/agent deploy", false);
    assert!(missing.contains("configure `os"));
    assert!(missing.contains("/login"));
}

#[test]
fn os_required_alert_uses_shared_warning_line() {
    let rendered = os_required_alert("/agent run", true);

    assert_eq!(
        a3s_tui::style::strip_ansi(&rendered),
        "  ⚠ /agent run needs OS — sign in with /login first"
    );
    assert!(rendered.contains(&format!("\x1b[{}m", TN_YELLOW.fg_ansi())));
}

#[test]
fn ide_flash_line_uses_shared_toast_component() {
    let rendered = ide_flash_line(ToastKind::Warning, "read-only");

    assert_eq!(a3s_tui::style::strip_ansi(&rendered), "⚠ read-only");
    assert!(rendered.contains(&format!("\x1b[{}m", TN_YELLOW.fg_ansi())));
}

// ---- image preview (/ide + paste) ----

#[test]
fn image_path_detection() {
    assert!(is_image_path(std::path::Path::new("a.PNG")));
    assert!(is_image_path(std::path::Path::new("x/y.jpeg")));
    assert!(!is_image_path(std::path::Path::new("main.rs")));
    assert!(!is_image_path(std::path::Path::new("noext")));
}

#[test]
fn half_block_render_packs_two_rows_and_colors() {
    // 6px tall image -> 3 half-block rows; each row is colored ▀ cells.
    let img = ::image::DynamicImage::ImageRgba8(::image::RgbaImage::from_pixel(
        4,
        6,
        ::image::Rgba([10, 20, 30, 255]),
    ));
    let lines = render_image_blocks(&img, 80, 40);
    assert_eq!(lines.len(), 3, "6px / 2 = 3 rows");
    assert!(lines[0].contains('▀'), "uses upper half-block");
    assert!(lines[0].contains("\x1b["), "carries ANSI color");
}

#[test]
fn half_block_render_fits_within_bounds() {
    let img = ::image::DynamicImage::ImageRgba8(::image::RgbaImage::new(400, 400));
    let lines = render_image_blocks(&img, 20, 10);
    assert!(lines.len() <= 10, "never exceeds max_rows");
}

#[test]
fn clipboard_helper_never_leaves_stale_or_empty_bytes() {
    // Clipboard contents are host-dependent. Regardless of success, an old
    // destination must never survive as if it were the newly pasted image.
    let dir = tempfile::tempdir().unwrap();
    let dest = dir.path().join("clipboard.png");
    std::fs::write(&dest, b"stale image bytes").unwrap();
    let ok = clipboard_image_to(&dest);
    if !ok {
        assert!(!dest.exists(), "failed paste leaves no file");
    } else {
        let bytes = std::fs::read(&dest).unwrap();
        assert!(!bytes.is_empty());
        assert_ne!(bytes, b"stale image bytes");
    }
}

// ---- /ide editor cursor math (multi-byte safe) ----

#[test]
fn char_byte_handles_ascii_and_wide_unicode() {
    assert_eq!(char_byte("hello", 0), 0);
    assert_eq!(char_byte("hello", 3), 3);
    assert_eq!(char_byte("hello", 5), 5); // past end clamps to len
                                          // These wide chars are 3 bytes each in UTF-8; cursor index 1 -> byte 3.
    assert_eq!(char_byte("あい", 1), 3);
    assert_eq!(char_byte("あい", 2), 6);
}

#[test]
fn char_byte_supports_inplace_edits() {
    // Mirrors the /ide insert path: insert a wide char mid-string by char idx.
    let mut s = String::from("ab");
    let b = char_byte(&s, 1);
    s.insert(b, 'あ');
    assert_eq!(s, "aあb");
}

// ---- config + skills ----

#[test]
fn starter_config_template_parses() {
    // First-launch generates this — it must be valid ACL with a usable model.
    let p = std::env::temp_dir().join("a3s-template-test.acl");
    std::fs::write(&p, config_template()).unwrap();
    let cfg = a3s_code_core::config::CodeConfig::from_file(&p)
        .expect("starter template must parse as valid ACL");
    let models: Vec<_> = cfg.list_models().into_iter().collect();
    assert!(!models.is_empty(), "template defines at least one model");
    let _ = std::fs::remove_file(&p);
}

#[test]
fn counts_skill_dirs_and_flat_md() {
    let base = std::env::temp_dir().join("a3s-skillcount-test");
    let _ = std::fs::remove_dir_all(&base);
    std::fs::create_dir_all(base.join("myskill")).unwrap();
    std::fs::write(base.join("myskill/SKILL.md"), "# skill").unwrap();
    std::fs::write(base.join("flat.md"), "# flat skill").unwrap();
    std::fs::write(base.join("notes.txt"), "ignored").unwrap();
    assert_eq!(count_skill_files(std::slice::from_ref(&base)), 2);
    let _ = std::fs::remove_dir_all(&base);
}