"""Project execution observation adapter for PMFlow AI.

This module converts PMFlow OS truth/execution projections into customer-safe
evidence facts. It is intentionally read-only and does not decide the final
answer shape.
"""

from __future__ import annotations

from dataclasses import dataclass
from typing import Any

from ..schemas.project_operating_evidence import (
    ProjectOperatingEvidenceFacet,
    ProjectOperatingEvidencePacket,
    ProjectOperatingEvidenceRef,
    ProjectOperatingSuggestedAction,
)
from ..schemas.pmflow_ai_turn_runtime import PMFlowAIEvidenceFinding


@dataclass(frozen=True)
class ProjectOperatingEvidenceReaderInput:
    project_id: int
    project_title: str
    project_status: str
    project_stage: str
    loop_stage: str
    truth: dict[str, Any]
    execution_summary: dict[str, Any]
    project: dict[str, Any]
    execution: dict[str, Any]
    acceptance: dict[str, Any]
    release_gate: dict[str, Any]
    quality_contract: dict[str, Any]
    quality_summary: dict[str, Any]
    task_counts: dict[str, Any]
    active_tasks: list[dict[str, Any]]
    current_task: dict[str, Any]
    evidence_ref: ProjectOperatingEvidenceRef


def build_project_operating_evidence_packet(
    *,
    project_id: int,
    title: str,
    status: str,
    truth_payload: dict[str, Any] | None,
    execution_payload: dict[str, Any] | None,
    fallback_task_counts: dict[str, Any] | None,
    object_binding: dict[str, Any] | None = None,
) -> ProjectOperatingEvidencePacket:
    """Build a structured read-only operating packet for one project."""

    truth = _dict(truth_payload)
    execution_summary = _dict(execution_payload)
    project = _dict(truth.get("project"))
    execution = _dict(execution_summary.get("execution"))
    acceptance = _dict(execution_summary.get("acceptance"))
    release_gate = _dict(execution_summary.get("releaseGate"))
    quality_contract = _dict(execution_summary.get("qualityContract"))
    quality_summary = _dict(quality_contract.get("summary"))
    task_counts = _dict(fallback_task_counts)
    active_tasks = _active_tasks(execution_summary)
    current_task = _current_task(execution=execution, execution_summary=execution_summary)

    project_title = _text(project.get("name") or project.get("title") or title or f"项目 {project_id}", 160)
    project_status = _text(project.get("status") or status, 80)
    project_stage = _text(project.get("stage") or truth.get("stage"), 120)
    loop_stage = _text(truth.get("loopStage"), 120)
    ref = ProjectOperatingEvidenceRef(
        ref_type="project",
        ref_id=f"project:{project_id}",
        display_label=project_title,
        source_surface="PMFlow OS",
    )

    reader_input = ProjectOperatingEvidenceReaderInput(
        project_id=project_id,
        project_title=project_title,
        project_status=project_status,
        project_stage=project_stage,
        loop_stage=loop_stage,
        truth=truth,
        execution_summary=execution_summary,
        project=project,
        execution=execution,
        acceptance=acceptance,
        release_gate=release_gate,
        quality_contract=quality_contract,
        quality_summary=quality_summary,
        task_counts=task_counts,
        active_tasks=active_tasks,
        current_task=current_task,
        evidence_ref=ref,
    )

    command_state = _read_command_state(reader_input)
    workbench_state = _read_workbench_state(reader_input)
    decision_review_state = _read_decision_review_state(reader_input)
    execution_state = _read_execution_state(reader_input)
    quality_test_state = _read_quality_test_state(reader_input)
    release_growth_state = _read_release_growth_state(reader_input)
    team_state = _read_team_state(reader_input)
    project_memory_state = _read_project_memory_state(reader_input)
    risk_blocker_state = _read_risk_blocker_state(reader_input)
    recent_timeline_state = _read_recent_timeline_state(reader_input)

    next_actions = _unique_texts(list(release_gate.get("nextActions") or []), limit=6)
    blockers = _project_blockers(acceptance=acceptance, release_gate=release_gate, quality_contract=quality_contract)
    safe_actions = [
        ProjectOperatingSuggestedAction(
            action_key=f"prepare_next_action_{index}",
            display_label=action,
            safety="prepare_only",
            reason="来自 PMFlow OS 门禁/执行态的只读建议，执行前仍需要用户确认边界。",
            target_ref=f"project:{project_id}",
        )
        for index, action in enumerate(next_actions[:5], start=1)
    ]
    blocked_actions = [
        ProjectOperatingSuggestedAction(
            action_key=f"blocked_by_evidence_{index}",
            display_label=blocker,
            safety="blocked",
            reason="当前证据显示该阻塞未解除。",
            target_ref=f"project:{project_id}",
        )
        for index, blocker in enumerate(blockers[:5], start=1)
    ]

    return ProjectOperatingEvidencePacket(
        project_id=project_id,
        project_ref=f"project:{project_id}",
        project_title=project_title,
        project_status=project_status,
        object_binding=_dict(object_binding),
        command_state=command_state,
        workbench_state=workbench_state,
        decision_review_state=decision_review_state,
        execution_state=execution_state,
        quality_test_state=quality_test_state,
        release_growth_state=release_growth_state,
        team_state=team_state,
        project_memory_state=project_memory_state,
        risk_blocker_state=risk_blocker_state,
        recent_timeline_state=recent_timeline_state,
        evidence_refs=[ref],
        safe_next_actions=safe_actions,
        blocked_actions=blocked_actions,
    )


