flare-kernel 0.2.8__tar.gz → 0.2.10__tar.gz

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/PKG-INFO

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

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/pyproject.toml

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

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/contracts/kernel_contract.py

@@ -44,7 +44,7 @@ class KernelRequest(BaseModel):
     run_id: str | None = None
     tenant_id: str = "default"
     instance_id: str = "default"
-    domain_pack_version: str = "v1"
+    domain_pack_version: str = "default"
     session_id: str | None = None
     last_turn_id: str | None = None
     command: str | None = None

flare_kernel-0.2.10/src/flare_kernel/router/canonical/composer_ui.py

@@ -0,0 +1,126 @@
+"""Backend-owned composer UI projection helpers.
+
+The frontend renders this projection; it must not infer chooser visibility,
+recommendation visibility, or dismissal semantics from local keys.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def _trim(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _is_requirement_intake_mode(value: str) -> bool:
+    return _trim(value) == "requirement_intake"
+
+
+def _clean_list(values: list[Any]) -> list[str]:
+    return [_trim(item) for item in values if _trim(item)]
+
+
+def _next_action_keys(next_actions: list[Any]) -> list[str]:
+    keys: list[str] = []
+    for item in next_actions:
+        if not isinstance(item, dict):
+            continue
+        key = _trim(item.get("action_key") or item.get("type"))
+        if key:
+            keys.append(key)
+    return keys
+
+
+def _resolve_chooser_visibility(
+    *,
+    activated_mode: str,
+    stage_key: str,
+    status_key: str,
+    current_question: dict[str, Any] | None,
+    required_missing: list[Any],
+) -> tuple[str, bool]:
+    if _trim(activated_mode) == "auto":
+        return "none", False
+    if stage_key == "requirement_intake" and isinstance(current_question, dict):
+        return "question", True
+    if _is_requirement_intake_mode(activated_mode) and isinstance(current_question, dict):
+        return "question", True
+    if stage_key == "requirement_intake" and status_key in {"collecting", "blocked"} and bool(required_missing):
+        return "question", True
+    return "none", False
+
+
+def _build_dismiss_token(
+    *,
+    chooser_kind: str,
+    stage_key: str,
+    status_key: str,
+    current_question: dict[str, Any] | None,
+    required_missing: list[Any],
+) -> str:
+    if chooser_kind == "none":
+        return ""
+    question = current_question if isinstance(current_question, dict) else {}
+    question_ref = _trim(
+        question.get("question_revision")
+        or question.get("revision")
+        or question.get("question_id")
+        or question.get("field_key")
+    )
+    missing_ref = ",".join(_clean_list(required_missing))
+    parts = [chooser_kind, question_ref or missing_ref, _trim(stage_key), _trim(status_key)]
+    return "|".join([part for part in parts if part])
+
+
+def build_composer_ui_projection(
+    *,
+    activated_mode: str,
+    mode_source: str,
+    stage_key: str,
+    status_key: str,
+    current_question: dict[str, Any] | None,
+    required_missing: list[Any],
+    next_actions: list[Any],
+) -> dict[str, Any]:
+    question_field_key = _trim((current_question or {}).get("field_key"))
+    primary_missing_field = _trim(required_missing[0] if required_missing else "")
+    chooser_kind, chooser_visible = _resolve_chooser_visibility(
+        activated_mode=activated_mode,
+        stage_key=stage_key,
+        status_key=status_key,
+        current_question=current_question,
+        required_missing=required_missing,
+    )
+    dismiss_token = _build_dismiss_token(
+        chooser_kind=chooser_kind,
+        stage_key=stage_key,
+        status_key=status_key,
+        current_question=current_question,
+        required_missing=required_missing,
+    )
+    chooser_state = {
+        "kind": chooser_kind,
+        "visible": chooser_visible,
+        "requires_explicit_user_action": chooser_visible,
+        "dismissible": chooser_visible,
+        "dismiss_token": dismiss_token,
+        "keep_mode_on_submit": chooser_visible,
+        "source": "authoritative",
+        "current_field_key": question_field_key or primary_missing_field,
+        "blocking_fields": _clean_list(required_missing),
+        "next_action_keys": _next_action_keys(next_actions),
+    }
+    active_manual_mode = _trim(activated_mode) not in {"", "auto"}
+    return {
+        "active_mode": _trim(activated_mode) or "auto",
+        "mode_source": _trim(mode_source),
+        "source": "authoritative",
+        "recommendation_panel": {
+            "visible": not active_manual_mode,
+            "source": "authoritative",
+            "reason": "active_mode" if active_manual_mode else "auto_mode",
+        },
+        "composer_chooser": chooser_state,
+        "chooser_state": chooser_state,
+    }

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/canonical/flow.py

@@ -101,22 +101,6 @@ def normalize_stage_status_and_question(
         resolved_question = None
         if status_key in {"collecting", "blocked"}:
             status_key = "idle"
-    elif (
-        resolved_question is None
-        and required_missing
-        and stage_key == "requirement_intake"
-        and status_key in {"collecting", "blocked"}
-    ):
-        primary_field_key = str(required_missing[0] or "").strip()
-        if primary_field_key:
-            resolved_question = {
-                "field_key": primary_field_key,
-                "field_label": primary_field_key,
-                "question_text": f"请补充「{primary_field_key}」相关信息",
-                "options": [],
-                "step_index": 1,
-                "step_total": len(required_missing),
-            }
     if isinstance(resolved_question, dict) and intake_session_id:
         resolved_question = {
             **resolved_question,

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/canonical/payload.py

@@ -15,6 +15,7 @@ from flare_kernel.router.canonical.contract_support import (
     resolve_authoritative_runtime_payload,
     resolve_canvas_analysis_payload,
 )
+from flare_kernel.router.canonical.composer_ui import build_composer_ui_projection
 from flare_kernel.router.canonical.context_authority import build_context_authority_projection
 from flare_kernel.router.canonical.track_actions import build_track_next_actions
 from flare_kernel.router.intake.status.projection import (
@@ -27,10 +28,6 @@ from flare_kernel.router.intent.compat_aliases import (
     resolve_domain_relevance,
 )
 
-def _is_requirement_intake_mode(value: str) -> bool:
-    return str(value or "").strip() == "requirement_intake"
-
-
 def _normalize_canonical_mode(value: str) -> str:
     normalized = str(value or "auto").strip().lower().replace("-", "_").replace(" ", "_")
     return normalized or "auto"
@@ -116,45 +113,16 @@ def build_canonical_payload(
     module_prompt_registry = coerce_action_list(authoritative_runtime_payload.get("module_prompt_registry"))
     current_question = authoritative_current_question
     next_actions = authoritative_next_actions
-    question_field_key = str((current_question or {}).get("field_key") or "").strip()
-    question_kind = str((current_question or {}).get("question_kind") or "").strip().lower()
-    primary_missing_field = str((required_missing[0] if required_missing else "") or "").strip()
-    chooser_kind = "none"
-    chooser_visible = False
-    if activated_mode != "auto":
-        if (
-            stage_key == "requirement_intake"
-            and isinstance(current_question, dict)
-        ):
-            chooser_kind = "question"
-            chooser_visible = True
-        elif (
-            _is_requirement_intake_mode(activated_mode)
-            and isinstance(current_question, dict)
-        ):
-            chooser_kind = "question"
-            chooser_visible = True
-        elif (
-            stage_key == "requirement_intake"
-            and status_key in {"collecting", "blocked"}
-            and bool(required_missing)
-        ):
-            chooser_kind = "question"
-            chooser_visible = True
-    chooser_state = {
-        "kind": chooser_kind,
-        "visible": chooser_visible,
-        "requires_explicit_user_action": chooser_visible,
-        "source": "authoritative",
-        "current_field_key": question_field_key or primary_missing_field,
-        "blocking_fields": [str(item) for item in required_missing if str(item).strip()],
-        "next_action_keys": [
-            str(item.get("action_key") or item.get("type") or "").strip()
-            for item in next_actions
-            if isinstance(item, dict)
-            and str(item.get("action_key") or item.get("type") or "").strip()
-        ],
-    }
+    composer_ui = build_composer_ui_projection(
+        activated_mode=activated_mode,
+        mode_source=mode_source,
+        stage_key=stage_key,
+        status_key=status_key,
+        current_question=current_question,
+        required_missing=required_missing,
+        next_actions=next_actions,
+    )
+    chooser_state = composer_ui["chooser_state"]
     round_projection = build_round_projection(
         intake_session_id=intake_session_id,
         stage_key=stage_key,
@@ -216,7 +184,7 @@ def build_canonical_payload(
     }
     assistant_reply_text = str(assistant_text or "")
     normalized_command = str(command or "").strip().lower()
-    if _is_requirement_intake_mode(activated_mode) and normalized_command not in {"implement", "apply"}:
+    if activated_mode == "requirement_intake" and normalized_command not in {"implement", "apply"}:
         assistant_reply_text = ""
 
     return {
@@ -245,6 +213,7 @@ def build_canonical_payload(
             "stage": stage_key,
             "status": status_key,
             "chooser_state": chooser_state,
+            "composer_ui": composer_ui,
             "intake_session_id": intake_session_id,
             "intake_session_state": intake_session_state,
             "intake_session_completed": intake_session_completed,
@@ -279,6 +248,7 @@ def build_canonical_payload(
         "followup_question": followup_question,
         "question_decision": question_decision,
         "next_actions": authoritative_next_actions,
+        "composer_ui": composer_ui,
         "track_result": track_result,
         "response_strategy_result": response_strategy_result,
         "module_prompt_registry": module_prompt_registry,

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/intake/canonicalization.py

@@ -92,12 +92,16 @@ def canonicalize_field_entity(
     raw_value: Any,
     source_type: str,
     evidence_text: str,
+    field_definition: dict[str, Any] | None = None,
+    field_semantics: dict[str, Any] | None = None,
 ) -> dict[str, Any] | None:
     return canonicalize_field_entity_from_router(
         field_key=field_key,
         raw_value=raw_value,
         source_type=source_type,
         evidence_text=evidence_text,
+        field_definition=field_definition,
+        field_semantics=field_semantics,
     )
 
 

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/intake/extraction/extractors.py

@@ -151,15 +151,12 @@ def extract_intake_delivery_time(message: str) -> str:
 
 
 def resolve_intake_extraction_scope(context: dict[str, Any] | None = None) -> set[str]:
-    fallback_scope = {"goal", "use_case", "budget", "quantity", "constraints", "delivery_time"}
     if not isinstance(context, dict):
-        return fallback_scope
+        return set()
     allowed_fields = context.get("allowed_fields")
-    if not isinstance(allowed_fields, list):
-        return fallback_scope
+    if not isinstance(allowed_fields, (list, tuple, set)):
+        return set()
     normalized = {str(item or "").strip() for item in allowed_fields if str(item or "").strip()}
-    if not normalized:
-        return fallback_scope
     return normalized
 
 

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/intake/field_projection/core.py

@@ -58,6 +58,8 @@ def canonicalize_field_entity(
     raw_value: Any,
     source_type: str,
     evidence_text: str,
+    field_definition: dict[str, Any] | None = None,
+    field_semantics: dict[str, Any] | None = None,
 ) -> dict[str, Any] | None:
     """Canonicalize a single field entity from raw value and evidence."""
     return _canonicalize_field_entity(
@@ -65,6 +67,8 @@ def canonicalize_field_entity(
         raw_value=raw_value,
         source_type=source_type,
         evidence_text=evidence_text,
+        field_definition=field_definition,
+        field_semantics=field_semantics,
     )
 
 

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/intake/field_projection/entity.py

@@ -2,17 +2,24 @@
 
 from __future__ import annotations
 
+import re
 from typing import Any
 
 from flare_kernel.router.intake.amount_quantity import canonicalize_budget_value, canonicalize_quantity_value
 from flare_kernel.router.intake.delivery_time import canonicalize_delivery_time_value
 from flare_kernel.router.intake.field_projection.source import build_field_source_payload
+from flare_kernel.router.intake.numeric import detect_numeric_precision, parse_numeric_token
 from flare_kernel.router.text_safety import has_value
 
-_STRICT_STRUCTURED_FIELDS = {
-    "budget",
+_STRUCTURED_VALUE_TYPES = {
+    "money",
+    "money_range",
     "quantity",
-    "delivery_time",
+    "integer",
+    "number",
+    "time_window",
+    "date",
+    "datetime",
 }
 
 
@@ -34,27 +41,78 @@ def build_unparsed_field_entity(
     }
 
 
+def _coerce_mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _resolve_value_type(
+    *,
+    field_definition: dict[str, Any] | None,
+    field_semantics: dict[str, Any] | None,
+) -> str:
+    semantics = _coerce_mapping(field_semantics)
+    definition = _coerce_mapping(field_definition)
+    return str(
+        semantics.get("value_type")
+        or definition.get("value_type")
+        or definition.get("type")
+        or ""
+    ).strip().lower()
+
+
+def _canonicalize_number_value(raw_text: str) -> dict[str, Any] | None:
+    match = re.search(r"(?P<number>\d+(?:\.\d+)?|[一二两三四五六七八九十百千万亿]+)", raw_text)
+    if not match:
+        return None
+    parsed = parse_numeric_token(match.group("number"))
+    if parsed is None:
+        return None
+    value: int | float = int(round(parsed)) if float(parsed).is_integer() else parsed
+    return {
+        "status": "confirmed",
+        "normalized_value": {
+            "kind": "number",
+            "value": value,
+            "precision": detect_numeric_precision(raw_text),
+        },
+        "display_value": str(value),
+        "confidence": 0.9,
+    }
+
+
+def _canonicalize_structured_value(value_type: str, raw_text: str) -> dict[str, Any] | None:
+    if value_type in {"money", "money_range"}:
+        return canonicalize_budget_value(raw_text)
+    if value_type == "quantity":
+        return canonicalize_quantity_value(raw_text)
+    if value_type in {"integer", "number"}:
+        return _canonicalize_number_value(raw_text)
+    if value_type in {"time_window", "date", "datetime"}:
+        return canonicalize_delivery_time_value(raw_text)
+    return None
+
+
 def canonicalize_field_entity(
     *,
     field_key: str,
     raw_value: Any,
     source_type: str,
     evidence_text: str,
+    field_definition: dict[str, Any] | None = None,
+    field_semantics: dict[str, Any] | None = None,
 ) -> dict[str, Any] | None:
     """Canonicalize a single field entity from raw value and evidence."""
     normalized_key = str(field_key or "").strip()
     raw_text = str(raw_value or "").strip()
     if not normalized_key or not raw_text:
         return None
-    canonical: dict[str, Any] | None = None
-    if normalized_key == "budget":
-        canonical = canonicalize_budget_value(raw_text)
-    elif normalized_key == "quantity":
-        canonical = canonicalize_quantity_value(raw_text)
-    elif normalized_key == "delivery_time":
-        canonical = canonicalize_delivery_time_value(raw_text)
+    value_type = _resolve_value_type(
+        field_definition=field_definition,
+        field_semantics=field_semantics,
+    )
+    canonical = _canonicalize_structured_value(value_type, raw_text)
     if canonical is None:
-        if normalized_key in _STRICT_STRUCTURED_FIELDS:
+        if value_type in _STRUCTURED_VALUE_TYPES:
             canonical = {
                 "status": "unparsed",
                 "normalized_value": None,

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/intake/field_projection/payload.py

@@ -22,10 +22,20 @@ def canonicalize_payload_fields(payload: dict[str, Any]) -> dict[str, Any]:
     normalized_sources = dict(field_sources) if isinstance(field_sources, dict) else {}
     existing_entities = payload.get("field_entities")
     normalized_existing = dict(existing_entities) if isinstance(existing_entities, dict) else {}
+    field_definitions = payload.get("field_definitions")
+    definitions_by_key = {
+        str(item.get("key") or "").strip(): item
+        for item in field_definitions
+        if isinstance(item, dict) and str(item.get("key") or "").strip()
+    } if isinstance(field_definitions, list) else {}
+    field_semantics = payload.get("field_semantics")
+    semantics_by_key = dict(field_semantics) if isinstance(field_semantics, dict) else {}
 
     next_entities: dict[str, Any] = {}
     next_fields: dict[str, str] = {}
     field_candidates: dict[str, Any] = {}
+    field_clarifications: dict[str, Any] = {}
+    answered_field_keys: set[str] = set()
     field_keys = set()
     field_keys.update(str(key or "").strip() for key in fields.keys())
     field_keys.update(str(key or "").strip() for key in normalized_existing.keys())
@@ -51,14 +61,27 @@ def canonicalize_payload_fields(payload: dict[str, Any]) -> dict[str, Any]:
             raw_value=raw_value,
             source_type=source_type,
             evidence_text=evidence_text,
+            field_definition=definitions_by_key.get(field_key),
+            field_semantics=(
+                semantics_by_key.get(field_key)
+                if isinstance(semantics_by_key.get(field_key), dict)
+                else None
+            ),
         )
         if not isinstance(entity, dict):
             continue
         next_entities[field_key] = entity
+        answered_field_keys.add(field_key)
         if is_field_entity_confirmed(entity):
             next_fields[field_key] = str(entity.get("display_value") or "").strip()
         else:
             field_candidates[field_key] = entity
+            field_clarifications[field_key] = {
+                "field_key": field_key,
+                "status": "needs_clarification",
+                "reason": "unparsed_structured_value",
+                "raw_value": str(entity.get("raw_value") or raw_value or "").strip(),
+            }
 
     payload["field_entities"] = next_entities
     payload["fields"] = next_fields
@@ -66,6 +89,21 @@ def canonicalize_payload_fields(payload: dict[str, Any]) -> dict[str, Any]:
         payload["field_candidates"] = field_candidates
     else:
         payload.pop("field_candidates", None)
+    if field_clarifications:
+        payload["field_clarifications"] = field_clarifications
+    else:
+        payload.pop("field_clarifications", None)
+
+    required_missing = payload.get("required_missing")
+    if isinstance(required_missing, list):
+        payload["required_missing"] = [
+            item
+            for item in required_missing
+            if str(item).strip()
+            and str(item).strip() not in next_fields
+            and str(item).strip() not in answered_field_keys
+        ]
+        return payload
 
     required_fields = payload.get("required_fields")
     if isinstance(required_fields, list):
@@ -73,16 +111,8 @@ def canonicalize_payload_fields(payload: dict[str, Any]) -> dict[str, Any]:
         payload["required_missing"] = [
             field_key
             for field_key in normalized_required_fields
-            if field_key not in next_fields
+            if field_key not in next_fields and field_key not in answered_field_keys
         ]
-    else:
-        required_missing = payload.get("required_missing")
-        if isinstance(required_missing, list):
-            payload["required_missing"] = [
-                item
-                for item in required_missing
-                if str(item).strip() and str(item).strip() not in next_fields
-            ]
     return payload
 
 

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/intent/escalation/override.py

@@ -73,8 +73,6 @@ def apply_escalation_mode_override(
         resolved_intent = "requirement_intake"
     elif not str(resolved_intent or "").strip() or str(resolved_intent).strip() == "default":
         resolved_intent = "requirement_intake"
-    resolved_mode = "requirement_intake"
-    mode_source = "intent_and_escalation_classifier"
     intent_source = "intent_and_escalation_classifier"
     intent_confidence = max(float(intent_confidence or 0.0), max(0.0, min(1.0, classifier_confidence)))
     classifier_reason = str(escalation_signal.get("reason") or "").strip()

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/kernel_constants/patch.py

@@ -21,6 +21,7 @@ PATCH_SCOPES_AUTHORITATIVE = {
     "track_result",
     "response_strategy_result",
     "module_prompt_registry",
+    "composer_ui",
     "analysis",
     "observation",
     "capabilities.field_retrieval",

flare_kernel-0.2.10/src/flare_kernel/router/kernel_facade/domain_pack_payload.py

@@ -0,0 +1,52 @@
+"""Domain-pack field context injection for kernel payload enrichment."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_kernel.contracts import KernelRequest
+from flare_kernel.runtime.domain.domain_pack_loader import load_domain_pack
+
+
+def _copy_list(value: Any) -> list[Any]:
+    return list(value) if isinstance(value, list) else []
+
+
+def _should_skip_field_list(payload: dict[str, Any], key: str) -> bool:
+    if isinstance(payload.get(key), list):
+        return True
+    if key == "required_fields" and isinstance(payload.get("required_missing"), list):
+        return True
+    return False
+
+
+def merge_domain_pack_field_context(req: KernelRequest) -> KernelRequest:
+    """Attach domain-pack field contracts before intake extraction runs."""
+    payload = dict(req.payload) if isinstance(req.payload, dict) else {}
+    pack = load_domain_pack(
+        instance_id=req.instance_id,
+        domain_pack_version=req.domain_pack_version,
+        domain=str(payload.get("domain_pack_domain") or payload.get("domain") or "").strip() or None,
+        payload=payload,
+        tenant_id=req.tenant_id,
+    )
+    pack_fields = pack.fields if isinstance(pack.fields, dict) else {}
+    if not isinstance(payload.get("field_definitions"), list):
+        definitions = _copy_list(pack_fields.get("field_definitions"))
+        if definitions:
+            payload["field_definitions"] = definitions
+    for key in ("required_fields", "recommended_fields", "optional_fields"):
+        if _should_skip_field_list(payload, key):
+            continue
+        values = _copy_list(pack_fields.get(key))
+        if values:
+            payload[key] = values
+    if (
+        not isinstance(payload.get("field_semantics"), dict)
+        and isinstance(pack_fields.get("field_semantics"), dict)
+    ):
+        payload["field_semantics"] = dict(pack_fields.get("field_semantics") or {})
+    return req.model_copy(update={"payload": payload})
+
+
+__all__ = ["merge_domain_pack_field_context"]

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/kernel_facade/payload_enrichment.py

