diff --git a/backend/api/prescreen.py b/backend/api/prescreen.py index 46d1946..0f97d17 100644 --- a/backend/api/prescreen.py +++ b/backend/api/prescreen.py @@ -34,6 +34,7 @@ from api.project_assistant import enabled from api.risk_agent_access import authorize, check_project from contracts.prescreen import ( EVIDENCE_MAX, + ID_MAX, MAX_BATCH_FILES, NOTE_MAX, ErrorCode, @@ -41,7 +42,7 @@ from contracts.prescreen import ( S1_ERROR_RETRYABLE, ) from services import assistant_store as store -from services import fact_conflict, material_import, prescreen_sandbox, prescreen_store +from services import fact_conflict, material_import, prescreen_sandbox, prescreen_store, trajectory from services.assistant_settings import flags from services.fact_conflict import FactConflictUnresolved from services.project_assistant import ProjectAssistantService @@ -91,6 +92,20 @@ class SimulationInput(Input): expected_revision: int | None = Field(default=None, ge=1) +class OutcomeInput(Input): + """T10 会议结果。原始结果码必填；未提供时不得推断成通过或否决。""" + + raw_code: str = Field(min_length=1, max_length=100) + meeting_id: str = Field(min_length=1, max_length=ID_MAX) + normalized: str | None = Field(default=None, max_length=40) + occurred_at: str | None = None + reviewed_snapshot_id: str | None = Field(default=None, max_length=ID_MAX) + supersedes_id: str | None = Field(default=None, max_length=ID_MAX) + mapping_ref: dict | None = None + conditions: list[str] = Field(default_factory=list, max_length=50) + evidence_ids: list[str] = Field(default_factory=list, max_length=EVIDENCE_MAX) + + # ---------------------------------------------------------------- 错误信封 def _envelope(request: Request, code: ErrorCode, message: str) -> JSONResponse: request_id = request.headers.get("x-request-id") or store.uid("req") @@ -452,3 +467,54 @@ def create_simulation(project_id: str, run_id: str, payload: SimulationInput, return result return run(request, action) + + +# ---------------------------------------------------------------- 轨迹与会议结果（T10） +@router.get("/projects/{project_id}/runs/{run_id}/trajectory") +def get_trajectory(project_id: str, run_id: str, request: Request, + cursor: str | None = None, limit: int = 50): + """只读轨迹回放。失败的步骤照常返回，不做美化过滤。""" + blocked = scope(request, project_id) + if blocked is not None: + return blocked + + def action(): + with _db() as db: + return trajectory.replay(db, project_id, run_id, cursor, _limit(limit)) + + return run(request, action) + + +@router.get("/projects/{project_id}/review-outcomes") +def list_review_outcomes(project_id: str, request: Request, status: str | None = None): + """会议结果列表。unmatched 单列，不混进已观察通过率的分母。""" + blocked = scope(request, project_id) + if blocked is not None: + return blocked + if status not in (None, "matched", "unmatched"): + return _envelope(request, ErrorCode.INVALID_REQUEST, + "状态取值须为 matched 或 unmatched") + + def action(): + with _db() as db: + return trajectory.listing(db, project_id, status) + + return run(request, action) + + +@router.post("/projects/{project_id}/review-outcomes", status_code=201) +def record_review_outcome(project_id: str, payload: OutcomeInput, request: Request): + """追加会议结果。找不到材料版本的一律记 unmatched；更正只能新增。""" + blocked = scope(request, project_id) + if blocked is not None: + return blocked + + def action(): + with _db() as db: + runs = store.listing(db, "run", project_id) + snapshots = [item.get("input_snapshot_id") for item in runs + if item.get("input_snapshot_id")] + return trajectory.record(db, project_id, payload.model_dump(), _actor(request), + known_snapshots=snapshots) + + return run(request, action) diff --git a/backend/contracts/trajectory.py b/backend/contracts/trajectory.py new file mode 100644 index 0000000..b5c36f7 --- /dev/null +++ b/backend/contracts/trajectory.py @@ -0,0 +1,112 @@ +"""T10 轨迹与会议结果契约。 + +Owner：本文件（docs/v2/03-detailed-design.md §9.1 的 TrajectoryStep / ReviewOutcome）。 +`contracts/prescreen.py` 头部已明确把这两个对象排除在该文件之外，这里补上。 + +两条不可让渡的规则： +1. **只记录可观察动作**：步骤只保存计划、组件版本、输入输出引用、理由摘要与 + 错误码；**不存在**隐藏思维链字段，也不采集模型内部推理（BR-31 / AC-32）。 +2. **结果追加，不覆盖**：会议结果只能新增并指向 `supersedes_id`，绝不改写既有 + 记录或历史预测（BR-13 / AC-33）。 +""" + +from __future__ import annotations + +from typing import Literal + +from pydantic import Field, model_validator + +from contracts.prescreen import ( + DESC_MAX, + EVIDENCE_MAX, + ID_MAX, + AwareDatetime, + Contract, + EventOutcome, + Ref, +) + +STEP_KINDS = ("plan", "skill", "tool", "rule", "judgment", "synthesis") +STEP_STATUSES = ("queued", "running", "completed", "skipped", "failed", "cancelled") + + +class TrajectoryStep(Contract): + """一次运行里的一个可观察步骤。`failed` 步骤保留而不是被过滤掉。""" + + id: str = Field(min_length=1, max_length=ID_MAX) + run_id: str = Field(min_length=1, max_length=ID_MAX) + parent_step_id: str | None = Field(default=None, max_length=ID_MAX) + sequence: int = Field(ge=0) + kind: Literal["plan", "skill", "tool", "rule", "judgment", "synthesis"] + component_ref: Ref | None = None + input_refs: list[str] = Field(default_factory=list, max_length=EVIDENCE_MAX) + output_refs: list[str] = Field(default_factory=list, max_length=EVIDENCE_MAX) + evidence_ids: list[str] = Field(default_factory=list, max_length=EVIDENCE_MAX) + status: Literal["queued", "running", "completed", "skipped", "failed", "cancelled"] + started_at: AwareDatetime | None = None + finished_at: AwareDatetime | None = None + reason_summary: str | None = Field(default=None, max_length=DESC_MAX) + error_code: str | None = Field(default=None, max_length=ID_MAX) + latency_ms: int | None = Field(default=None, ge=0) + cost: float | None = Field(default=None, ge=0) + cost_currency: str | None = Field(default=None, max_length=16) + + @model_validator(mode="after") + def _check_step(self) -> TrajectoryStep: + if self.status == "failed" and not self.error_code: + raise ValueError("失败的步骤必须带错误码，不能只留一条看不出原因的记录") + if self.cost is None and self.cost_currency is not None: + raise ValueError("成本未知时币种也必须留空，不能只写币种") + if self.parent_step_id == self.id: + raise ValueError("步骤不能以自己为父步骤") + return self + + def observable(self) -> dict: + """对外可读字段白名单：排除任何推理过程字段（AC-32 的机器可读断言）。""" + body = self.model_dump(mode="json") + return {key: body[key] for key in ( + "id", "run_id", "parent_step_id", "sequence", "kind", "component_ref", + "input_refs", "output_refs", "evidence_ids", "status", "started_at", + "finished_at", "reason_summary", "error_code", "latency_ms", "cost", + "cost_currency")} + + +class ReviewOutcome(Contract): + """评审会结果记录。`label` 只在口径明确时才有值，未确认的一律为空。""" + + id: str = Field(min_length=1, max_length=ID_MAX) + project_id: str = Field(min_length=1, max_length=ID_MAX) + meeting_id: str = Field(min_length=1, max_length=ID_MAX) + revision: int = Field(ge=1) + occurred_at: AwareDatetime + recorded_at: AwareDatetime + reviewed_snapshot_id: str | None = Field(default=None, max_length=ID_MAX) + raw_code: str = Field(min_length=1, max_length=100) + normalized: EventOutcome + mapping_ref: Ref | None = None + label: bool | None = None + conditions: list[str] = Field(default_factory=list, max_length=50) + evidence_ids: list[str] = Field(default_factory=list, max_length=EVIDENCE_MAX) + status: Literal["matched", "unmatched"] + supersedes_id: str | None = Field(default=None, max_length=ID_MAX) + recorded_by: str = Field(min_length=1, max_length=ID_MAX) + + @model_validator(mode="after") + def _check_outcome(self) -> ReviewOutcome: + if self.status == "unmatched" and self.reviewed_snapshot_id is not None: + raise ValueError("找不到对应材料版本时应记为 unmatched，不得挂上任何快照") + if self.status == "matched" and self.reviewed_snapshot_id is None: + raise ValueError("matched 必须指向被评审的材料版本") + if self.label is not None: + if self.mapping_ref is None or self.status != "matched": + raise ValueError("没有明确映射口径或材料版本未匹配时不得给出二元标签") + if self.normalized not in (EventOutcome.approved, EventOutcome.rejected): + raise ValueError("只有通过/否决才有二元标签；附条件、撤回、未送审一律留空") + if self.supersedes_id == self.id: + raise ValueError("更正不能指向自己") + return self + + def counts_toward_denominator(self) -> bool: + """未送审、撤回、附条件、未知都不进入已观察通过率的分母（AC-22/37）。""" + return self.status == "matched" and self.normalized in ( + EventOutcome.approved, EventOutcome.rejected) diff --git a/backend/services/trajectory.py b/backend/services/trajectory.py new file mode 100644 index 0000000..d3b2530 --- /dev/null +++ b/backend/services/trajectory.py @@ -0,0 +1,174 @@ +"""T10 轨迹回放与会议结果复盘。 + +依据：docs/v2/03-detailed-design.md §9.1/§9.4、14-experience-loop.md §7/§8； +BR-13/31/32、E-05/23/26、AC-22/32/33。 + +三条不可让渡的规则： +1. **只读回放**：轨迹从既有 run 的步骤投影出来，本模块不写 run，也不改历史结果。 +2. **失败保留**：失败的步骤照样出现并带错误码，不因为"看起来不好"被过滤。 +3. **结果追加**：会议结果只能新增；更正生成新记录并指向 `supersedes_id`， + 找不到材料版本的一律记 unmatched 并单列，不当成否决、也不进通过率分母。 +""" + +from __future__ import annotations + +from contracts.prescreen import EventOutcome +from contracts.trajectory import ReviewOutcome, TrajectoryStep +from services import assistant_store as store + +KIND = "review_outcome" +DEFAULT_PAGE = 50 + +# 既有步骤状态 → 轨迹状态。partial 不是完成，保留原样说明，避免看起来"全过"。 +_STATUS_MAP = {"running": "running", "completed": "completed", "partial": "completed", + "failed": "failed", "skipped": "skipped", "cancelled": "cancelled"} +_PARTIAL_NOTE = "部分完成（原始状态 partial）；未完成的部分不计入已核查" +_FAILURE_CODE_FALLBACK = "RUN_STEP_FAILED" + +RAW_ALIASES = { + "通过": EventOutcome.approved, "同意": EventOutcome.approved, + "否决": EventOutcome.rejected, "未通过": EventOutcome.rejected, + "附条件": EventOutcome.conditional, "附条件通过": EventOutcome.conditional, + "暂缓": EventOutcome.deferred, "撤回": EventOutcome.withdrawn, + "未送审": EventOutcome.not_submitted, +} + + +def _step(run_body: dict, raw: dict, index: int) -> TrajectoryStep: + status = _STATUS_MAP.get(str(raw.get("status")), "skipped") + errors = raw.get("errors") or () + notes = [] + if raw.get("status") == "partial": + notes.append(_PARTIAL_NOTE) + if raw.get("missing_inputs"): + notes.append("缺证：" + "、".join(str(item) for item in raw["missing_inputs"])) + skill = raw.get("skill") or {} + component = {"id": skill["id"], "version": str(skill.get("version", ""))} if skill.get("id") else None + return TrajectoryStep( + id=str(raw.get("step_id")), run_id=str(raw.get("run_id") or run_body.get("id")), + parent_step_id=None, sequence=index, + kind="skill" if raw.get("skill") else "tool" if raw.get("tool") else "plan", + component_ref=component, + input_refs=[str(raw.get("input_snapshot_id"))] if raw.get("input_snapshot_id") else [], + output_refs=sorted(str(key) for key in (raw.get("outputs") or {})), + evidence_ids=sorted({str(item) for finding in raw.get("findings") or () + for item in (finding.get("evidence_ids") or ())}), + status=status, + started_at=raw.get("started_at"), finished_at=raw.get("finished_at"), + reason_summary="；".join(notes) or None, + error_code=(str(errors[0].get("code")) if errors and errors[0].get("code") + else _FAILURE_CODE_FALLBACK) if status == "failed" else None, + latency_ms=raw.get("latency_ms"), cost=None, cost_currency=None) + # 成本缺省一律留空：既有运行没有成本口径时不得填 0 或估计值（06 §5）。 + + +def project_steps(run_body: dict) -> list[dict]: + """把既有 run 的步骤投影成轨迹步骤，顺序即 sequence，不改写原 run。""" + return [_step(run_body, raw, index).model_dump(mode="json") + for index, raw in enumerate(run_body.get("steps") or ())] + + +def replay(db, project_id: str, run_id: str, cursor: str | None = None, + limit: int = DEFAULT_PAGE) -> dict: + """只读回放：按 sequence 稳定分页。不存在或跨项目 → KeyError（接口层转 404）。""" + run = store.get(db, "run", run_id) + if run.get("project_id") != project_id: + raise KeyError("运行不存在或不属于该项目") + steps = project_steps(run) + start = max(0, int(cursor or 0)) + window = steps[start:start + max(1, min(limit, 200))] + end = start + len(window) + return { + "run_id": run_id, "project_id": project_id, "status": run.get("status"), + "snapshot_id": run.get("input_snapshot_id"), + "steps": window, + "next_cursor": str(end) if end < len(steps) else None, + "read_only": True, + "note": "轨迹只记录可观察动作与版本；不包含模型内部推理过程", + } + + +def _outcomes(db, project_id: str) -> list[dict]: + return list(store.listing(db, KIND, project_id)) + + +def _chain_has_cycle(rows: list[dict], start: str) -> bool: + """防御性检查：追加写入本身造不出环，但迁移/导入的旧行可能有（03 §9.1）。""" + seen, current = set(), start + while current: + if current in seen: + return True + seen.add(current) + current = next((item.get("supersedes_id") for item in rows + if item["id"] == current), None) + return False + + +def record(db, project_id: str, body: dict, actor: str, + known_snapshots=()) -> dict: + """追加一条会议结果。更正只能新增，且必须指向同项目的旧记录。""" + rows = _outcomes(db, project_id) + raw_code = str(body.get("raw_code") or "").strip() + if not raw_code: + raise ValueError("会议结果必须给出原始结果码，未提供时不得推断") + + normalized = body.get("normalized") or RAW_ALIASES.get(raw_code, EventOutcome.unknown) + if isinstance(normalized, str): + normalized = EventOutcome(normalized) + snapshot = body.get("reviewed_snapshot_id") + matched = bool(snapshot) and (not known_snapshots or snapshot in set(known_snapshots)) + + supersedes = body.get("supersedes_id") + if supersedes: + previous = next((item for item in rows if item["id"] == supersedes), None) + if previous is None: + raise ValueError("更正要指向本项目既有的会议结果记录") + if _chain_has_cycle(rows, supersedes): + raise ValueError("更正链出现循环，已拒绝") + mapping_ref = body.get("mapping_ref") + label = None + if matched and mapping_ref and normalized in (EventOutcome.approved, EventOutcome.rejected): + label = normalized == EventOutcome.approved + + revision = 1 + max([item.get("revision", 0) for item in rows + if item.get("meeting_id") == body.get("meeting_id")] or [0]) + outcome = ReviewOutcome( + id=store.uid("outcome"), project_id=project_id, + meeting_id=str(body.get("meeting_id") or ""), revision=revision, + occurred_at=body.get("occurred_at") or store.now(), recorded_at=store.now(), + reviewed_snapshot_id=snapshot if matched else None, + raw_code=raw_code, normalized=normalized, mapping_ref=mapping_ref, label=label, + conditions=list(body.get("conditions") or ()), + evidence_ids=list(body.get("evidence_ids") or ()), + status="matched" if matched else "unmatched", + supersedes_id=supersedes, recorded_by=actor) + saved = outcome.model_dump(mode="json") + store.put(db, KIND, saved) + store.event(db, project_id, "review_outcome.recorded", actor, + {"outcome_id": saved["id"], "status": saved["status"], + "raw_code": saved["raw_code"]}, None) + return saved + + +def listing(db, project_id: str, status: str | None = None) -> dict: + """按匹配状态分组返回。unmatched 单列，不混进通过率分母。""" + rows = sorted(_outcomes(db, project_id), + key=lambda item: item.get("recorded_at") or "") + observed = [item for item in rows if item["status"] == "matched"] + unmatched = [item for item in rows if item["status"] == "unmatched"] + if status == "matched": + return {"items": observed} + if status == "unmatched": + return {"items": unmatched} + return {"items": rows, "matched": observed, "unmatched": unmatched, + "counts_toward_denominator": denominator(rows)} + + +def denominator(rows) -> dict: + """已观察分母只数"匹配到材料版本且有通过/否决口径"的记录（AC-22/37）。""" + labelled = [item for item in rows if item.get("status") == "matched" + and item.get("normalized") in ("approved", "rejected")] + excluded = [(item["id"], item.get("raw_code"), item.get("normalized")) + for item in rows if item not in labelled] + return {"observed": len(labelled), "excluded": excluded, + "note": "未送审、撤回、附条件与未知结果不计入已观察通过率；不把未知当否决"} diff --git a/backend/test_trajectory.py b/backend/test_trajectory.py new file mode 100644 index 0000000..62243c7 --- /dev/null +++ b/backend/test_trajectory.py @@ -0,0 +1,288 @@ +"""T10 轨迹回放与会议结果复盘测试。 + +覆盖 AC-32（一个 run 多 step、失败保留、可追溯、不伪造隐藏推理） +与 AC-33（unmatched 单列、更正追加并引用旧版、不改原预测）， +以及 06 §5 要求的"成本未知不得伪造"。 + +同时验证只读性：回放与追加会议结果都不改动既有 run。 +""" + +import os +import tempfile +import unittest +from pathlib import Path +from unittest.mock import patch + +from fastapi import FastAPI +from fastapi.exceptions import RequestValidationError +from fastapi.testclient import TestClient + +from api import prescreen as api +from contracts.trajectory import ReviewOutcome, TrajectoryStep +from services import assistant_store as store +from services import trajectory +from services.project_assistant import ProjectAssistantService + +HEADERS = {"X-Xingbang-Demo-Role": "manager"} +PROJECT = "DEMO-B" + + +def step(step_id, status="completed", **over): + body = {"run_id": "run-1", "step_id": step_id, "name": f"步骤 {step_id}", + "skill": {"id": step_id, "version": "1.0.0"}, "status": status, + "input_snapshot_id": "snap-1", "started_at": "2026-09-30T01:00:00+00:00", + "finished_at": "2026-09-30T01:00:03+00:00", "attempt": 1, + "outputs": {"requirement_response": "已核查"}, + "findings": [{"code": f"{step_id}.check", "result": "issue", + "evidence_ids": ["EV-1"]}], + "errors": [], "missing_inputs": [], "output_sources": {}} + body.update(over) + return body + + +def run_body(steps=None, **over): + body = {"id": "run-1", "project_id": PROJECT, "status": "completed", + "input_snapshot_id": "snap-1", "revision": 1, + "created_at": "2026-09-30T01:00:00+00:00", + "steps": steps if steps is not None else [step("corporate.cashflow")]} + body.update(over) + return body + + +class TrajectoryProjectionTests(unittest.TestCase): + def test_one_run_becomes_one_trajectory_with_many_steps(self): + rows = trajectory.project_steps(run_body(steps=[ + step("corporate.cashflow"), step("corporate.title"), + step("corporate.deal", status="failed", + errors=[{"code": "SKILL_TIMEOUT", "message": "模型超时"}])])) + self.assertEqual([item["sequence"] for item in rows], [0, 1, 2]) + self.assertEqual({item["run_id"] for item in rows}, {"run-1"}) + self.assertEqual(len({item["id"] for item in rows}), 3) + + def test_failed_step_is_preserved_with_a_code(self): + rows = trajectory.project_steps(run_body(steps=[ + step("a"), step("b", status="failed", + errors=[{"code": "SKILL_TIMEOUT", "message": "超时"}])])) + failed = [item for item in rows if item["status"] == "failed"] + self.assertEqual(len(failed), 1, "失败的步骤不得被过滤掉") + self.assertEqual(failed[0]["error_code"], "SKILL_TIMEOUT") + + def test_failed_step_without_error_detail_still_carries_a_code(self): + rows = trajectory.project_steps(run_body(steps=[step("b", status="failed")])) + self.assertTrue(rows[0]["error_code"], "失败必须留痕，不能只有一条看不出原因的记录") + + def test_partial_is_not_reported_as_fully_checked(self): + rows = trajectory.project_steps(run_body(steps=[step("a", status="partial", + missing_inputs=["银行流水"])])) + self.assertIn("部分完成", rows[0]["reason_summary"]) + self.assertIn("银行流水", rows[0]["reason_summary"]) + + def test_steps_expose_only_observable_fields(self): + rows = trajectory.project_steps(run_body()) + allowed = set(TrajectoryStep.model_fields) + for row in rows: + self.assertTrue(set(row) <= allowed) + for banned in ("thought", "reasoning", "chain_of_thought", "scratchpad", + "hidden_state", "prompt"): + self.assertNotIn(banned, rows[0], "轨迹不得包含模型内部推理字段") + + def test_cost_is_unknown_not_zero(self): + rows = trajectory.project_steps(run_body()) + self.assertIsNone(rows[0]["cost"], "没有成本口径时应留空，不得填 0 或估计值") + self.assertIsNone(rows[0]["cost_currency"]) + + def test_evidence_and_versions_are_traceable(self): + rows = trajectory.project_steps(run_body()) + self.assertEqual(rows[0]["evidence_ids"], ["EV-1"]) + self.assertEqual(rows[0]["component_ref"], {"id": "corporate.cashflow", + "version": "1.0.0"}) + self.assertEqual(rows[0]["input_refs"], ["snap-1"]) + + +class TrajectoryStoreTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True) + self.service = ProjectAssistantService(Path(self.temp.name) / "assistant.sqlite3") + with store.transaction(self.service.db_path) as db: + store.put(db, "run", run_body(steps=[step("a"), step("b", status="failed")])) + + def tearDown(self): + self.temp.cleanup() + + def test_replay_is_read_only_and_paginated(self): + with store.transaction(self.service.db_path) as db: + before = store.get(db, "run", "run-1") + page = trajectory.replay(db, PROJECT, "run-1", limit=1) + after = store.get(db, "run", "run-1") + self.assertEqual(len(page["steps"]), 1) + self.assertEqual(page["next_cursor"], "1") + self.assertTrue(page["read_only"]) + self.assertEqual(before, after, "回放不得改动运行") + + def test_replay_rejects_foreign_project(self): + with store.transaction(self.service.db_path) as db: + with self.assertRaises(KeyError): + trajectory.replay(db, "OTHER-9", "run-1") + + +class ReviewOutcomeTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True) + self.service = ProjectAssistantService(Path(self.temp.name) / "assistant.sqlite3") + + def tearDown(self): + self.temp.cleanup() + + def record(self, **over): + body = {"raw_code": "通过", "meeting_id": "M-1", + "occurred_at": "2026-09-29T02:00:00+00:00", + "reviewed_snapshot_id": "snap-1", "evidence_ids": ["EV-1"]} + body.update(over) + with store.transaction(self.service.db_path) as db: + return trajectory.record(db, PROJECT, body, "reviewer-1", + known_snapshots=["snap-1"]) + + def test_unknown_snapshot_is_unmatched_and_has_no_label(self): + saved = self.record(reviewed_snapshot_id=None) + self.assertEqual(saved["status"], "unmatched") + self.assertIsNone(saved["label"], "未匹配材料版本时不得给出二元标签") + self.assertIsNone(saved["reviewed_snapshot_id"]) + + def test_conditional_is_never_labeled_as_approved(self): + saved = self.record(raw_code="附条件通过") + self.assertEqual(saved["normalized"], "conditional") + self.assertIsNone(saved["label"], "附条件不等于通过（BR-21）") + + def test_withdrawn_is_recorded_but_excluded_from_denominator(self): + self.record(raw_code="撤回") + self.record(raw_code="通过") + with store.transaction(self.service.db_path) as db: + listed = trajectory.listing(db, PROJECT) + self.assertEqual(listed["counts_toward_denominator"]["observed"], 1) + excluded = listed["counts_toward_denominator"]["excluded"] + self.assertEqual([item[1] for item in excluded], ["撤回"]) + + def test_correction_appends_and_references_the_old_record(self): + first = self.record(raw_code="通过") + corrected = self.record(raw_code="否决", supersedes_id=first["id"]) + self.assertEqual(corrected["supersedes_id"], first["id"]) + self.assertGreater(corrected["revision"], first["revision"]) + with store.transaction(self.service.db_path) as db: + rows = trajectory.listing(db, PROJECT)["items"] + self.assertEqual(len(rows), 2, "更正必须追加，不得覆盖旧记录") + self.assertEqual(rows[0]["raw_code"], "通过") + + def test_correction_must_point_to_an_existing_record_of_the_project(self): + with self.assertRaises(ValueError): + self.record(supersedes_id="outcome-missing") + + def test_supersede_chains_always_terminate(self): + first = self.record(raw_code="通过") + second = self.record(raw_code="否决", supersedes_id=first["id"]) + self.record(raw_code="附条件", supersedes_id=second["id"]) + with store.transaction(self.service.db_path) as db: + rows = trajectory.listing(db, PROJECT)["items"] + by_id = {item["id"]: item for item in rows} + for item in rows: + seen, current = set(), item["id"] + while current: + self.assertNotIn(current, seen, "更正链不得出现循环") + seen.add(current) + current = (by_id.get(current) or {}).get("supersedes_id") + self.assertEqual(len(rows), 3) + + def test_missing_raw_code_is_rejected(self): + with self.assertRaises(ValueError): + self.record(raw_code="") + + def test_recording_never_touches_runs(self): + with store.transaction(self.service.db_path) as db: + store.put(db, "run", run_body()) + before = None + with store.transaction(self.service.db_path) as db: + before = store.get(db, "run", "run-1") + self.record(raw_code="否决") + with store.transaction(self.service.db_path) as db: + after = store.get(db, "run", "run-1") + self.assertEqual(before, after, "会议结果不得改写历史预测") + + def test_contract_refuses_label_without_mapping(self): + with self.assertRaises(ValueError): + ReviewOutcome(id="o-1", project_id=PROJECT, meeting_id="M-1", revision=1, + occurred_at="2026-09-29T02:00:00+00:00", + recorded_at="2026-09-29T02:00:00+00:00", + reviewed_snapshot_id="snap-1", raw_code="通过", + normalized="approved", label=True, status="matched", + recorded_by="reviewer-1") + + +class TrajectoryApiTests(unittest.TestCase): + def setUp(self): + self.temp = tempfile.TemporaryDirectory(ignore_cleanup_errors=True) + self.service = ProjectAssistantService(Path(self.temp.name) / "assistant.sqlite3") + self.patches = [ + patch.object(api, "_service", lambda: self.service), + patch.dict(os.environ, {"XINGBANG_AUTH_USERS": "", "XINGBANG_REQUIRE_AUTH": "0", + "XINGBANG_LOCAL_MODEL_URL": ""}), + ] + for item in self.patches: + item.start() + app = FastAPI() + app.add_exception_handler(RequestValidationError, api.validation_handler) + app.include_router(api.router) + self.client = TestClient(app) + self.base = "/api/xingbang/risk-agent/project-assistant/prescreen" + with store.transaction(self.service.db_path) as db: + store.put(db, "run", run_body(steps=[step("a"), step("b", status="failed", + errors=[{"code": "SKILL_TIMEOUT"}])])) + + def tearDown(self): + self.client.close() + for item in reversed(self.patches): + item.stop() + self.temp.cleanup() + + def test_trajectory_replay_over_http(self): + response = self.client.get(f"{self.base}/projects/{PROJECT}/runs/run-1/trajectory", + headers=HEADERS) + self.assertEqual(response.status_code, 200) + body = response.json() + self.assertEqual([item["status"] for item in body["steps"]], + ["completed", "failed"]) + self.assertTrue(body["read_only"]) + + def test_trajectory_of_missing_run_is_404(self): + response = self.client.get(f"{self.base}/projects/{PROJECT}/runs/run-x/trajectory", + headers=HEADERS) + self.assertEqual(response.status_code, 404) + + def test_outcome_round_trip(self): + created = self.client.post( + f"{self.base}/projects/{PROJECT}/review-outcomes", + json={"raw_code": "附条件通过", "meeting_id": "M-1"}, + headers=HEADERS) + self.assertEqual(created.status_code, 201) + self.assertEqual(created.json()["status"], "unmatched") + self.assertIsNone(created.json()["label"]) + + listed = self.client.get(f"{self.base}/projects/{PROJECT}/review-outcomes", + headers=HEADERS) + self.assertEqual(len(listed.json()["unmatched"]), 1) + self.assertEqual(listed.json()["counts_toward_denominator"]["observed"], 0) + + def test_outcome_without_raw_code_is_rejected(self): + response = self.client.post( + f"{self.base}/projects/{PROJECT}/review-outcomes", + json={"meeting_id": "M-1"}, headers=HEADERS) + self.assertEqual(response.status_code, 422) + self.assertEqual(response.json()["error"]["code"], "INVALID_REQUEST") + + def test_unknown_outcome_status_filter_is_rejected(self): + response = self.client.get( + f"{self.base}/projects/{PROJECT}/review-outcomes?status=weird", + headers=HEADERS) + self.assertEqual(response.status_code, 422) + + +if __name__ == "__main__": + unittest.main()