flare-kernel 1.0.3__tar.gz → 1.0.4__tar.gz

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flare-kernel
-Version: 1.0.3
+Version: 1.0.4
 Summary: FLARE kernel runtime package
 License: Proprietary
 Classifier: Development Status :: 3 - Alpha

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "flare-kernel"
-version = "1.0.3"
+version = "1.0.4"
 description = "FLARE kernel runtime package"
 readme = "README.md"
 requires-python = ">=3.11"

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/src/flare_kernel/router/streaming/draft/reconciliation_completion.py

@@ -29,14 +29,19 @@ def _merge_context_patch(existing: Any, incoming: Any) -> dict[str, Any]:
 
 
 def _active_artifact_from_canvas(canvas_state: dict[str, Any]) -> dict[str, Any]:
-    artifact_document = _mapping(canvas_state.get("artifact_document"))
+    artifact_document = dict(_mapping(canvas_state.get("artifact_document")))
     return {
+        **artifact_document,
         "artifact_id": str(artifact_document.get("artifact_id") or "").strip(),
-        "document_kind": str(artifact_document.get("artifact_type") or "runtime_active_artifact").strip(),
+        "document_kind": str(
+            artifact_document.get("document_kind")
+            or artifact_document.get("artifact_type")
+            or "runtime_active_artifact"
+        ).strip(),
         "title": str(artifact_document.get("title") or "").strip(),
         "content": str(artifact_document.get("content") or "").strip(),
         "content_format": str(artifact_document.get("content_format") or "markdown").strip(),
-        "active_tab": "requirement",
+        "active_tab": str(artifact_document.get("active_tab") or "requirement").strip(),
         "status": str(artifact_document.get("status") or "accepted").strip(),
         "source": "reconciliation_runtime",
     }

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/src/flare_kernel/runtime/orchestration/active_artifact_context_runtime.py

@@ -11,6 +11,18 @@ from typing import Any
 _BLOCKED_SOURCE_MARKERS = frozenset(
     {"assistant_reply", "conversation_reply", "boundary_guidance"}
 )
+_STRUCTURE_KEYS = (
+    "artifact_type",
+    "latest_revision",
+    "semantic_map",
+    "procurement_semantic_map",
+    "structure_map",
+    "procurement_packages",
+    "field_pack_suggestions",
+    "metadata",
+    "upkeep_status",
+    "artifact_hud",
+)
 
 
 def _as_mapping(value: Any) -> dict[str, Any]:
@@ -25,6 +37,10 @@ def _content_text(value: Any) -> str:
     return str(value or "").strip()
 
 
+def _structure_fields(source: dict[str, Any]) -> dict[str, Any]:
+    return {key: source[key] for key in _STRUCTURE_KEYS if key in source}
+
+
 def _artifact_document(canvas_state: Any) -> dict[str, Any]:
     payload = _as_mapping(canvas_state)
     direct = _as_mapping(payload.get("artifact_document"))
