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

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

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

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

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

{flare_kernel-0.2.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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.9 → 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.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.9 → 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.9 → flare_kernel-0.2.10}/src/flare_kernel/router/prompting/requirement_intake.py

@@ -46,7 +46,26 @@ _DOCUMENT_OUTPUT_INSTRUCTION = (
 )
 
 
-def _missing_field_prompt_items(payload: dict[str, Any], required_missing: list[Any]) -> list[dict[str, str]]:
+def _normalize_prompt_options(options: Any) -> list[dict[str, str]]:
+    if not isinstance(options, list):
+        return []
+    normalized: list[dict[str, str]] = []
+    for index, option in enumerate(options, start=1):
+        item = option if isinstance(option, dict) else {"label": option, "value": option}
+        label = str(item.get("label") or item.get("text") or item.get("value") or "").strip()
+        if not label:
+            continue
+        normalized.append(
+            {
+                "key": str(item.get("key") or f"option_{index}").strip(),
+                "label": label,
+                "value": str(item.get("value") or label).strip(),
+            }
+        )
+    return normalized
+
+
+def _missing_field_prompt_items(payload: dict[str, Any], required_missing: list[Any]) -> list[dict[str, Any]]:
     projected_items = payload.get("required_missing_items") if isinstance(payload.get("required_missing_items"), list) else []
     projected_map = {
         str(item.get("key") or "").strip(): str(item.get("label") or "").strip()
@@ -66,7 +85,14 @@ def _missing_field_prompt_items(payload: dict[str, Any], required_missing: list[
             continue
         definition = definition_map.get(key, {})
         label = projected_map.get(key) or str(definition.get("label") or key).strip()
-        items.append({"key": key, "label": label})
+        prompt_item: dict[str, Any] = {"key": key, "label": label}
+        question = str(definition.get("question") or "").strip()
+        if question:
+            prompt_item["question"] = question
+        options = _normalize_prompt_options(definition.get("options"))
+        if options:
+            prompt_item["options"] = options
+        items.append(prompt_item)
     return items
 
 

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/src/flare_kernel/runtime/domain/domain_pack_loader.py

@@ -19,6 +19,10 @@ from flare_kernel.runtime.domain.profile_resolution import (
     ResolutionContext,
     ResolutionTraceEntry,
 )
+from flare_kernel.runtime.domain.domain_pack_paths import (
+    DEFAULT_PACK_VARIANT as _DEFAULT_PACK_VARIANT,
+    resolve_domain_pack_dir,
+)
 
 logger = get_logger("flare_kernel.runtime.domain.domain_pack_loader")
 
@@ -26,7 +30,6 @@ _DOMAIN_PACK_ROOT_ENV = "FLARE_DOMAIN_PACK_ROOT"
 _DEFAULT_DOMAIN_ENV = "FLARE_DOMAIN_PACK_DEFAULT_DOMAIN"
 _INSTANCE_PROFILE_FILE = "branding/instance-branding.json"
 _DEFAULT_DOMAIN = "generic"
-_DEFAULT_VERSION = "v1"
 
 
 @dataclass(frozen=True)
@@ -390,7 +393,7 @@ def _new_capability(enabled: bool, *, reason: str = "", missing: bool = False) -
     return payload
 
 
-def _build_missing_pack(domain: str, version: str, root: Path | None, *, reason: str) -> DomainPack:
+def _build_missing_pack(domain: str, variant: str, root: Path | None, *, reason: str) -> DomainPack:
     capabilities = {
         "pack": _new_capability(False, reason=reason, missing=True),
         "taxonomy": _new_capability(False, reason="pack_missing", missing=True),
@@ -402,7 +405,7 @@ def _build_missing_pack(domain: str, version: str, root: Path | None, *, reason:
     }
     return DomainPack(
         domain=domain,
-        version=version,
+        version=variant,
         root=str(root) if isinstance(root, Path) else "",
         taxonomy=None,
         fields=None,
@@ -417,12 +420,12 @@ def _build_missing_pack(domain: str, version: str, root: Path | None, *, reason:
 
 
 @lru_cache(maxsize=32)
-def _load_domain_pack_cached(root_path: str, domain: str, domain_pack_version: str) -> DomainPack:
+def _load_domain_pack_cached(root_path: str, domain: str, domain_pack_variant: str) -> DomainPack:
     root = Path(root_path)
-    pack_root = root / domain / domain_pack_version
-    if not pack_root.exists() or not pack_root.is_dir():
-        logger.warning("domain_pack.version_not_found domain=%s version=%s root=%s", domain, domain_pack_version, str(pack_root))
-        return _build_missing_pack(domain, domain_pack_version, root, reason="version_not_found")
+    pack_root = resolve_domain_pack_dir(root, domain, domain_pack_variant)
+    if pack_root is None:
+        logger.warning("domain_pack.not_found domain=%s variant=%s root=%s", domain, domain_pack_variant, str(root / domain))
+        return _build_missing_pack(domain, domain_pack_variant, root, reason="pack_not_found")
 
     taxonomy_raw = _read_structured_file(pack_root / "taxonomy.yaml")
     fields_raw = _read_structured_file(pack_root / "fields.yaml")
@@ -473,7 +476,7 @@ def _load_domain_pack_cached(root_path: str, domain: str, domain_pack_version: s
 
     return DomainPack(
         domain=domain,
-        version=domain_pack_version,
+        version=domain_pack_variant,
         root=str(pack_root),
         taxonomy=taxonomy,
         fields=fields,
@@ -626,7 +629,7 @@ def load_requirement_schema(instance_id: str) -> dict[str, Any] | None:
 
     pack = load_domain_pack(
         instance_id=instance_id,
-        domain_pack_version=_DEFAULT_VERSION,
+        domain_pack_version=_DEFAULT_PACK_VARIANT,
         domain=resolve_default_domain(),
     )
     if not isinstance(pack.fields, dict):

flare_kernel-0.2.10/src/flare_kernel/runtime/domain/domain_pack_paths.py

@@ -0,0 +1,38 @@
+"""Domain-pack filesystem path resolution."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+DEFAULT_PACK_VARIANT = "default"
+_PACK_MODULE_FILENAMES = (
+    "taxonomy.yaml",
+    "fields.yaml",
+    "workflow.yaml",
+    "search-mapping.yaml",
+    "replace-rules.yaml",
+)
+
+
+def is_domain_pack_dir(path: Path) -> bool:
+    if not path.exists() or not path.is_dir():
+        return False
+    if (path / "templates").is_dir():
+        return True
+    return any((path / filename).is_file() for filename in _PACK_MODULE_FILENAMES)
+
+
+def resolve_domain_pack_dir(root: Path, domain: str, domain_pack_variant: str) -> Path | None:
+    domain_root = root / domain
+    if is_domain_pack_dir(domain_root):
+        return domain_root
+    variant = str(domain_pack_variant or "").strip()
+    if not variant:
+        return None
+    variant_root = domain_root / variant
+    if is_domain_pack_dir(variant_root):
+        return variant_root
+    return None
+
+
+__all__ = ["DEFAULT_PACK_VARIANT", "is_domain_pack_dir", "resolve_domain_pack_dir"]

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/src/flare_kernel/runtime/infrastructure/source/schema.py

@@ -6,6 +6,10 @@ from typing import Any, Callable
 
 
 def ensure_document_understanding_column(conn: Any, text_fn: Callable[[str], Any]) -> None:
+    dialect_name = str(getattr(getattr(conn, "dialect", None), "name", "") or "").lower()
+    if dialect_name == "postgresql":
+        conn.execute(text_fn("ALTER TABLE flare_project_sources ADD COLUMN IF NOT EXISTS document_understanding TEXT"))
+        return
     try:
         conn.execute(text_fn("ALTER TABLE flare_project_sources ADD COLUMN document_understanding TEXT"))
     except Exception:

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/src/flare_kernel/runtime/orchestration/mode/intake_context.py

@@ -92,8 +92,8 @@ def build_intake_context(
     prompt_summary_template_key = str(
         payload.get("prompt_summary_template_key")
         or pack_workflow.get("prompt_summary_template_key")
-        or "flare_default_v1"
-    ).strip() or "flare_default_v1"
+        or "flare_default"
+    ).strip() or "flare_default"
     prompt_summary_template = payload.get("prompt_summary_template")
     if not isinstance(prompt_summary_template, dict):
         prompt_summary_template = pack_workflow.get("prompt_summary_template")

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/src/flare_kernel.egg-info/PKG-INFO

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

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/src/flare_kernel.egg-info/SOURCES.txt

@@ -140,6 +140,7 @@ src/flare_kernel/router/kernel_endpoint_handlers/turn.py
 src/flare_kernel/router/kernel_facade/__init__.py
 src/flare_kernel/router/kernel_facade/canonical_state.py
 src/flare_kernel/router/kernel_facade/dependency_resolution.py
+src/flare_kernel/router/kernel_facade/domain_pack_payload.py
 src/flare_kernel/router/kernel_facade/flow.py
 src/flare_kernel/router/kernel_facade/orchestration.py
 src/flare_kernel/router/kernel_facade/payload_enrichment.py
@@ -260,6 +261,7 @@ src/flare_kernel/runtime/diagnostics/replay_snapshot_io.py
 src/flare_kernel/runtime/diagnostics/replay_snapshot_validation.py
 src/flare_kernel/runtime/domain/__init__.py
 src/flare_kernel/runtime/domain/domain_pack_loader.py
+src/flare_kernel/runtime/domain/domain_pack_paths.py
 src/flare_kernel/runtime/domain/profile_resolution.py
 src/flare_kernel/runtime/execution/__init__.py
 src/flare_kernel/runtime/execution/agent_runtime.py

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/tests/test_artifact_template_runtime.py

@@ -10,7 +10,7 @@ _REPO_ROOT = Path(__file__).resolve().parents[3]
 
 
 def _load_generic_domain_pack() -> dict:
-    domain_dir = _REPO_ROOT / "domain-packs" / "generic" / "v1"
+    domain_dir = _REPO_ROOT / "domain-packs" / "generic"
     workflow = json.loads((domain_dir / "workflow.yaml").read_text(encoding="utf-8"))
     templates = {
         path.name: path.read_text(encoding="utf-8")

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/tests/test_business_hardcode_guard.py

@@ -92,9 +92,9 @@ def test_kernel_core_has_no_infrastructure_deployment_field_canonicalization() -
 def test_generic_pack_and_frontend_process_model_have_no_deployment_gate_terms() -> None:
     repo_root = Path(__file__).resolve().parents[3]
     paths = [
-        repo_root / "domain-packs" / "generic" / "v1" / "fields.yaml",
-        repo_root / "domain-packs" / "generic" / "v1" / "workflow.yaml",
-        repo_root / "domain-packs" / "generic" / "v1" / "search-mapping.yaml",
+        repo_root / "domain-packs" / "generic" / "fields.yaml",
+        repo_root / "domain-packs" / "generic" / "workflow.yaml",
+        repo_root / "domain-packs" / "generic" / "search-mapping.yaml",
         repo_root / "packages" / "flare-chat-ui" / "src" / "chat-gui" / "ui" / "timeline" / "components" / "chatTimelineSystemProcessModel.js",
     ]
     banned_tokens = [

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/tests/test_canonical_state_flow.py

@@ -109,6 +109,23 @@ def test_normalize_stage_status_and_question_sets_idle_when_auto_collecting() ->
     assert question is None
 
 
+def test_normalize_stage_status_and_question_does_not_synthesize_question_without_backend_state() -> None:
+    stage_key, status_key, question = normalize_stage_status_and_question(
+        orchestration_status={"current_stage": "requirement_intake.collecting"},
+        required_missing=["budget"],
+        activated_mode="requirement_intake",
+        current_question=None,
+        command="send_message",
+        assistant_text="",
+        intake_session_id="intake_1",
+        normalize_stage_status_fn=lambda **_kwargs: ("requirement_intake", "collecting"),
+    )
+
+    assert stage_key == "requirement_intake"
+    assert status_key == "collecting"
+    assert question is None
+
+
 def test_resolve_analysis_generation_state_builds_validation_error_when_not_ready() -> None:
     state = resolve_analysis_generation_state(
         command="generate_analysis",

{flare_kernel-0.2.9 → flare_kernel-0.2.10}/tests/test_canonical_state_payload.py

@@ -217,7 +217,7 @@ def test_canonical_payload_ignores_removed_plan_authoritative_fields() -> None:
             "removed_canvas_draft": {"content": "draft"},
             "removed_apply_handoff": {"ready": False},
             "removed_summary_contract": {"summary": "contract"},
-            "removed_summary_template_key": "flare_default_v1",
+            "removed_summary_template_key": "flare_default",
             "removed_summary_template": {"sections": ["summary"]},
         },
         build_confirmed_fields_schema_fn=lambda *_args, **_kwargs: {},