def build_project_execution_findings(
    *,
    project_id: int,
    title: str,
    status: str,
    truth_payload: dict[str, Any] | None,
    execution_payload: dict[str, Any] | None,
    fallback_task_counts: dict[str, Any] | None,
    relevance: str,
) -> tuple[list[PMFlowAIEvidenceFinding], list[str]]:
    """Build bounded findings and coverage gaps for one project."""

    truth = _dict(truth_payload)
    execution_summary = _dict(execution_payload)
    project = _dict(truth.get("project"))
    execution = _dict(execution_summary.get("execution"))
    acceptance = _dict(execution_summary.get("acceptance"))
    release_gate = _dict(execution_summary.get("releaseGate"))
    quality_contract = _dict(execution_summary.get("qualityContract"))
    quality_summary = _dict(quality_contract.get("summary"))

    project_title = _text(project.get("name") or project.get("title") or title or f"项目 {project_id}", 160)
    project_status = _text(project.get("status") or status, 80)
    project_stage = _text(project.get("stage") or truth.get("stage"), 120)
    loop_stage = _text(truth.get("loopStage"), 120)

    findings: list[PMFlowAIEvidenceFinding] = []
    gaps: list[str] = []

    overview_parts = [project_title]
    if project_stage:
        overview_parts.append(f"阶段：{project_stage}")
    if project_status:
        overview_parts.append(f"状态：{project_status}")
    if loop_stage:
        overview_parts.append(f"运行环节：{loop_stage}")
    findings.append(
        _finding(
            fact="项目概况：" + "，".join(overview_parts) + "。",
            implication="用于判断当前推进建议应绑定项目阶段和运行环节，而不是只看项目是否存在。",
            relevance=relevance,
        )
    )
    if not project_stage:
        gaps.append("project_stage_missing")

    current_task = _current_task(execution=execution, execution_summary=execution_summary)
    if current_task:
        task_title = _text(current_task.get("title"), 220)
        task_status = _text(current_task.get("status"), 80)
        execution_status = _text(execution.get("status"), 80)
        task_id = _text(current_task.get("id") or execution.get("taskId"), 80)
        parts = [task_title or f"任务 {task_id}" if task_id else "当前任务"]
        if task_id:
            parts.append(f"任务ID：{task_id}")
        if task_status:
            parts.append(f"任务状态：{task_status}")
        if execution_status:
            parts.append(f"执行状态：{execution_status}")
        findings.append(
            _finding(
                fact="当前执行任务：" + "，".join(parts) + "。",
                implication="这是当前推进顺序的第一锚点，优先处理它的完成证据和阻塞。",
                relevance=relevance,
            )
        )
    else:
        gaps.append("current_execution_state_missing")

    acceptance_status = _text(acceptance.get("status"), 100)
    required_action = _text(acceptance.get("requiredAction"), 160)
    if acceptance_status or required_action:
        parts = []
        if acceptance_status:
            parts.append(f"验收状态：{acceptance_status}")
        if required_action:
            parts.append(f"下一步要求：{required_action}")
        findings.append(
            _finding(
                fact="执行验收：" + "，".join(parts) + "。",
                implication="用于判断当前推进是否应先补验收材料、测试证据或人工确认。",
                relevance=relevance,
            )
        )

    gate_status = _text(release_gate.get("status"), 100)
    gate_title = _text(release_gate.get("title"), 120)
    gate_summary = _text(release_gate.get("summary"), 260)
    if gate_status or gate_title or gate_summary:
        parts = []
        if gate_status:
            parts.append(f"门禁状态：{gate_status}")
        if gate_title:
            parts.append(gate_title)
        if gate_summary:
            parts.append(gate_summary)
        findings.append(
            _finding(
                fact="发布/验收门禁：" + "，".join(parts) + "。",
                implication="门禁状态决定当前能否继续发布、交付或进入下一轮开发。",
                relevance=relevance,
            )
        )

    blockers = _project_blockers(acceptance=acceptance, release_gate=release_gate, quality_contract=quality_contract)
    if blockers:
        findings.append(
            _finding(
                fact="阻塞项：" + "；".join(blockers[:6]) + "。",
                implication="推进建议应优先消除这些阻塞，而不是继续泛化规划。",
                relevance=relevance,
            )
        )
    else:
        gaps.append("project_blockers_or_release_gate_missing")

    active_tasks = _active_tasks(execution_summary)
    if active_tasks:
        task_summaries = []
        for item in active_tasks[:8]:
            task_title = _text(item.get("title"), 180)
            if not task_title:
                continue
            task_status = _text(item.get("status"), 60)
            task_summaries.append(f"{task_title}{f'（{task_status}）' if task_status else ''}")
        if task_summaries:
            findings.append(
                _finding(
                    fact=f"候选任务：当前有 {len(active_tasks)} 个执行/待执行任务，" + "；".join(task_summaries[:5]) + "。",
                    implication="这些任务构成可排序的推进队列，可用于给出下一步行动顺序。",
                    relevance=relevance,
                )
            )
    else:
        task_counts = _dict(fallback_task_counts)
        count_summary = _task_count_summary(task_counts)
        if count_summary:
            findings.append(
                _finding(
                    fact="候选任务：" + count_summary + "。",
                    implication="当前只拿到任务数量，缺少任务标题和阻塞细节。",
                    relevance=relevance,
                    confidence="medium",
                )
            )
        else:
            gaps.append("active_or_next_tasks_missing")

    next_actions = _unique_texts(list(release_gate.get("nextActions") or []), limit=5)
    if next_actions:
        findings.append(
            _finding(
                fact="系统建议下一步：" + "；".join(next_actions[:4]) + "。",
                implication="这是 PMFlow OS 根据门禁与证据链给出的直接推进动作。",
                relevance=relevance,
            )
        )

    memory_summary = _memory_summary(truth)
    if memory_summary:
        findings.append(
            _finding(
                fact="项目记忆：" + memory_summary,
                implication="项目记忆用于区分已确认事实和仍待审的想法，避免重复规划。",
                relevance=relevance,
                confidence="medium",
            )
        )

    quality_missing = _safe_int(quality_summary.get("releaseBlockingMissing"))
    if quality_missing:
        findings.append(
            _finding(
                fact=f"质量合同：还有 {quality_missing} 个发布阻塞级证据未完成。",
                implication="当前推进应先补齐发布阻塞级证据，再讨论发布或扩大范围。",
                relevance=relevance,
            )
        )

    if not execution_summary:
        gaps.append("project_execution_projection_missing")
    return findings[:10], _unique_texts(gaps, limit=8)