@@ -65,6 +81,7 @@ def _project_artifact_context(message: dict[str, Any]) -> dict[str, Any]:
     if not artifact_id or not content or _blocked_source(artifact_document, canvas_state):
         return {}
     return {
+        **_structure_fields(artifact_document),
         "artifact_id": artifact_id,
         "document_kind": "runtime_active_artifact",
         "title": _clean_text(artifact_document.get("title")) or "需求文档",
@@ -87,6 +104,7 @@ def _explicit_artifact_context(payload: dict[str, Any]) -> dict[str, Any]:
     if not content:
         return {}
     return {
+        **_structure_fields(context),
         "artifact_id": _clean_text(context.get("artifact_id")) or "active_artifact",
         "document_kind": _clean_text(context.get("document_kind")) or "runtime_active_artifact",
         "title": _clean_text(context.get("title")) or "当前文档",
@@ -114,6 +132,7 @@ def _artifact_context_row_context(row: dict[str, Any]) -> dict[str, Any]:
     if not artifact_id or not content:
         return {}
     return {
+        **_structure_fields(row),
         "artifact_id": artifact_id,
         "document_kind": _clean_text(row.get("document_kind")) or "runtime_active_artifact",
         "title": _clean_text(row.get("title")) or "当前文档",

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/src/flare_kernel/runtime/orchestration/mode/intake_artifact_semantic_map.py

@@ -52,7 +52,14 @@ def _list(value: Any) -> list[Any]:
 def _unique(values: list[Any]) -> list[str]:
     result: list[str] = []
     for value in values:
-        item = _text(value)
+        item = _public_label(
+            _mapping(value).get("value"),
+            _mapping(value).get("label"),
+            _mapping(value).get("title"),
+            _mapping(value).get("name"),
+            _mapping(value).get("field_key"),
+            value,
+        )
         if item and item not in result:
             result.append(item)
     return result
@@ -177,9 +184,10 @@ def _value_nodes(package: dict[str, Any], key: str, *, package_id: str, node_typ
     nodes: list[dict[str, Any]] = []
     for index, value in enumerate(_list(package.get(key)), start=1):
         node_id = f"{package_id}:{key}:{index}"
+        item = _mapping(value)
         node = _node(
             node_id=node_id,
-            label=_text(value),
+            label=_public_label(item.get("value"), item.get("label"), item.get("title"), item.get("name"), value),
             node_type=node_type,
             summary=summary,
         )

flare_kernel-1.0.4/src/flare_kernel/runtime/reconciliation/artifact_projection.py

@@ -0,0 +1,155 @@
+"""Artifact projection enrichment for reconciliation patch results.
+
+This module turns lean patch snapshots into structure-preserving artifact rows.
+It does not decide whether a patch should run, persist data, or call providers.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_kernel.runtime.artifact_edit.semantic_map_refresh import (
+    refresh_requirement_semantic_map,
+)
+
+_STRUCTURE_KEYS = (
+    "semantic_map",
+    "procurement_semantic_map",
+    "structure_map",
+    "procurement_packages",
+    "field_pack_suggestions",
+    "metadata",
+    "upkeep_status",
+    "artifact_hud",
+)
+
+
+def _mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _sequence(value: Any) -> list[Any]:
+    return value if isinstance(value, list) else []
+
+
+def _text(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _operations(patch_preview: dict[str, Any]) -> list[dict[str, Any]]:
+    return [
+        item
+        for item in (_mapping(row) for row in _sequence(patch_preview.get("operations")))
+        if _text(item.get("operation_type")) == "replace_text"
+    ]
+
+
+def _patch_text(value: str, operations: list[dict[str, Any]]) -> str:
+    result = value
+    for operation in operations:
+        target = str(operation.get("target_text") or "")
+        replacement = str(operation.get("replacement_text") or "")
+        if not target or target not in result:
+            continue
+        result = result.replace(target, replacement) if operation.get("replace_all") is True else result.replace(target, replacement, 1)
+    return result
+
+
+def _patch_value(value: Any, operations: list[dict[str, Any]]) -> Any:
+    if isinstance(value, str):
+        return _patch_text(value, operations)
+    if isinstance(value, list):
+        return [_patch_value(item, operations) for item in value]
+    if isinstance(value, dict):
+        return {key: _patch_value(item, operations) for key, item in value.items()}
+    return value
+
+
+def _source_key(row: dict[str, Any]) -> tuple[str, str]:
+    return (_text(row.get("artifact_id")), _text(row.get("active_tab")))
+
+
+def _has_structure(row: dict[str, Any]) -> bool:
+    return any(key in row and row[key] for key in _STRUCTURE_KEYS)
+
+
+def _first_structured(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    for row in rows:
+        if _has_structure(row):
+            return row
+    return rows[0] if rows else {}
+
+
+def _matching_source(snapshot: dict[str, Any], source_artifacts: list[dict[str, Any]]) -> dict[str, Any]:
+    snapshot_key = _source_key(snapshot)
+    exact_matches = [row for row in source_artifacts if _source_key(row) == snapshot_key]
+    if exact_matches:
+        return _first_structured(exact_matches)
+    artifact_id = snapshot_key[0]
+    id_matches = [row for row in source_artifacts if artifact_id and _text(row.get("artifact_id")) == artifact_id]
+    return _first_structured(id_matches)
+
+
+def _is_requirement(row: dict[str, Any]) -> bool:
+    active_tab = _text(row.get("active_tab"))
+    artifact_type = _text(row.get("artifact_type") or row.get("document_kind"))
+    return active_tab == "requirement" or artifact_type in {"requirements_document", "requirement_summary"}
+
+
+def _canvas_state(payload: dict[str, Any]) -> dict[str, Any]:
+    canvas_payload = _mapping(payload.get("canvas_state"))
+    nested = _mapping(canvas_payload.get("canvas_state"))
+    return nested or canvas_payload
+
+
+def _latest_revision(snapshot: dict[str, Any]) -> dict[str, Any]:
+    latest = dict(_mapping(snapshot.get("latest_revision")))
+    content = _text(snapshot.get("content"))
+    if content:
+        latest["content"] = content
+    return latest
+
+
+def _refresh_semantic_map(
+    *,
+    document: dict[str, Any],
+    payload: dict[str, Any],
+    snapshot: dict[str, Any],
+) -> dict[str, Any]:
+    existing = _mapping(document.get("semantic_map"))
+    if not _is_requirement(document):
+        return existing
+    refreshed = refresh_requirement_semantic_map(
+        document=document,
+        canvas_state=_canvas_state(payload),
+        revision=_latest_revision(snapshot),
+    )
+    return refreshed or existing
+
+
+def enrich_patch_snapshots(
+    *,
+    snapshots: list[dict[str, Any]],
+    source_artifacts: list[dict[str, Any]],
+    patch_preview: dict[str, Any],
+    payload: dict[str, Any],
+) -> list[dict[str, Any]]:
+    """Return patch snapshots enriched with their original artifact structure."""
+
+    operations = _operations(patch_preview)
+    enriched: list[dict[str, Any]] = []
+    for snapshot in snapshots:
+        source = _matching_source(snapshot, source_artifacts)
+        base = _patch_value(source, operations) if source else {}
+        row = {**_mapping(base), **snapshot, "latest_revision": _latest_revision(snapshot)}
+        for key in _STRUCTURE_KEYS:
+            if key not in row and key in _mapping(base):
+                row[key] = base[key]
+        semantic_map = _refresh_semantic_map(document=row, payload=payload, snapshot=snapshot)
+        if semantic_map:
+            row["semantic_map"] = semantic_map
+        enriched.append(row)
+    return enriched
+
+
+__all__ = ["enrich_patch_snapshots"]

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/src/flare_kernel/runtime/reconciliation/executor.py

@@ -11,10 +11,11 @@ from flare_kernel.runtime.reconciliation.contracts import (
     sequence,
     text,
 )
+from flare_kernel.runtime.reconciliation.artifact_projection import enrich_patch_snapshots
 from flare_kernel.runtime.reconciliation.events import trace_event
 
 
-def _artifact_rows(payload: dict[str, Any], policy: dict[str, Any]) -> list[dict[str, Any]]:
+def _artifact_rows(payload: dict[str, Any], policy: dict[str, Any], *, dedupe: bool = True) -> list[dict[str, Any]]:
     rows: list[dict[str, Any]] = []
     active = payload.get("active_artifact_context")
     if isinstance(active, dict):
@@ -26,7 +27,8 @@ def _artifact_rows(payload: dict[str, Any], policy: dict[str, Any]) -> list[dict
     rows.extend(item for item in sequence(payload.get("artifact_context")) if isinstance(item, dict))
     session_context = mapping(payload.get("session_context"))
     rows.extend(item for item in sequence(session_context.get("artifact_context")) if isinstance(item, dict))
-    return [{**row, "artifact_type": artifact_type_for(row, policy)} for row in _dedupe_rows(rows)]
+    resolved = _dedupe_rows(rows) if dedupe else rows
+    return [{**row, "artifact_type": artifact_type_for(row, policy)} for row in resolved]
 
 
 def _dedupe_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
@@ -202,8 +204,9 @@ def execute_reconciliation_plan(
 ) -> dict[str, Any]:
     payload = mapping(runtime_snapshot.get("payload"))
     trace = [trace_event("patch_job.started", {"status": "started", "plan_id": plan.get("plan_id")})]
+    source_artifacts = _artifact_rows(payload, policy, dedupe=False)
     execution = apply_reconciliation_plan(
-        artifacts=_artifact_rows(payload, policy),
+        artifacts=_dedupe_rows(source_artifacts),
         patch_preview=patch_preview,
         plan=plan,
         impact=impact,
@@ -219,7 +222,12 @@ def execute_reconciliation_plan(
             "patch_apply_status": execution.get("patch_apply_status"),
         }
 
-    snapshots = [mapping(item) for item in sequence(execution.get("artifact_snapshots")) if mapping(item)]
+    snapshots = enrich_patch_snapshots(
+        snapshots=[mapping(item) for item in sequence(execution.get("artifact_snapshots")) if mapping(item)],
+        source_artifacts=source_artifacts,
+        patch_preview=patch_preview,
+        payload=payload,
+    )
     _append_snapshot_events(trace, plan=plan, snapshots=snapshots, patch_preview=patch_preview)
     _append_step_events(trace, plan, "mark_stale", "artifact.marked_stale")
     _append_step_events(trace, plan, "regenerate_recommended", "artifact.regenerate_recommended")
@@ -231,7 +239,7 @@ def execute_reconciliation_plan(
         "trace": trace,
         "artifact_snapshots": snapshots,
         "patch_apply_status": execution.get("patch_apply_status"),
-        "context_patch": execution.get("context_patch") if isinstance(execution.get("context_patch"), dict) else {},
+        "context_patch": {"artifact_context": snapshots} if snapshots else {},
         **_projection_payloads(snapshots=snapshots, payload=payload, policy=policy),
     }
 

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/src/flare_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flare-kernel
-Version: 1.0.3
+Version: 1.0.4
 Summary: FLARE kernel runtime package
 License: Proprietary
 Classifier: Development Status :: 3 - Alpha

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/src/flare_kernel.egg-info/SOURCES.txt

@@ -714,6 +714,7 @@ src/flare_kernel/runtime/reasoning/intake/readiness/__init__.py
 src/flare_kernel/runtime/reasoning/intake/readiness/core.py
 src/flare_kernel/runtime/reasoning/intake/readiness/scoring.py
 src/flare_kernel/runtime/reconciliation/__init__.py
+src/flare_kernel/runtime/reconciliation/artifact_projection.py
 src/flare_kernel/runtime/reconciliation/context_revision.py
 src/flare_kernel/runtime/reconciliation/contracts.py
 src/flare_kernel/runtime/reconciliation/events.py
@@ -1007,6 +1008,7 @@ tests/test_provider_audit_export.py
 tests/test_reasoning_context_patch.py
 tests/test_reasoning_loop.py
 tests/test_reconciliation_analysis_patch_projection.py
+tests/test_reconciliation_artifact_structure_projection.py
 tests/test_reconciliation_context_revision.py
 tests/test_reconciliation_orchestrator.py
 tests/test_release_isolation_gate.py

{flare_kernel-1.0.3 → flare_kernel-1.0.4}/tests/test_intake_artifact_semantic_map.py

@@ -162,6 +162,46 @@ def test_intake_artifact_semantic_map_updates_when_context_changes() -> None:
     assert _child(second_package, "数量 / 预算")["children"][0]["label"] == "30台"
 
 
+def test_intake_artifact_semantic_map_renders_candidate_objects_as_labels() -> None:
+    artifact = build_intake_artifact_document(
+        canvas_state_payload={"mode_key": "requirement_intake", "session_id": "session-candidate-labels", "canvas_state": {}},
+        runtime_payload={
+            "procurement_packages": [
+                {
+                    "package_id": "admin-service",
+                    "title": "行政服务",
+                    "category_candidates": [
+                        {
+                            "value": "行政服务",
+                            "confidence": 0.55,
+                            "state": "candidate",
+                            "source": "category_resolution",
+                            "reason": "环境、资源",
+                            "needs_confirmation": True,
+                        }
+                    ],
+                    "quantity_candidates": [
+                        {
+                            "value": "2年",
+                            "confidence": 0.6,
+                            "state": "candidate",
+                        }
+                    ],
+                }
+            ],
+        },
+    ).model_dump(exclude_none=True)
+
+    package_node = _branch(artifact["semantic_map"]["tree"], "package")["nodes"][0]
+    category_label = _child(package_node, "品类定位")["children"][0]["label"]
+    quantity_label = _child(package_node, "数量 / 预算")["children"][0]["label"]
+
+    assert category_label == "行政服务"
+    assert quantity_label == "2年"
+    assert "{" not in category_label
+    assert "confidence" not in category_label
+
+
 def test_intake_artifact_semantic_map_projects_template_fields_with_current_values() -> None:
     content = """# AI应用服务器采购分析报告（更新版草案）
 

flare_kernel-1.0.4/tests/test_reconciliation_artifact_structure_projection.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+from flare_kernel.runtime.reconciliation.orchestrator import run_reconciliation
+
+
+def _policy() -> dict:
+    return {
+        "field_rules": [
+            {
+                "field_key": "currency",
+                "match_terms": ["币种"],
+                "change_type": "field_value_update",
+                "auto_apply": True,
+                "artifact_actions": {"requirements_document": "patch"},
+            }
+        ],
+        "artifact_types": {"requirement": "requirements_document"},
+    }
+
+
+def _preview() -> dict:
+    return {
+        "schema_version": "patch.preview.v1",
+        "patch_kind": "content_patch",
+        "status": "auto_apply_ready",
+        "operations": [
+            {
+                "operation_type": "replace_text",
+                "target_text": "币种：美元",
+                "replacement_text": "币种：人民币",
+                "replace_all": True,
+                "target_found": True,
+                "status": "proposed",
+            }
+        ],
+        "preview": {"summary": "文本替换", "diff": "- 币种：美元\n+ 币种：人民币"},
+        "apply": {"enabled": True, "auto_apply": True},
+    }
+
+
+def _artifact() -> dict:
+    return {
+        "artifact_id": "req-structure-1",
+        "artifact_type": "requirements_document",
+        "title": "需求文档",
+        "active_tab": "requirement",
+        "content": "# 需求文档\n\n- 项目：测试服务器采购\n- 币种：美元",
+        "content_format": "markdown",
+        "status": "accepted",
+        "procurement_packages": [
+            {
+                "package_id": "server-package",
+                "title": "测试服务器",
+                "budget_candidates": ["币种：美元"],
+            }
+        ],
+        "field_pack_suggestions": [
+            {
+                "field_pack_id": "currency-pack",
+                "label": "币种字段包",
+                "fields": [{"field_key": "币种", "value": "美元"}],
+            }
+        ],
+        "metadata": {
+            "semantic_template": {
+                "structure_label": "需求结构",
+                "sections": [
+                    {"key": "overview", "label": "项目概述", "fields": ["项目", "币种"]},
+                    {"key": "packages", "label": "采购包", "repeatable": True},
+                ],
+            }
+        },
+        "semantic_map": {
+            "status": "ready",
+            "tree": {
+                "root": {"id": "root", "label": "需求文档", "type": "root"},
+                "branches": [
+                    {
+                        "id": "semantic_structure",
+                        "label": "需求结构",
+                        "type": "structure",
+                        "nodes": [{"id": "currency", "label": "币种：美元", "type": "field"}],
+                    }
+                ],
+            },
+        },
+    }
+
+
+def test_requirement_patch_preserves_structure_projection_and_context() -> None:
+    result = run_reconciliation(
+        raw_message="币种从美元改成人民币，需求清单里面修改一下",
+        runtime_snapshot={
+            "payload": {
+                "session_id": "session-structure",
+                "project_id": "project-structure",
+                "reconciliation_policy": _policy(),
+                "active_artifact_context": _artifact(),
+            },
+            "domain_pack": {"replace_rules": {"reconciliation_policy": _policy()}},
+        },
+        orchestration_status={"patch_preview_result": _preview()},
+    )
+
+    document = result["canvas_state"]["artifact_document"]
+    context_row = result["context_patch"]["artifact_context"][0]
+    semantic_text = str(document.get("semantic_map"))
+
+    assert result["status"] == "completed"
+    assert "币种：人民币" in document["content"]
+    assert document["procurement_packages"][0]["title"] == "测试服务器"
+    assert document["field_pack_suggestions"][0]["label"] == "币种字段包"
+    assert document["metadata"]["semantic_template"]["structure_label"] == "需求结构"
+    assert document["semantic_map"]["status"] == "ready"
+    assert "币种：人民币" in semantic_text
+    assert "币种：美元" not in semantic_text
+    assert context_row["semantic_map"]["status"] == "ready"
+    assert context_row["procurement_packages"][0]["package_id"] == "server-package"
+
+
+def test_reconciliation_completion_preserves_active_artifact_structure() -> None:
+    from flare_kernel.router.streaming.draft.reconciliation_completion import (
+        attach_reconciliation_completion,
+    )
+
+    runtime_snapshot = {
+        "payload": {
+            "session_id": "session-structure",
+            "project_id": "project-structure",
+            "reconciliation_policy": _policy(),
+            "active_artifact_context": _artifact(),
+        },
+        "domain_pack": {"replace_rules": {"reconciliation_policy": _policy()}},
+    }
+    result = attach_reconciliation_completion(
+        raw_message="币种从美元改成人民币，需求清单里面修改一下",
+        runtime_snapshot=runtime_snapshot,
+        orchestration_status={"patch_preview_result": _preview()},
+    )
+
+    active = runtime_snapshot["payload"]["active_artifact_context"]
+
+    assert result["status"] == "completed"
+    assert "币种：人民币" in active["content"]
+    assert active["semantic_map"]["status"] == "ready"
+    assert active["procurement_packages"][0]["package_id"] == "server-package"
+
+
+def test_persisted_context_reload_preserves_active_artifact_structure() -> None:
+    from flare_kernel.runtime.orchestration.active_artifact_context_runtime import (
+        resolve_active_artifact_context,
+    )
+    from flare_kernel.session_store import append_exchange, create_session, get_session, reset_store_for_testing
+
+    reset_store_for_testing()
+    session = create_session(function_type="requirement_intake", project_id="p", title="Demo", user_id="u")
+    result = run_reconciliation(
+        raw_message="币种从美元改成人民币，需求清单里面修改一下",
+        runtime_snapshot={
+            "payload": {
+                "session_id": session["session_id"],
+                "project_id": "p",
+                "reconciliation_policy": _policy(),
+                "active_artifact_context": _artifact(),
+            },
+            "domain_pack": {"replace_rules": {"reconciliation_policy": _policy()}},
+        },
+        orchestration_status={"patch_preview_result": _preview()},
+    )
+
+    append_exchange(session_id=session["session_id"], context_patch=result["context_patch"])
+    stored = get_session(session_id=session["session_id"])
+    context = stored["context"]
+    active = resolve_active_artifact_context(
+        session_id=session["session_id"],
+        payload={"session_context": context},
+    )
+
+    assert context["artifact_context"][0]["semantic_map"]["status"] == "ready"
+    assert active["semantic_map"]["status"] == "ready"
+    assert active["procurement_packages"][0]["title"] == "测试服务器"
+
+
+def test_patch_recovers_structure_when_active_context_is_lean_snapshot() -> None:
+    structured = _artifact()
+    lean_active = {
+        "artifact_id": structured["artifact_id"],
+        "artifact_type": structured["artifact_type"],
+        "title": structured["title"],
+        "active_tab": "requirement",
+        "content": structured["content"],
+        "content_format": "markdown",
+        "status": "accepted",
+    }
+
+    result = run_reconciliation(
+        raw_message="币种从美元改成人民币，需求清单里面修改一下",
+        runtime_snapshot={
+            "payload": {
+                "session_id": "session-lean-active",
+                "project_id": "project-structure",
+                "reconciliation_policy": _policy(),
+                "active_artifact_context": lean_active,
+                "session_context": {"artifact_context": [structured]},
+            },
+            "domain_pack": {"replace_rules": {"reconciliation_policy": _policy()}},
+        },
+        orchestration_status={"patch_preview_result": _preview()},
+    )
+
+    document = result["canvas_state"]["artifact_document"]
+
+    assert "币种：人民币" in document["content"]
+    assert document["semantic_map"]["status"] == "ready"
+    assert document["procurement_packages"][0]["title"] == "测试服务器"