@@ -43,6 +43,9 @@ from flare_kernel.router.intake.payload_updates import (
 from flare_kernel.router.kernel_facade.dependency_resolution import (
     resolve_payload_enrichment_dependencies,
 )
+from flare_kernel.router.kernel_facade.domain_pack_payload import (
+    merge_domain_pack_field_context,
+)
 from flare_kernel.router.kernel_facade.utils import (
     _kernel_attr,
     _safe_session_id,
@@ -58,9 +61,7 @@ from flare_kernel.router.mode.resolution import (
 from flare_kernel.router.request.intent_resolution import (
     resolve_intent_override as _resolve_intent_override_from_router,
 )
-from flare_kernel.router.text_safety import (
-    extract_user_message as _extract_user_message,
-)
+from flare_kernel.router.text_safety import extract_user_message as _extract_user_message
 
 
 def enrich_kernel_payload_flow(
@@ -95,6 +96,8 @@ def enrich_kernel_payload_flow(
     is_intake_control_message_fn: Callable[[str], bool] | None = None,
 ) -> dict[str, Any]:
     """Run payload enrichment with fully resolved dependencies."""
+    if resolved_mode == "requirement_intake":
+        req = merge_domain_pack_field_context(req)
     return enrich_payload_from_router(
         req,
         resolved_mode=resolved_mode,

{flare_kernel-0.2.8 → flare_kernel-0.2.10}/src/flare_kernel/router/mode/resolution.py

@@ -130,6 +130,15 @@ def _has_source_grounding_route(req: KernelRequest) -> bool:
     route = str(source_grounding.get("route") or "").strip()
     return source_grounding.get("active") is True and route == "source_grounded_answer"
 
+
+def _resolve_mode_from_inferred_intent(resolved_intent: str) -> tuple[str, str]:
+    if not resolved_intent:
+        return "", ""
+    if resolved_intent == "requirement_intake":
+        return "default", "intent_suggestion"
+    return resolved_intent, "intent"
+
+
 def resolve_request_mode(
     req: KernelRequest,
     resolved_intent: str,
@@ -211,7 +220,8 @@ def resolve_request_mode(
         return current_mode, "current_hint"
 
     normalized_resolved_intent = normalize_mode_candidate_fn(resolved_intent)
-    if normalized_resolved_intent:
-        return normalized_resolved_intent, "intent"
+    inferred_mode, inferred_source = _resolve_mode_from_inferred_intent(normalized_resolved_intent)
+    if inferred_source:
+        return inferred_mode, inferred_source
 
     return "default", "fallback"