def _facet(
    *,
    key: str,
    label: str,
    facts: list[str],
    summary: str,
    evidence_refs: list[ProjectOperatingEvidenceRef],
    missing: list[str],
    partial: bool = False,
) -> ProjectOperatingEvidenceFacet:
    clean_facts = _unique_texts(facts, limit=12)
    coverage = "covered" if clean_facts and not partial and not missing else "partial" if clean_facts else "missing"
    return ProjectOperatingEvidenceFacet(
        facet_key=key,
        display_label=label,
        coverage_status=coverage,
        summary=_text(summary or "；".join(clean_facts[:4]), 500),
        facts=clean_facts,
        evidence_refs=evidence_refs,
        remaining_gaps=[] if coverage == "covered" else missing,
    )


def _read_command_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    facts = _unique_texts(
        [
            f"项目：{data.project_title}" if data.project_title else "",
            f"阶段：{data.project_stage}" if data.project_stage else "",
            f"状态：{data.project_status}" if data.project_status else "",
            f"运行环节：{data.loop_stage}" if data.loop_stage else "",
            f"最后写入：{_text(data.truth.get('lastWritebackAt'), 120)}" if data.truth.get("lastWritebackAt") else "",
        ],
        limit=8,
    )
    return _facet(
        key="command_state",
        label="指挥台",
        facts=facts,
        summary="，".join(facts),
        evidence_refs=[data.evidence_ref],
        missing=["project_stage_missing"] if not data.project_stage else [],
    )


