flare-kernel 1.0.1__tar.gz → 1.0.2__tar.gz

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/PKG-INFO

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

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/pyproject.toml

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

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/contracts/__init__.py

@@ -23,6 +23,7 @@ from flare_kernel.contracts.artifact_document import (
     ArtifactDocument,
     ArtifactFieldSuggestion,
     ArtifactSection,
+    ArtifactUpkeepStatus,
     FieldPackSuggestion,
     ProcurementPackage,
 )
@@ -117,6 +118,7 @@ __all__ = [
     "ArtifactDocument",
     "ArtifactFieldSuggestion",
     "ArtifactSection",
+    "ArtifactUpkeepStatus",
     "FieldPackSuggestion",
     "ProcurementPackage",
     "AnalysisRouteDecision",

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/contracts/artifact_document.py

@@ -43,6 +43,16 @@ class FieldPackSuggestion(BaseModel):
     metadata: dict[str, Any] = Field(default_factory=dict)
 
 
+class ArtifactUpkeepStatus(BaseModel):
+    state: str = ""
+    reason: str = ""
+    action: dict[str, Any] = Field(default_factory=dict)
+    source_revision_id: str = ""
+    target_revision_id: str = ""
+    updated_at: str = ""
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+
 class ProcurementPackage(BaseModel):
     package_id: str
     title: str = ""
@@ -73,6 +83,7 @@ class ArtifactDocument(BaseModel):
     procurement_packages: list[ProcurementPackage] = Field(default_factory=list)
     field_pack_suggestions: list[FieldPackSuggestion] = Field(default_factory=list)
     semantic_map: dict[str, Any] = Field(default_factory=dict)
+    upkeep_status: ArtifactUpkeepStatus | None = None
     actions: list[dict[str, Any]] = Field(default_factory=list)
     metadata: dict[str, Any] = Field(default_factory=dict)
 
@@ -81,6 +92,7 @@ __all__ = [
     "ArtifactDocument",
     "ArtifactFieldSuggestion",
     "ArtifactSection",
+    "ArtifactUpkeepStatus",
     "FieldPackSuggestion",
     "ProcurementPackage",
 ]

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/router/completion/intake_summary_document_sync.py

@@ -86,6 +86,25 @@ def _has_active_requirement_canvas(runtime_snapshot: dict[str, Any]) -> bool:
     return bool(_latest_requirement_canvas_payload(runtime_snapshot))
 
 
+def _has_current_question_answer(runtime_payload: dict[str, Any]) -> bool:
+    if _coerce_mapping(runtime_payload.get("question_answer")):
+        return True
+    turn_act = _coerce_mapping(runtime_payload.get("turn_act"))
+    return _clean_text(turn_act.get("turn_kind")) == "field_answer"
+
+
+def _is_template_only_canvas(payload: dict[str, Any]) -> bool:
+    canvas_state = _coerce_mapping(payload.get("canvas_state"))
+    artifact_document = _coerce_mapping(payload.get("artifact_document")) or _coerce_mapping(canvas_state.get("artifact_document"))
+    latest_revision = _coerce_mapping(artifact_document.get("latest_revision"))
+    content_framework = _coerce_mapping(payload.get("content_framework"))
+    signals = _coerce_mapping(content_framework.get("signals"))
+    return (
+        signals.get("has_model_content") is False
+        or _clean_text(latest_revision.get("diff")) == "domain_template_projection"
+    )
+
+
 def _with_summary_context(action: dict[str, Any], summary_context: dict[str, Any]) -> dict[str, Any]:
     resolved = dict(action)
     if not summary_context or not _should_attach_summary_context(resolved):
@@ -164,6 +183,7 @@ def should_sync_document_output_to_requirement_canvas(
     completion_provider: str,
     completion_model: str,
     completion_status: str,
+    command: str = "",
 ) -> bool:
     """Return whether a model-authored document output should update Canvas."""
 
@@ -175,6 +195,11 @@ def should_sync_document_output_to_requirement_canvas(
     if not _has_active_requirement_canvas(runtime_snapshot):
         return False
     payload = _coerce_mapping(runtime_snapshot.get("payload"))
+    has_current_question = bool(_coerce_mapping(orchestration_status.get("current_question")))
+    if _clean_text(command) == "send_message" and has_current_question and not _has_current_question_answer(payload):
+        return False
+    if _is_template_only_canvas(_latest_requirement_canvas_payload(runtime_snapshot)):
+        return False
     response_intent = _coerce_mapping(payload.get("response_intent_result"))
     post_generation = _post_generation_result(
         runtime_snapshot=runtime_snapshot,

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/router/completion/intake_summary_events.py

@@ -37,6 +37,13 @@ def _coerce_list(value: Any) -> list[Any]:
     return value if isinstance(value, list) else []
 
 
+def _has_current_question_answer(runtime_payload: dict[str, Any]) -> bool:
+    if _coerce_mapping(runtime_payload.get("question_answer")):
+        return True
+    turn_act = _coerce_mapping(runtime_payload.get("turn_act"))
+    return _clean_text(turn_act.get("turn_kind")) == "field_answer"
+
+
 def _latest_requirement_canvas_payload(runtime_snapshot: dict[str, Any]) -> dict[str, Any]:
     for event in reversed(_coerce_list(runtime_snapshot.get("mode_events"))):
         payload = _coerce_mapping(_coerce_mapping(event).get("payload"))
@@ -233,9 +240,8 @@ def should_sync_requirement_summary_from_model(
     runtime_payload = _coerce_mapping(runtime_snapshot.get("payload"))
     if is_requirement_summary_submission_payload(runtime_payload):
         return False
-    if resolved_command == "send_message" and _coerce_mapping(
-        _coerce_mapping(orchestration_status).get("current_question")
-    ):
+    has_current_question = bool(_coerce_mapping(_coerce_mapping(orchestration_status).get("current_question")))
+    if resolved_command == "send_message" and has_current_question and not _has_current_question_answer(runtime_payload):
         return False
     return bool(_latest_requirement_canvas_payload(runtime_snapshot) or _has_active_requirement_artifact(runtime_snapshot))
 

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/router/payload/analysis_canvas.py

@@ -206,6 +206,10 @@ def _resolve_sourcing_trace(payload: dict[str, Any], session_context: dict[str,
     }
 
 
+def _analysis_artifact_profile(analysis_type: Any) -> str:
+    return "requirement_analysis" if str(analysis_type or "requirement") == "requirement" else "sourcing_analysis"
+
+
 def _resolve_analysis_context(
     *,
     analysis_route: dict[str, Any] | None,
@@ -314,8 +318,16 @@ def build_canvas_analysis_payload(
             export_markdown=True,
             fullscreen=True,
         )
+        document = _coerce_context_dict(payload.get("document"))
         payload = {
             **payload,
+            "document": {
+                **document,
+                "metadata": {
+                    **_coerce_context_dict(document.get("metadata")),
+                    "artifact_profile": _analysis_artifact_profile(context.get("analysis_type")),
+                },
+            },
             "toolbar_actions": toolbar_actions,
             "workspace_capabilities": build_canvas_workspace_capabilities(toolbar_actions=toolbar_actions),
         }

flare_kernel-1.0.2/src/flare_kernel/router/streaming/draft/artifact_upkeep_completion.py

@@ -0,0 +1,119 @@
+"""Streaming adapter for active artifact upkeep completion."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_kernel.router.streaming.event_emitter import StreamingEventEmitter
+from flare_kernel.runtime.artifact_upkeep.orchestrator import run_artifact_upkeep
+
+
+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 " ".join(str(value or "").split()).strip()
+
+
+def _merge_context_patch(existing: Any, incoming: Any) -> dict[str, Any]:
+    merged = dict(_mapping(existing))
+    for key, value in _mapping(incoming).items():
+        if isinstance(value, list):
+            current = merged.get(key) if isinstance(merged.get(key), list) else []
+            merged[key] = [*current, *value]
+        elif isinstance(value, dict) and isinstance(merged.get(key), dict):
+            merged[key] = {**merged[key], **value}
+        else:
+            merged[key] = value
+    return merged
+
+
+def _requirement_context_row(context_patch: dict[str, Any]) -> dict[str, Any]:
+    for row in _sequence(context_patch.get("artifact_context")):
+        item = _mapping(row)
+        if _text(item.get("active_tab")) == "requirement":
+            return item
+    return {}
+
+
+def _analysis_payload(revision_patches: list[dict[str, Any]]) -> dict[str, Any]:
+    for patch in revision_patches:
+        item = _mapping(patch)
+        if _text(item.get("active_tab")) == "analysis":
+            return _mapping(item.get("projection_payload"))
+    return {}
+
+
+def attach_artifact_upkeep_completion(
+    *,
+    runtime_snapshot: dict[str, Any],
+    orchestration_status: dict[str, Any],
+    raw_message: str,
+    assistant_message: str,
+    source_turn_id: str,
+    visible_reply_policy: dict[str, Any],
+    requirement_mode_key: str,
+) -> dict[str, Any]:
+    """Attach upkeep result to backend-owned runtime projections."""
+
+    result = run_artifact_upkeep(
+        runtime_snapshot=runtime_snapshot,
+        user_message=raw_message,
+        assistant_message=assistant_message,
+        source_turn_id=source_turn_id,
+        visible_reply_policy=visible_reply_policy,
+        requirement_mode_key=requirement_mode_key,
+    )
+    if result.get("applied") is not True:
+        return result
+
+    runtime_payload = _mapping(runtime_snapshot.get("payload"))
+    context_patch = _mapping(result.get("context_patch"))
+    analysis_payload = _analysis_payload(_sequence(result.get("revision_patches")))
+    requirement_context = _requirement_context_row(context_patch)
+    if requirement_context:
+        runtime_payload = {**runtime_payload, "active_artifact_context": requirement_context}
+    if analysis_payload:
+        orchestration_status["canvas_analysis_payload"] = analysis_payload
+        runtime_payload = {
+            **runtime_payload,
+            "canvas_analysis_payload": analysis_payload,
+            "analysis_payload": analysis_payload,
+        }
+    runtime_payload = {
+        **runtime_payload,
+        "artifact_upkeep_result": result,
+        "context_patch": _merge_context_patch(runtime_payload.get("context_patch"), context_patch),
+    }
+    runtime_snapshot["payload"] = runtime_payload
+    orchestration_status["artifact_upkeep_result"] = result
+    orchestration_status["artifact_upkeep_plan"] = result.get("update_plan")
+    return result
+
+
+def build_artifact_upkeep_events(
+    *,
+    result: dict[str, Any],
+    emitter: StreamingEventEmitter,
+) -> list[str]:
+    """Build canvas/analysis stream events from upkeep revision patches."""
+
+    events: list[str] = []
+    for patch in _sequence(_mapping(result).get("revision_patches")):
+        payload = _mapping(_mapping(patch).get("projection_payload"))
+        if not payload:
+            continue
+        active_tab = _text(_mapping(patch).get("active_tab"))
+        if active_tab == "requirement":
+            events.append(emitter.emit_event("canvas_state", payload))
+        elif active_tab == "analysis":
+            events.append(emitter.emit_event("analysis_payload", payload))
+    return events
+
+
+__all__ = ["attach_artifact_upkeep_completion", "build_artifact_upkeep_events"]

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/router/streaming/draft/context_patch_completion.py

@@ -142,6 +142,7 @@ def resolve_context_patch(
     orchestration_status: dict[str, Any],
     command: str,
     artifact_write_allowed: bool = True,
+    artifact_upkeep_context_patch: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     payload = runtime_snapshot.get("payload") if isinstance(runtime_snapshot.get("payload"), dict) else {}
     context_patch = payload.get("context_patch") if isinstance(payload.get("context_patch"), dict) else {}
@@ -176,6 +177,7 @@ def resolve_context_patch(
         context_patch,
         artifact_patch,
         analysis_patch,
+        artifact_upkeep_context_patch or {},
     )
 
 

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/router/streaming/draft/post_completion.py

@@ -21,36 +21,25 @@ from flare_kernel.router.completion.intake_summary_events import (
 from flare_kernel.router.completion.intake_summary_document_sync import (
     should_sync_document_output_to_requirement_canvas,
 )
+from flare_kernel.router.streaming.draft.artifact_upkeep_completion import attach_artifact_upkeep_completion, build_artifact_upkeep_events
 from flare_kernel.router.streaming.draft.completion import DraftCompletionArtifacts
 from flare_kernel.router.streaming.draft.finalize import (
     apply_draft_content_policy,
     iter_canonical_finalize_events,
 )
-from flare_kernel.router.streaming.draft.context_patch_completion import (
-    attach_canvas_summary_context_patch,
-    resolve_context_patch,
-)
+from flare_kernel.router.streaming.draft.context_patch_completion import attach_canvas_summary_context_patch, resolve_context_patch
 from flare_kernel.router.streaming.draft.patch_preview_events import attach_patch_preview_status
 from flare_kernel.router.streaming.draft.post_generation_completion import (
     attach_post_generation_completion,
     post_generated_artifact_markdown,
     post_generated_timeline_text,
 )
-from flare_kernel.router.streaming.draft.post_completion_canvas_policy import (
-    has_structured_reasoning_canvas_artifact,
-    should_project_requirement_canvas,
-)
+from flare_kernel.router.streaming.draft.post_completion_canvas_policy import has_structured_reasoning_canvas_artifact, should_project_requirement_canvas
 from flare_kernel.router.streaming.draft.reconciliation_completion import (
     attach_reconciliation_completion,
 )
-from flare_kernel.router.streaming.draft.post_completion_summary_actions import (
-    consume_confirm_send_actions,
-    is_requirement_summary_submission_turn,
-)
-from flare_kernel.router.streaming.draft.turn_disposition_completion import (
-    artifact_write_allowed,
-    attach_turn_disposition,
-)
+from flare_kernel.router.streaming.draft.post_completion_summary_actions import consume_confirm_send_actions, is_requirement_summary_submission_turn
+from flare_kernel.router.streaming.draft.turn_disposition_completion import artifact_write_allowed, attach_turn_disposition
 from flare_kernel.router.streaming.event_emitter import StreamingEventEmitter
 from flare_kernel.runtime.orchestration.mode.intake_summary_artifact import (
     build_model_authored_requirement_summary_event,
@@ -183,6 +172,15 @@ def build_draft_post_completion_events(
         content_text=artifact_content_text,
         runtime_snapshot=runtime_snapshot,
     )
+    artifact_upkeep_result = attach_artifact_upkeep_completion(
+        runtime_snapshot=runtime_snapshot,
+        orchestration_status=orchestration_status,
+        raw_message=raw_message,
+        assistant_message=visible_content_text,
+        source_turn_id=request_id,
+        visible_reply_policy=turn_disposition,
+        requirement_mode_key=resolved_mode,
+    )
     sync_session_intent_stage_fn(
         orchestration_status=orchestration_status,
         signal=escalation_signal,
@@ -240,12 +238,14 @@ def build_draft_post_completion_events(
         completion_provider=artifacts.completion.provider,
         completion_model=artifacts.completion.model,
         completion_status=artifacts.completion.status,
+        command=effective_command,
     )
     model_summary_sync = document_output_sync or should_sync_requirement_summary_from_model(
         runtime_snapshot=runtime_snapshot,
         content_text=artifacts.content_text,
         completion_status=artifacts.completion.status,
         command=effective_command,
+        orchestration_status=orchestration_status,
     )
     memory_runtime_event = {"trace_id": trace_id, **runtime_snapshot["memory_runtime"], **artifacts.memory_record}
     events.append(emitter.emit_event("memory_runtime", memory_runtime_event))
@@ -255,6 +255,7 @@ def build_draft_post_completion_events(
         events.append(emitter.emit_event("canvas_state", reconciliation_result["canvas_state"]))
     if isinstance(reconciliation_result.get("analysis_payload"), dict):
         events.append(emitter.emit_event("analysis_payload", reconciliation_result["analysis_payload"]))
+    events.extend(build_artifact_upkeep_events(result=artifact_upkeep_result, emitter=emitter))
     if summary_submission_turn and allow_artifact_write:
         summary_event = build_model_authored_requirement_summary_event(
             runtime_snapshot=runtime_snapshot,
@@ -340,6 +341,7 @@ def build_draft_post_completion_events(
             orchestration_status=orchestration_status,
             command=effective_command,
             artifact_write_allowed=allow_artifact_write,
+            artifact_upkeep_context_patch=artifact_upkeep_result.get("context_patch") if not allow_artifact_write else {},
         ),
         emitter=emitter,
     )

{flare_kernel-1.0.1 → flare_kernel-1.0.2}/src/flare_kernel/runtime/artifact_edit/semantic_map_refresh.py

@@ -41,6 +41,7 @@ def refresh_requirement_semantic_map(
         canvas_state=canvas_state,
         content=_refresh_content(document, revision),
         semantic_template=semantic_template,
+        knowledge_sources=sequence(existing.get("node_candidates")),
     )
     if not semantic_map:
         return existing

flare_kernel-1.0.2/src/flare_kernel/runtime/artifact_quality/__init__.py

@@ -0,0 +1,5 @@
+"""Artifact content quality helpers."""
+
+from flare_kernel.runtime.artifact_quality.requirement_markdown import sanitize_requirement_markdown
+
+__all__ = ["sanitize_requirement_markdown"]

flare_kernel-1.0.2/src/flare_kernel/runtime/artifact_quality/requirement_markdown.py

@@ -0,0 +1,110 @@
+"""Requirement markdown quality guardrails.
+
+Pure text cleanup only. This module does not infer fields, call providers, or
+own workflow decisions.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+_LIST_ITEM_RE = re.compile(r"^\s*(?:[-*]\s+|\d+[.、)]\s+)")
+_BLOCKED_HEADING_PATTERNS = (
+    "待你确认",
+    "需要你确认",
+    "待确认的关键点",
+    "需要确认的信息",
+    "建议你先确认",
+    "建议先确认",
+    "请确认",
+    "关键问题",
+)
+_BLOCKED_PARAGRAPH_PATTERNS = (
+    "为了把这份草案进一步",
+    "为了把这个草案进一步",
+    "建议你先确认",
+    "建议先确认",
+    "请先确认",
+)
+
+
+def _text(value: Any) -> str:
+    return str(value or "").replace("\r\n", "\n").strip()
+
+
+def _heading_level(line: str) -> int:
+    stripped = line.strip()
+    if not stripped.startswith("#"):
+        return 0
+    marker = stripped.split(" ", 1)[0]
+    return len(marker) if set(marker) == {"#"} else 0
+
+
+def _heading_text(line: str) -> str:
+    return re.sub(r"^#+\s*", "", line.strip()).strip()
+
+
+def _is_blocked_heading(line: str) -> bool:
+    heading = _heading_text(line)
+    return bool(heading and any(pattern in heading for pattern in _BLOCKED_HEADING_PATTERNS))
+
+
+def _is_blocked_paragraph(line: str) -> bool:
+    stripped = line.strip()
+    return any(pattern in stripped for pattern in _BLOCKED_PARAGRAPH_PATTERNS)
+
+
+def _is_plain_blocked_heading(line: str) -> bool:
+    stripped = line.strip()
+    if not stripped or len(stripped) > 48 or _LIST_ITEM_RE.match(stripped) or "|" in stripped:
+        return False
+    return any(pattern in stripped for pattern in _BLOCKED_HEADING_PATTERNS)
+
+
+def _trim_blank_edges(lines: list[str]) -> list[str]:
+    start = 0
+    end = len(lines)
+    while start < end and not lines[start].strip():
+        start += 1
+    while end > start and not lines[end - 1].strip():
+        end -= 1
+    return lines[start:end]
+
+
+def sanitize_requirement_markdown(content: str) -> str:
+    """Remove conversational confirmation/question sections from artifact markdown."""
+
+    source = _text(content)
+    if not source:
+        return ""
+    result: list[str] = []
+    skip_level = 0
+    skip_plain_block = False
+    skip_list_after_paragraph = False
+    for line in source.split("\n"):
+        level = _heading_level(line)
+        if skip_level and level and level <= skip_level:
+            skip_level = 0
+        if skip_plain_block and level:
+            skip_plain_block = False
+        if skip_list_after_paragraph and level:
+            skip_list_after_paragraph = False
+        if skip_list_after_paragraph and (not line.strip() or _LIST_ITEM_RE.match(line.strip())):
+            continue
+        skip_list_after_paragraph = False
+        if skip_level:
+            continue
+        if skip_plain_block:
+            continue
+        if level and _is_blocked_heading(line):
+            skip_level = level
+            continue
+        if not level and _is_plain_blocked_heading(line):
+            skip_plain_block = True
+            continue
+        if not level and _is_blocked_paragraph(line):
+            skip_list_after_paragraph = True
+            continue
+        result.append(line.rstrip())
+    return "\n".join(_trim_blank_edges(result)).strip()

flare_kernel-1.0.2/src/flare_kernel/runtime/artifact_registry/__init__.py

@@ -0,0 +1,16 @@
+"""Active artifact registry runtime package."""
+
+from .contracts import (
+    ACTIVE_ARTIFACT_SNAPSHOT_SCHEMA_VERSION,
+    active_artifact_snapshot,
+    has_active_artifact_identity,
+)
+from .resolver import resolve_active_artifact_snapshot, resolve_active_artifact_snapshots
+
+__all__ = [
+    "ACTIVE_ARTIFACT_SNAPSHOT_SCHEMA_VERSION",
+    "active_artifact_snapshot",
+    "has_active_artifact_identity",
+    "resolve_active_artifact_snapshot",
+    "resolve_active_artifact_snapshots",
+]

flare_kernel-1.0.2/src/flare_kernel/runtime/artifact_registry/contracts.py

@@ -0,0 +1,68 @@
+"""Active artifact registry contract helpers.
+
+Contract-only first slice. Resolver behavior will be added separately.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+ACTIVE_ARTIFACT_SNAPSHOT_SCHEMA_VERSION = "active.artifact.snapshot.v1"
+
+
+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 " ".join(str(value or "").split()).strip()
+
+
+def compact(payload: dict[str, Any]) -> dict[str, Any]:
+    return {key: value for key, value in payload.items() if value not in ("", None, [], {})}
+
+
+def active_artifact_snapshot(
+    *,
+    artifact_id: str,
+    artifact_type: str,
+    active_tab: str,
+    revision_id: str = "",
+    content: str = "",
+    content_format: str = "markdown",
+    source: str = "",
+    dependencies: list[Any] | None = None,
+) -> dict[str, Any]:
+    """Build a backend-resolved active artifact snapshot contract."""
+
+    return {
+        "schema_version": ACTIVE_ARTIFACT_SNAPSHOT_SCHEMA_VERSION,
+        "artifact_id": text(artifact_id),
+        "artifact_type": text(artifact_type),
+        "active_tab": text(active_tab),
+        "revision_id": text(revision_id),
+        "content": str(content or "").strip(),
+        "content_format": text(content_format) or "markdown",
+        "source": text(source),
+        "dependencies": [dict(item) if isinstance(item, dict) else text(item) for item in sequence(dependencies)],
+    }
+
+
+def has_active_artifact_identity(snapshot: dict[str, Any] | None) -> bool:
+    payload = mapping(snapshot)
+    return bool(text(payload.get("artifact_id")) and text(payload.get("artifact_type")))
+
+
+__all__ = [
+    "ACTIVE_ARTIFACT_SNAPSHOT_SCHEMA_VERSION",
+    "active_artifact_snapshot",
+    "compact",
+    "has_active_artifact_identity",
+    "mapping",
+    "sequence",
+    "text",
+]