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

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

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

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

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

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

@@ -7,6 +7,9 @@ from flare_kernel.contracts.context import (
     ContextEvidenceItem,
     ContextSourcingResult,
     ContextTurnItem,
+    ContextWriteDeclaration,
+    ContextWriteRegistry,
+    context_contract_field_names,
     create_empty_context,
 )
 from flare_kernel.contracts.auth_contract import (
@@ -20,6 +23,7 @@ from flare_kernel.contracts.artifact_document import (
     ArtifactDocument,
     ArtifactFieldSuggestion,
     ArtifactSection,
+    ArtifactUpkeepStatus,
     FieldPackSuggestion,
     ProcurementPackage,
 )
@@ -114,6 +118,7 @@ __all__ = [
     "ArtifactDocument",
     "ArtifactFieldSuggestion",
     "ArtifactSection",
+    "ArtifactUpkeepStatus",
     "FieldPackSuggestion",
     "ProcurementPackage",
     "AnalysisRouteDecision",
@@ -144,6 +149,9 @@ __all__ = [
     "ContextEvidenceItem",
     "ContextSourcingResult",
     "ContextTurnItem",
+    "ContextWriteDeclaration",
+    "ContextWriteRegistry",
+    "context_contract_field_names",
     "create_empty_context",
     "Mode",
     "ModeHandler",

{flare_kernel-1.0.0 → 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 = ""
@@ -72,6 +82,8 @@ class ArtifactDocument(BaseModel):
     sections: list[ArtifactSection] = Field(default_factory=list)
     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)
 
@@ -80,6 +92,7 @@ __all__ = [
     "ArtifactDocument",
     "ArtifactFieldSuggestion",
     "ArtifactSection",
+    "ArtifactUpkeepStatus",
     "FieldPackSuggestion",
     "ProcurementPackage",
 ]

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/contracts/context.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 
 from typing import Any
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 
 class ContextEvidenceItem(BaseModel):
@@ -93,3 +93,77 @@ class ContextContract(BaseModel):
 
 def create_empty_context() -> ContextContract:
     return ContextContract()
+
+
+def _clean_text(value: Any) -> str:
+    return " ".join(str(value or "").split()).strip()
+
+
+def context_contract_field_names() -> set[str]:
+    fields = getattr(ContextContract, "model_fields", None) or getattr(ContextContract, "__fields__", {})
+    return set(fields.keys())
+
+
+def _normalize_context_fields(value: list[str]) -> list[str]:
+    allowed = context_contract_field_names()
+    normalized: list[str] = []
+    seen: set[str] = set()
+    unknown: list[str] = []
+    for item in value or []:
+        field = _clean_text(item)
+        if not field:
+            continue
+        if field not in allowed:
+            unknown.append(field)
+            continue
+        if field not in seen:
+            normalized.append(field)
+            seen.add(field)
+    if unknown:
+        raise ValueError(f"unknown context fields: {', '.join(unknown)}")
+    return normalized
+
+
+class ContextWriteDeclaration(BaseModel):
+    contract_version: str = "flare.context_write_declaration.v1"
+    capability_key: str
+    reads_context_fields: list[str] = Field(default_factory=list)
+    writes_context_fields: list[str] = Field(default_factory=list)
+    normalized_result_contract: str = ""
+    context_patch_builder: str = ""
+    readiness_policy: str = ""
+    projection_scopes: list[str] = Field(default_factory=list)
+    rollback_point: str = ""
+    targeted_tests: list[str] = Field(default_factory=list)
+    metadata: dict[str, Any] = Field(default_factory=dict)
+
+    @field_validator("capability_key")
+    @classmethod
+    def require_capability_key(cls, value: str) -> str:
+        text = _clean_text(value)
+        if not text:
+            raise ValueError("capability_key is required")
+        return text
+
+    @field_validator("reads_context_fields", "writes_context_fields")
+    @classmethod
+    def validate_context_fields(cls, value: list[str]) -> list[str]:
+        return _normalize_context_fields(value)
+
+
+class ContextWriteRegistry(BaseModel):
+    contract_version: str = "flare.context_write_registry.v1"
+    declarations: list[ContextWriteDeclaration] = Field(default_factory=list)
+
+    @model_validator(mode="after")
+    def require_unique_capabilities(self) -> "ContextWriteRegistry":
+        seen: set[str] = set()
+        duplicates: list[str] = []
+        for declaration in self.declarations:
+            key = declaration.capability_key
+            if key in seen:
+                duplicates.append(key)
+            seen.add(key)
+        if duplicates:
+            raise ValueError(f"duplicate capability declarations: {', '.join(duplicates)}")
+        return self

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/contracts/kernel_contract.py

@@ -239,10 +239,13 @@ class ProjectSourceRecord(BaseModel):
     filename: str
     mime_type: str = ""
     size: int | None = None
-    status: Literal["uploaded", "parsing", "chunked", "embedded", "indexed", "ready", "failed"] = "uploaded"
+    status: Literal["uploaded", "parsing", "chunked", "embedded", "indexed", "ready", "failed", "duplicate"] = "uploaded"
     error_code: str | None = None
     error_message: str = ""
+    content_hash: str = ""
+    duplicate_of_source_id: str | None = None
     document_understanding: dict[str, Any] | None = None
+    document_profile: dict[str, Any] | None = None
     created_at: str
     updated_at: str
     persisted_to_project: bool = True

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/contracts/session_contract.py

@@ -85,6 +85,7 @@ class SessionMessageRecord(BaseModel):
     analysis_payload: dict[str, Any] | None = None
     context_usage: dict[str, Any] | None = None
     provider_trace: dict[str, Any] | None = None
+    context_activity: dict[str, Any] | None = None
     context_authority: dict[str, Any] | None = None
     workflow_projection: dict[str, Any] | None = None
     plan_payload: dict[str, Any] | None = None
@@ -146,6 +147,7 @@ class SessionAppendExchangeRequest(BaseModel):
     analysis_payload: dict[str, Any] | None = None
     context_usage: dict[str, Any] | None = None
     provider_trace: dict[str, Any] | None = None
+    context_activity: dict[str, Any] | None = None
     context_authority: dict[str, Any] | None = None
     workflow_projection: dict[str, Any] | None = None
     plan_payload: dict[str, Any] | None = None

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/router/api/session.py

@@ -314,6 +314,7 @@ async def append_chat_session_exchange(
         analysis_payload=append_fields["analysis_payload"],
         context_usage=req.context_usage,
         provider_trace=req.provider_trace,
+        context_activity=req.context_activity,
         context_authority=req.context_authority,
         workflow_projection=req.workflow_projection,
         plan_payload=append_fields["plan_payload"],

flare_kernel-1.0.2/src/flare_kernel/router/canonical/context_activity.py

@@ -0,0 +1,132 @@
+"""Canonical context activity projection for frontend animation.
+
+DOC HELPER — context_activity.v1 is backend-owned display metadata. It only
+summarizes runtime/session context into a stable projection; it does not mutate
+context, trigger compaction, or own workflow state transitions.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _as_mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _as_list(value: Any) -> list[Any]:
+    return value if isinstance(value, list) else []
+
+
+def _count_list(value: Any) -> int:
+    return len(value) if isinstance(value, list) else 0
+
+
+def _coerce_int(value: Any) -> int:
+    try:
+        parsed = int(float(value))
+    except (TypeError, ValueError):
+        return 0
+    return max(0, parsed)
+
+
+def _token_counts(runtime: dict[str, Any]) -> tuple[int, int, float]:
+    usage = _as_mapping(runtime.get("context_usage"))
+    token_estimate = _as_mapping(usage.get("token_estimate"))
+    budget_tokens = _as_mapping(usage.get("budget_tokens"))
+    token_used = _coerce_int(token_estimate.get("total_prompt_tokens_estimate"))
+    token_limit = _coerce_int(budget_tokens.get("total_tokens"))
+    if token_limit <= 0:
+        return token_used, token_limit, 0.0
+    return token_used, token_limit, round(min(1.0, token_used / token_limit), 2)
+
+
+def _source_count(runtime: dict[str, Any]) -> int:
+    payload = _as_mapping(runtime.get("payload"))
+    data_ingestion = _as_mapping(runtime.get("data_ingestion"))
+    ref_count = max(
+        _count_list(payload.get("knowledge_refs")),
+        _count_list(payload.get("context_refs")),
+        _count_list(payload.get("source_ids")),
+    )
+    return max(_coerce_int(data_ingestion.get("source_count")), ref_count)
+
+
+def _has_canvas_activity(runtime: dict[str, Any]) -> bool:
+    payload = _as_mapping(runtime.get("payload"))
+    preflight = _as_mapping(runtime.get("artifact_edit_preflight")) or _as_mapping(payload.get("artifact_edit_preflight"))
+    return bool(preflight or _as_mapping(payload.get("active_artifact_context")))
+
+
+def _context_counts(context: dict[str, Any]) -> dict[str, int]:
+    return {
+        "facts": _count_list(context.get("facts")),
+        "unknowns": _count_list(context.get("unknowns")),
+        "evidence": _count_list(context.get("evidence")),
+        "turns": _count_list(context.get("turns")),
+        "artifact_context": _count_list(context.get("artifact_context")),
+    }
+
+
+def _resolve_state(*, source_count: int, canvas_active: bool, counters: dict[str, int]) -> tuple[str, str, str]:
+    if canvas_active:
+        return "syncing_canvas", "canvas_sync", "running"
+    if source_count > 0:
+        return "ingesting_sources", "source_ingestion", "running"
+    if counters["facts"] or counters["unknowns"] or counters["evidence"] or counters["turns"]:
+        return "collecting", "chat_turn", "running"
+    return "idle", "context", "completed"
+
+
+def _headline_params(*, state: str, source_count: int, counters: dict[str, int]) -> dict[str, int]:
+    if state == "ingesting_sources":
+        return {"source_count": source_count}
+    if state == "collecting":
+        return {"facts": counters["facts"], "unknowns": counters["unknowns"]}
+    return {}
+
+
+def _detail_params(counters: dict[str, int]) -> dict[str, int]:
+    return {
+        "facts": counters["facts"],
+        "unknowns": counters["unknowns"],
+        "evidence": counters["evidence"],
+        "artifact_context": counters["artifact_context"],
+    }
+
+
+def build_context_activity_projection(runtime_snapshot: dict[str, Any] | None) -> dict[str, Any]:
+    """Return backend-owned context activity for UI projection."""
+
+    runtime = _as_mapping(runtime_snapshot)
+    context = _as_mapping(runtime.get("session_context"))
+    source_count = _source_count(runtime)
+    token_used, token_limit, progress = _token_counts(runtime)
+    counters = {
+        "sources_total": source_count,
+        **_context_counts(context),
+        "token_used": token_used,
+        "token_limit": token_limit,
+    }
+    state, phase, status = _resolve_state(
+        source_count=source_count,
+        canvas_active=_has_canvas_activity(runtime),
+        counters=counters,
+    )
+    return {
+        "schema_version": "context_activity.v1",
+        "owner": "backend",
+        "frontend_policy": "projection_only",
+        "state": state,
+        "phase": phase,
+        "status": status,
+        "progress": progress,
+        "headline_key": f"context_activity.{state}.headline",
+        "headline_params": _headline_params(state=state, source_count=source_count, counters=counters),
+        "detail_key": "context_activity.counts.detail",
+        "detail_params": _detail_params(counters),
+        "counters": counters,
+    }
+
+
+__all__ = ["build_context_activity_projection"]

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/router/canonical/payload.py

@@ -17,6 +17,7 @@ from flare_kernel.router.canonical.contract_support import (
     resolve_canvas_analysis_payload,
 )
 from flare_kernel.router.canonical.composer_ui import build_composer_ui_projection
+from flare_kernel.router.canonical.context_activity import build_context_activity_projection
 from flare_kernel.router.canonical.context_authority import build_context_authority_projection
 from flare_kernel.router.canonical.mode_projection import resolve_round_end_mode_projection
 from flare_kernel.router.canonical.projection import resolve_canonical_next_actions
@@ -285,6 +286,7 @@ def build_canonical_payload(
             "type": "normal" if str(assistant_reply_text or "").strip() else "system_notice",
             "is_placeholder": provider_status == "placeholder",
         },
+        "context_activity": build_context_activity_projection(runtime_snapshot),
         "context_authority": build_context_authority_projection(runtime_snapshot),
         "primary_flow": {
             "mode": {

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/router/completion/analysis_policy.py

@@ -154,6 +154,23 @@ def _apply_overwrite_guard(
     return False
 
 
+def _sync_post_generation_markdown(
+    *,
+    orchestration_status: dict[str, Any],
+    runtime_snapshot: dict[str, Any] | None,
+    canvas_analysis_payload: dict[str, Any] | None,
+) -> None:
+    markdown = _text(_mapping(canvas_analysis_payload).get("markdown"))
+    post_generation = _mapping(orchestration_status.get("post_generation_result"))
+    if not markdown or not post_generation:
+        return
+    next_result = {**post_generation, "artifact_markdown": markdown}
+    orchestration_status["post_generation_result"] = next_result
+    if isinstance(runtime_snapshot, dict):
+        payload = _runtime_payload(runtime_snapshot)
+        runtime_snapshot["payload"] = {**payload, "post_generation_result": next_result}
+
+
 def apply_analysis_completion_policy(
     *,
     orchestration_status: dict[str, Any],
@@ -202,6 +219,11 @@ def apply_analysis_completion_policy(
         return
     if canvas_analysis_payload:
         orchestration_status["canvas_analysis_payload"] = canvas_analysis_payload
+        _sync_post_generation_markdown(
+            orchestration_status=orchestration_status,
+            runtime_snapshot=runtime_snapshot,
+            canvas_analysis_payload=canvas_analysis_payload,
+        )
     if isinstance(slot_patches, list):
         orchestration_status["analysis_slot_patches"] = slot_patches
 

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

@@ -10,6 +10,7 @@ from flare_kernel.router.completion.artifact_action_contract import (
 
 _SUMMARY_CONTEXT_ACTION_KEYS = frozenset({"confirm_plan", "generate_analysis"})
 _SUMMARY_CONTEXT_COMMANDS = frozenset({"generate_analysis"})
+_DOCUMENT_OUTPUT_INTENTS = frozenset({"document_template_output", "document_draft_output"})
 
 
 def _clean_text(value: Any) -> str:
@@ -54,6 +55,56 @@ def _summary_context_from_payload(payload: dict[str, Any]) -> dict[str, Any]:
     }
 
 
+def _latest_requirement_canvas_payload(runtime_snapshot: dict[str, Any]) -> dict[str, Any]:
+    mode_events = runtime_snapshot.get("mode_events")
+    for event in reversed(mode_events if isinstance(mode_events, list) else []):
+        payload = _coerce_mapping(_coerce_mapping(event).get("payload"))
+        if _clean_text(payload.get("mode_key")) == "requirement_intake":
+            return payload
+    return {}
+
+
+def _post_generation_result(
+    *,
+    runtime_snapshot: dict[str, Any],
+    orchestration_status: dict[str, Any],
+) -> dict[str, Any]:
+    result = orchestration_status.get("post_generation_result")
+    if isinstance(result, dict):
+        return result
+    payload = _coerce_mapping(runtime_snapshot.get("payload"))
+    return _coerce_mapping(payload.get("post_generation_result"))
+
+
+def _has_active_requirement_canvas(runtime_snapshot: dict[str, Any]) -> bool:
+    payload = _coerce_mapping(runtime_snapshot.get("payload"))
+    active = payload.get("active_artifact_context")
+    if _coerce_mapping(active):
+        return True
+    if isinstance(active, list) and active:
+        return True
+    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):
@@ -132,18 +183,35 @@ 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."""
 
-    _ = (
-        runtime_snapshot,
-        orchestration_status,
-        content_text,
-        completion_provider,
-        completion_model,
-        completion_status,
+    _ = (completion_provider, completion_model)
+    if _clean_text(runtime_snapshot.get("mode_key")) != "requirement_intake":
+        return False
+    if _clean_text(completion_status) != "ok" or not _clean_text(content_text):
+        return False
+    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,
+        orchestration_status=orchestration_status,
     )
-    return False
+    if not _clean_text(post_generation.get("artifact_markdown")):
+        return False
+    if _clean_text(response_intent.get("response_intent")) not in _DOCUMENT_OUTPUT_INTENTS:
+        return False
+    descriptor = _coerce_mapping(post_generation.get("artifact_descriptor"))
+    target_tab = _clean_text(descriptor.get("target_tab") or response_intent.get("target_tab"))
+    return target_tab in {"", "requirement"}
 
 
 __all__ = [

{flare_kernel-1.0.0 → 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"))
@@ -212,6 +219,7 @@ def should_sync_requirement_summary_from_model(
     content_text: str,
     completion_status: str,
     command: str = "",
+    orchestration_status: dict[str, Any] | None = None,
 ) -> bool:
     """Return whether model output should also be沉淀到 requirement Artifact."""
 
@@ -232,6 +240,9 @@ 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
+    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))
 
 
@@ -255,6 +266,7 @@ def with_model_authored_requirement_summary_event(
         content_text=content_text,
         completion_status=completion_status,
         command=command,
+        orchestration_status=orchestration_status,
     ):
         return mode_events
     summary_event = build_model_authored_requirement_summary_event(

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/router/fast_gate.py

@@ -44,9 +44,12 @@ def normalize_fast_gate_policy(value: Any) -> dict[str, Any]:
     policy = _as_mapping(value)
     deny_terms = _as_text_tuple(policy.get("deny_terms"))
     allow_terms = _as_text_tuple(policy.get("allow_terms"))
+    strong_allow_terms = _as_text_tuple(policy.get("strong_allow_terms"))
     normalized: dict[str, list[str]] = {}
     if allow_terms:
         normalized["allow_terms"] = list(allow_terms)
+    if strong_allow_terms:
+        normalized["strong_allow_terms"] = list(strong_allow_terms)
     if deny_terms:
         normalized["deny_terms"] = list(deny_terms)
     return normalized
@@ -66,7 +69,9 @@ def _matches_denied_boundary(message: str, policy: dict[str, Any]) -> bool:
         return False
     deny_terms = _as_text_tuple(policy.get("deny_terms"))
     allow_terms = _as_text_tuple(policy.get("allow_terms"))
-    return _contains_any(normalized, deny_terms) and not _contains_any(normalized, allow_terms)
+    strong_allow_terms = _as_text_tuple(policy.get("strong_allow_terms"))
+    effective_allow_terms = strong_allow_terms or allow_terms
+    return _contains_any(normalized, deny_terms) and not _contains_any(normalized, effective_allow_terms)
 
 
 def resolve_fast_gate(*, message: str, payload: dict[str, Any] | None = None) -> FastGateDecision:

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/router/kernel_constants/intent.py

@@ -4,9 +4,9 @@ from __future__ import annotations
 
 
 _NEUTRAL_INTENT_KEYWORDS = {
-    "requirement_intake": ("requirement_intake",),
+    "requirement_intake": ("requirement_intake", "确认关键字段", "关键字段"),
     "intelligent_sourcing": ("intelligent_sourcing",),
-    "analysis_mode": ("analysis_mode",),
+    "analysis_mode": ("analysis_mode", "需求分析", "做需求分析"),
 }
 
 INTENT_KEYWORDS = {
@@ -29,6 +29,7 @@ REQUIREMENT_ENTRY_EXPLICIT_PHRASES = (
     "请先帮我梳理",
     "请帮我梳理",
     "请梳理",
+    "我想梳理",
     "帮我梳理一下",
     "帮我梳理需求",
     "帮我做需求梳理",

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/router/kernel_constants/patch.py

@@ -1,8 +1,9 @@
 """Patch scope constants for flare.v1 contract emission.
 
 DOC HELPER — OBJ-09 patch authority allowlist.
-`context_authority` is an authoritative backend scope; consumers may project it
-but must not synthesize equivalent frontend authority.
+`context_authority` and `context_activity` are authoritative backend scopes;
+consumers may project them but must not synthesize equivalent frontend
+authority.
 """
 
 from __future__ import annotations
@@ -10,6 +11,7 @@ from __future__ import annotations
 PATCH_SCOPES_AUTHORITATIVE = {
     "session",
     "assistant_reply",
+    "context_activity",
     "context_authority",
     "workflow_projection",
     "primary_flow",

{flare_kernel-1.0.0 → flare_kernel-1.0.2}/src/flare_kernel/router/kernel_endpoint_handlers/turn.py

@@ -61,6 +61,26 @@ def _supports_keyword_flag(callable_obj, name: str) -> bool:
     )
 
 
+def _has_refs(value: Any) -> bool:
+    return isinstance(value, list) and any(bool(item) for item in value)
+
+
+def _payload_mapping(req: KernelRequest) -> dict[str, Any]:
+    return req.payload if isinstance(req.payload, dict) else {}
+
+
+def _stream_requires_context_io(req: KernelRequest) -> bool:
+    payload = _payload_mapping(req)
+    source_grounding = payload.get("source_grounding") if isinstance(payload.get("source_grounding"), dict) else {}
+    return (
+        _has_refs(req.context_refs)
+        or _has_refs(req.knowledge_refs)
+        or _has_refs(payload.get("context_refs"))
+        or _has_refs(payload.get("knowledge_refs"))
+        or source_grounding.get("active") is True
+    )
+
+
 async def handle_kernel_run(
     req: KernelRequest,
     *,
@@ -179,7 +199,7 @@ async def handle_kernel_stream(
     if _supports_keyword_flag(prepare_kernel_turn_context_fn, "run_structured_reasoning"):
         prepare_kwargs["run_structured_reasoning"] = False
     if _supports_keyword_flag(prepare_kernel_turn_context_fn, "run_context_io"):
-        prepare_kwargs["run_context_io"] = False
+        prepare_kwargs["run_context_io"] = _stream_requires_context_io(effective_req)
     turn_context = await prepare_kernel_turn_context_fn(effective_req, **prepare_kwargs)
     turn = unpack_kernel_turn_context_fn(turn_context)
     return await build_kernel_stream_response_fn(