def _read_workbench_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    task_facts = _task_facts(data)
    requirements = _model_rows(data.truth.get("requirements"))
    risks = _model_rows(data.truth.get("risks"))
    facts = [
        *task_facts,
        f"需求 {len(requirements)} 个" if requirements else "",
        f"风险 {len(risks)} 个" if risks else "",
    ]
    return _facet(
        key="workbench_state",
        label="项目工作台",
        facts=_unique_texts(facts, limit=12),
        summary="；".join(_unique_texts(facts, limit=5)),
        evidence_refs=[data.evidence_ref],
        missing=[] if _unique_texts(facts, limit=12) else ["active_or_next_tasks_missing"],
        partial=bool(task_facts and not data.active_tasks),
    )


def _read_decision_review_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    reviewer_routing = _dict(data.truth.get("reviewerRouting"))
    routing_summary = _dict(reviewer_routing.get("summary"))
    change_sets = _list(data.truth.get("changeSets"))
    change_items = _list(data.truth.get("changeItems"))
    approvals = _list(data.truth.get("approvals"))
    routing_items = _list(reviewer_routing.get("items"))
    facts = _unique_texts(
        [
            f"待审变更集 {len(change_sets)} 个" if change_sets else "",
            f"待审变更项 {len(change_items)} 个" if change_items else "",
            f"审批记录 {len(approvals)} 条" if approvals else "",
            f"待审路由 {len(routing_items)} 条" if routing_items else "",
            f"待审数：{routing_summary.get('totalPendingReview')}" if routing_summary.get("totalPendingReview") is not None else "",
            f"高风险待审：{routing_summary.get('highRiskCount')}" if routing_summary.get("highRiskCount") else "",
            f"验收状态：{_text(data.acceptance.get('status'), 100)}" if data.acceptance.get("status") else "",
            f"下一步要求：{_text(data.acceptance.get('requiredAction'), 160)}" if data.acceptance.get("requiredAction") else "",
        ],
        limit=12,
    )
    return _facet(
        key="decision_review_state",
        label="决策与待确认",
        facts=facts,
        summary="；".join(facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if facts else ["decision_review_state_missing"],
    )


def _read_execution_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    prompt_package = _dict(data.execution_summary.get("promptPackage"))
    repo_bindings = _list(data.execution_summary.get("repoBindings"))
    recent_events = _list(data.execution_summary.get("recentProgressEvents"))
    recent_deliveries = _list(data.execution_summary.get("recentDeliveries"))
    facts = _unique_texts(
        [
            f"执行状态：{_text(data.execution.get('status'), 100)}" if data.execution.get("status") else "",
            *_task_facts(data)[:4],
            f"执行包：{_text(prompt_package.get('title') or prompt_package.get('id'), 160)}" if prompt_package else "",
            f"代码仓库绑定 {len(repo_bindings)} 个" if repo_bindings else "",
            f"进展事件 {len(recent_events)} 条" if recent_events else "",
            f"交付记录 {len(recent_deliveries)} 条" if recent_deliveries else "",
        ],
        limit=12,
    )
    return _facet(
        key="execution_state",
        label="开发执行",
        facts=facts,
        summary="；".join(facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if data.current_task or data.execution.get("status") or recent_events else ["current_execution_state_missing"],
    )


def _read_quality_test_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    test_runs = _model_rows(data.truth.get("testRuns"))
    delivery_artifacts = _dict(data.execution_summary.get("deliveryArtifacts"))
    artifact_review = _dict(data.execution_summary.get("artifactReview"))
    artifact_completeness = _dict(data.execution_summary.get("artifactCompleteness"))
    test_outputs = _list(delivery_artifacts.get("test_outputs") or delivery_artifacts.get("testOutputs"))
    review_items = _list(artifact_review.get("items") or artifact_review.get("reviewItems"))
    quality_blockers = _unique_texts(list(data.quality_contract.get("blockingReasons") or []), limit=6)
    quality_missing = _safe_int(data.quality_summary.get("releaseBlockingMissing"))
    facts = _unique_texts(
        [
            f"发布阻塞级证据未完成 {quality_missing} 个" if quality_missing else "",
            f"测试记录 {len(test_runs)} 条" if test_runs else "",
            f"测试输出 {len(test_outputs)} 条" if test_outputs else "",
            f"交付审查项 {len(review_items)} 个" if review_items else "",
            f"证据完整度：{_text(artifact_completeness.get('status'), 100)}" if artifact_completeness.get("status") else "",
            *_quality_review_facts(review_items),
            *quality_blockers,
        ],
        limit=12,
    )
    return _facet(
        key="quality_test_state",
        label="测试与质量",
        facts=facts,
        summary="；".join(facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if data.quality_contract or test_runs or test_outputs or artifact_review else ["quality_test_state_missing"],
        partial=bool((data.quality_contract or artifact_review) and not facts),
    )


def _read_release_growth_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    releases = _model_rows(data.truth.get("releases"))
    metric_signals = _model_rows(data.truth.get("metricSignals"))
    release_signals = _dict(data.execution_summary.get("releaseSignals"))
    next_actions = _unique_texts(list(data.release_gate.get("nextActions") or []), limit=6)
    feedback = _list(release_signals.get("feedback") or release_signals.get("feedbackIngests"))
    recommendations = _list(release_signals.get("recommendations") or release_signals.get("iterationRecommendations"))
    facts = _unique_texts(
        [
            f"门禁状态：{_text(data.release_gate.get('status'), 100)}" if data.release_gate.get("status") else "",
            _text(data.release_gate.get("title"), 120),
            _text(data.release_gate.get("summary"), 260),
            f"发布记录 {len(releases)} 条" if releases else "",
            f"增长信号 {len(metric_signals)} 条" if metric_signals else "",
            f"反馈输入 {len(feedback)} 条" if feedback else "",
            f"迭代建议 {len(recommendations)} 条" if recommendations else "",
            *[f"建议动作：{item}" for item in next_actions],
        ],
        limit=12,
    )
    return _facet(
        key="release_growth_state",
        label="发布与增长",
        facts=facts,
        summary="；".join(facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if data.release_gate or releases or metric_signals or release_signals else ["release_growth_state_missing"],
        partial=bool((data.release_gate or release_signals) and not facts),
    )


def _read_team_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    reviewer_routing = _dict(data.truth.get("reviewerRouting"))
    routing_summary = _dict(reviewer_routing.get("summary"))
    routing_items = _list(reviewer_routing.get("items"))
    team_inbox = _dict(data.truth.get("teamInbox"))
    inbox_counts = [
        f"{label} {len(rows)}"
        for label, rows in (
            ("产品收件箱", _list(team_inbox.get("product"))),
            ("工程收件箱", _list(team_inbox.get("engineering"))),
            ("测试收件箱", _list(team_inbox.get("qa"))),
            ("增长收件箱", _list(team_inbox.get("growth"))),
        )
        if rows
    ]
    facts = _unique_texts(
        [
            *_team_facts(project=data.project, execution=data.execution, active_tasks=data.active_tasks),
            *inbox_counts,
            f"待审路由 {len(routing_items)} 条" if routing_items else "",
            f"缺审查人 {routing_summary.get('missingReviewerCount')} 项" if routing_summary.get("missingReviewerCount") else "",
            *_reviewer_suggestion_facts(routing_items),
        ],
        limit=12,
    )
    return _facet(
        key="team_state",
        label="团队层",
        facts=facts,
        summary="；".join(facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if facts else ["team_state_missing"],
    )


def _read_project_memory_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    memory = _dict(data.truth.get("projectMemory"))
    source_summary = _dict(memory.get("sourceSummary"))
    memory_summary = _memory_summary(data.truth)
    facts = _unique_texts(
        [
            memory_summary.rstrip("。") if memory_summary else "",
            *[f"{key} {value}" for key, value in source_summary.items() if value],
        ],
        limit=12,
    )
    return _facet(
        key="project_memory_state",
        label="项目记忆",
        facts=facts,
        summary="；".join(facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if facts else ["project_memory_missing"],
    )


def _read_risk_blocker_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    risks = _model_rows(data.truth.get("risks"))
    warnings = _unique_texts(list(data.truth.get("projectionWarnings") or []) + list(data.execution_summary.get("warnings") or []), limit=8)
    blockers = _project_blockers(acceptance=data.acceptance, release_gate=data.release_gate, quality_contract=data.quality_contract)
    artifact_review = _dict(data.execution_summary.get("artifactReview"))
    review_blockers = _unique_texts(list(artifact_review.get("blockingReasons") or []), limit=6)
    risk_facts = _unique_texts(
        [
            *blockers,
            *review_blockers,
            *[f"风险：{_text(item.get('title') or item.get('summary'), 180)}" for item in risks[:5] if isinstance(item, dict)],
            *[f"投影警告：{item}" for item in warnings[:4]],
            "已读取验收/门禁/质量信息，未发现明确阻塞项。" if not blockers and not review_blockers and (data.acceptance or data.release_gate or data.quality_contract) else "",
        ],
        limit=12,
    )
    return _facet(
        key="risk_blocker_state",
        label="风险与阻塞",
        facts=risk_facts,
        summary="；".join(risk_facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if risk_facts else ["project_blockers_or_release_gate_missing"],
        partial=bool(risk_facts and not blockers and not review_blockers),
    )


def _read_recent_timeline_state(data: ProjectOperatingEvidenceReaderInput) -> ProjectOperatingEvidenceFacet:
    facts = _timeline_facts(execution_summary=data.execution_summary, current_task=data.current_task, truth=data.truth)
    return _facet(
        key="recent_timeline_state",
        label="最近动态",
        facts=facts,
        summary="；".join(facts[:5]),
        evidence_refs=[data.evidence_ref],
        missing=[] if facts else ["recent_timeline_missing"],
        partial=bool(not facts and (data.current_task or data.active_tasks)),
    )


def _task_facts(data: ProjectOperatingEvidenceReaderInput) -> list[str]:
    facts: list[str] = []
    if data.current_task:
        task_title = _text(data.current_task.get("title"), 220)
        task_status = _text(data.current_task.get("status"), 80)
        task_id = _text(data.current_task.get("id") or data.execution.get("taskId"), 80)
        facts.append(
            "当前任务：" + "，".join(
                part
                for part in [
                    task_title or (f"任务 {task_id}" if task_id else "当前任务"),
                    f"任务ID：{task_id}" if task_id else "",
                    f"状态：{task_status}" if task_status else "",
                ]
                if part
            )
        )
    if data.active_tasks:
        facts.append(f"执行/待执行任务 {len(data.active_tasks)} 个")
        for item in data.active_tasks[:5]:
            task_title = _text(item.get("title"), 160)
            task_status = _text(item.get("status"), 60)
            if task_title:
                facts.append(f"{task_title}{f'（{task_status}）' if task_status else ''}")
    else:
        count_summary = _task_count_summary(data.task_counts)
        if count_summary:
            facts.append(count_summary)
    return _unique_texts(facts, limit=10)


def _project_blockers(
    *,
    acceptance: dict[str, Any],
    release_gate: dict[str, Any],
    quality_contract: dict[str, Any],
) -> list[str]:
    return _unique_texts(
        [
            *list(acceptance.get("blockingReasons") or []),
            *list(release_gate.get("blockingReasons") or []),
            *list(quality_contract.get("blockingReasons") or []),
        ],
        limit=8,
    )


def _team_facts(
    *,
    project: dict[str, Any],
    execution: dict[str, Any],
    active_tasks: list[dict[str, Any]],
) -> list[str]:
    candidates: list[Any] = [
        project.get("ownerName"),
        project.get("owner"),
        project.get("responsibleUserName"),
        execution.get("assigneeName"),
        execution.get("assignee"),
    ]
    for item in active_tasks[:5]:
        candidates.extend([item.get("assigneeName"), item.get("ownerName"), item.get("reviewerName")])
    facts = [f"负责人/协作者：{value}" for value in _unique_texts(candidates, limit=6)]
    return facts


def _quality_review_facts(review_items: list[Any]) -> list[str]:
    out: list[str] = []
    for item in review_items[:6]:
        if not isinstance(item, dict):
            continue
        title = _text(item.get("title") or item.get("item") or item.get("summary"), 160)
        status = _text(item.get("status"), 80)
        if title:
            out.append(f"交付审查：{title}{f'（{status}）' if status else ''}")
    return _unique_texts(out, limit=6)


def _reviewer_suggestion_facts(rows: list[Any]) -> list[str]:
    out: list[str] = []
    for item in rows[:6]:
        if not isinstance(item, dict):
            continue
        reviewer = _dict(item.get("suggestedReviewer"))
        display_name = _text(reviewer.get("displayName") or reviewer.get("role"), 120)
        reason = _text(item.get("reviewReason") or reviewer.get("reason"), 180)
        if display_name or reason:
            out.append("审查建议：" + "，".join(part for part in [display_name, reason] if part))
    return _unique_texts(out, limit=6)


def _timeline_facts(*, execution_summary: dict[str, Any], current_task: dict[str, Any], truth: dict[str, Any] | None = None) -> list[str]:
    rows: list[Any] = []
    truth_payload = _dict(truth)
    rows.extend(_list(truth_payload.get("feed"))[:6])
    for key in ("recentProgressEvents", "recentDeliveries", "recentEvents", "timeline", "activities", "progressEvents", "events"):
        value = execution_summary.get(key)
        if isinstance(value, list):
            rows.extend(value[:6])
    facts: list[str] = []
    for item in rows[:8]:
        if isinstance(item, dict):
            text = _text(item.get("summary") or item.get("title") or item.get("description") or item.get("message"), 220)
            status = _text(item.get("status"), 80)
            if text:
                facts.append(f"{text}{f'（{status}）' if status else ''}")
        else:
            text = _text(item, 220)
            if text:
                facts.append(text)
    if not facts and current_task:
        title = _text(current_task.get("title"), 160)
        status = _text(current_task.get("status"), 80)
        if title:
            facts.append(f"当前最近可见动态来自正在处理的任务：{title}{f'（{status}）' if status else ''}")
    return _unique_texts(facts, limit=8)


def _model_rows(value: Any) -> list[dict[str, Any]]:
    rows = value if isinstance(value, list) else []
    out: list[dict[str, Any]] = []
    for item in rows:
        if isinstance(item, dict):
            out.append(dict(item))
        elif hasattr(item, "model_dump"):
            out.append(item.model_dump(mode="json"))
    return out


def _list(value: Any) -> list[Any]:
    return list(value) if isinstance(value, list) else []


def _finding(
    *,
    fact: str,
    implication: str,
    relevance: str,
    confidence: str = "high",
) -> PMFlowAIEvidenceFinding:
    return PMFlowAIEvidenceFinding(
        fact=_text(fact, 700),
        source="PMFlow 项目执行态证据",
        implication=_text(implication, 700),
        relevance_to_goal=_text(relevance, 160),
        confidence=confidence if confidence in {"high", "medium", "low", "unknown"} else "unknown",
    )


def _current_task(*, execution: dict[str, Any], execution_summary: dict[str, Any]) -> dict[str, Any]:
    task_id = _text(execution.get("taskId"), 80)
    active_tasks = _active_tasks(execution_summary)
    if task_id:
        for item in active_tasks:
            if _text(item.get("id"), 80) == task_id:
                return item
    if active_tasks:
        return active_tasks[0]
    prompt = _text(execution.get("prompt"), 700)
    title = _extract_prompt_line(prompt, "- Title:")
    status = _extract_prompt_line(prompt, "- Status:")
    if title or task_id:
        return {"id": task_id, "title": title, "status": status}
    return {}


def _active_tasks(execution_summary: dict[str, Any]) -> list[dict[str, Any]]:
    rows = execution_summary.get("activeDevTasks")
    if not isinstance(rows, list):
        return []
    return [dict(item) for item in rows if isinstance(item, dict)]


def _memory_summary(truth: dict[str, Any]) -> str:
    memory = _dict(truth.get("projectMemory"))
    truth_nodes = list(memory.get("truthNodeFacts") or [])
    semantic_facts = list(memory.get("semanticFacts") or [])
    rows: list[str] = []
    for item in truth_nodes[:4]:
        if isinstance(item, dict):
            text = _text(item.get("summary") or item.get("title") or item.get("fact"), 160)
        else:
            text = _text(item, 160)
        if text:
            rows.append(text)
    if not rows:
        for item in semantic_facts[:4]:
            if isinstance(item, dict):
                text = _text(item.get("summary") or item.get("value") or item.get("fact"), 160)
            else:
                text = _text(item, 160)
            if text:
                rows.append(text)
    return "；".join(_unique_texts(rows, limit=4)) + ("。" if rows else "")


def _task_count_summary(task_counts: dict[str, Any]) -> str:
    parts: list[str] = []
    for key, label in (
        ("todo", "待处理"),
        ("pending", "待处理"),
        ("in_progress", "进行中"),
        ("blocked", "阻塞"),
        ("done", "已完成"),
    ):
        value = _safe_int(task_counts.get(key))
        if value:
            parts.append(f"{label} {value}")
    return "任务：" + "、".join(parts[:5]) if parts else ""


def _extract_prompt_line(prompt: str, prefix: str) -> str:
    for line in prompt.splitlines():
        if line.strip().startswith(prefix):
            return _text(line.split(prefix, 1)[-1].strip(), 220)
    return ""


def _dict(value: Any) -> dict[str, Any]:
    return dict(value) if isinstance(value, dict) else {}


def _text(value: Any, limit: int) -> str:
    return str(value or "").strip().replace("\x00", "")[:limit]


def _safe_int(value: Any) -> int:
    try:
        if value is None or value == "":
            return 0
        return int(value)
    except Exception:
        return 0


def _unique_texts(values: list[Any], *, limit: int) -> list[str]:
    out: list[str] = []
    for value in values:
        text = _text(value, 240)
        if text and text not in out:
            out.append(text)
        if len(out) >= limit:
            break
    return out