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

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

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

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

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

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

@@ -12,11 +12,13 @@ from typing import Any, Callable
 from flare_kernel.contracts import KernelRequest
 from flare_kernel.router.canonical.contract_support import (
     coerce_action_list,
+    coerce_mapping,
     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.projection import resolve_canonical_next_actions
 from flare_kernel.router.canonical.track_actions import build_track_next_actions
 from flare_kernel.router.intake.status.projection import (
     build_round_projection,
@@ -101,20 +103,22 @@ def build_canonical_payload(
         if isinstance(authoritative_runtime_payload.get("response_strategy_result"), dict)
         else {}
     )
-    authoritative_next_actions = (
-        coerce_action_list(authoritative_runtime_payload.get("next_actions"))
-        or next_actions
-        # DOC HELPER — ORC-10: track-derived actions are a backend fallback only
-        # when no runtime/canonical next_actions exist. UI must not infer these.
-        or build_track_next_actions(track_result)
+    runtime_payload = coerce_mapping(coerce_mapping(runtime_snapshot).get("payload"))
+    # DOC HELPER — ORC-10: track-derived actions are a backend fallback only
+    # when no runtime/canonical next_actions exist. UI must not infer these.
+    authoritative_next_actions = resolve_canonical_next_actions(
+        runtime_actions=coerce_action_list(runtime_payload.get("next_actions")),
+        context_actions=next_actions,
+        track_actions=build_track_next_actions(track_result),
+        intake_session_completed=intake_session_completed,
     )
-    if intake_session_completed:
-        authoritative_next_actions = []
     module_prompt_registry = coerce_action_list(authoritative_runtime_payload.get("module_prompt_registry"))
     current_question = authoritative_current_question
     next_actions = authoritative_next_actions
+    projected_activated_mode = "auto" if intake_session_completed else activated_mode
+    projected_suggested_mode = None if intake_session_completed else canonical_context.get("suggested_mode")
     composer_ui = build_composer_ui_projection(
-        activated_mode=activated_mode,
+        activated_mode=projected_activated_mode,
         mode_source=mode_source,
         stage_key=stage_key,
         status_key=status_key,
@@ -205,9 +209,9 @@ def build_canonical_payload(
         "context_authority": build_context_authority_projection(runtime_snapshot),
         "primary_flow": {
             "mode": {
-                "suggested": canonical_context.get("suggested_mode"),
-                "activated": activated_mode,
-                "is_activation_explicit": explicit_activation and activated_mode != "auto",
+                "suggested": projected_suggested_mode,
+                "activated": projected_activated_mode,
+                "is_activation_explicit": explicit_activation and projected_activated_mode != "auto",
                 "activation_source": mode_source if explicit_activation else "none",
             },
             "stage": stage_key,

{flare_kernel-0.2.10 → flare_kernel-0.2.11}/src/flare_kernel/router/canonical/projection.py

@@ -12,6 +12,12 @@ from flare_kernel.router.canonical.checkpoint import (
 )
 from flare_kernel.router.next_actions_guard import dedupe_next_actions_by_action_key
 
+_POST_INTAKE_INTERNAL_ACTION_KEYS = {
+    "activate_requirement_intake",
+    "continue_collection",
+    "implement",
+}
+
 
 def normalize_retrieved_knowledge(
     structured_retrieved_knowledge: list[dict[str, Any]] | None,
@@ -58,6 +64,41 @@ def collect_confirmed_field_values(
     return fields, field_entities
 
 
+def _action_key(action: dict[str, Any]) -> str:
+    return str(action.get("action_key") or action.get("type") or "").strip()
+
+
+def filter_post_intake_next_actions(
+    actions: list[dict[str, Any]],
+    *,
+    intake_session_completed: bool,
+) -> list[dict[str, Any]]:
+    filtered = [item for item in actions if isinstance(item, dict)]
+    if not intake_session_completed:
+        return filtered
+    return [
+        item for item in filtered
+        if _action_key(item) not in _POST_INTAKE_INTERNAL_ACTION_KEYS
+    ]
+
+
+def resolve_canonical_next_actions(
+    *,
+    runtime_actions: list[dict[str, Any]],
+    context_actions: list[dict[str, Any]],
+    track_actions: list[dict[str, Any]],
+    intake_session_completed: bool,
+) -> list[dict[str, Any]]:
+    for actions in (runtime_actions, context_actions, track_actions):
+        resolved = filter_post_intake_next_actions(
+            actions,
+            intake_session_completed=intake_session_completed,
+        )
+        if resolved:
+            return resolved
+    return []
+
+
 def build_next_actions_projection(
     *,
     orchestration_status: dict[str, Any],
@@ -67,8 +108,6 @@ def build_next_actions_projection(
     status_key: str,
     map_external_mode_fn: Callable[[str], str],
 ) -> list[dict[str, Any]]:
-    if intake_session_completed:
-        return []
     next_actions: list[dict[str, Any]] = []
     raw_actions = (
         orchestration_status.get("next_actions")
@@ -81,6 +120,8 @@ def build_next_actions_projection(
         action_key = str(action.get("action_key") or action.get("type") or "").strip()
         if not action_key:
             continue
+        if intake_session_completed and action_key in _POST_INTAKE_INTERNAL_ACTION_KEYS:
+            continue
         # DOC HELPER — action visibility is decision-driven.
         # Do not hide analysis actions by workflow stage here; status/readiness
         # must already reflect analysis_entry_decision from orchestration.

{flare_kernel-0.2.10 → flare_kernel-0.2.11}/src/flare_kernel/router/completion/guided.py

@@ -15,6 +15,8 @@ _REQUIREMENT_INTAKE_COMMAND_SCORES = {
     "activate_requirement_intake": {"main_chain": 0.0, "patch_only": 1.0},
 }
 _DEFAULT_REQUIREMENT_INTAKE_COMMAND_SCORE = {"main_chain": 1.0, "patch_only": 0.0}
+_PATCH_ONLY_COMPLETION_MODES = frozenset({"patch_only", "state_patch_only"})
+_MAIN_CHAIN_COMPLETION_MODES = frozenset({"main_chain", "llm", "generate"})
 
 
 @dataclass(frozen=True)
@@ -23,6 +25,7 @@ class _GuidedCompletionDecision:
     main_chain_score: float
     patch_only_score: float
     phase_score: float
+    policy_reason: str
 
     @property
     def is_patch_only(self) -> bool:
@@ -51,8 +54,71 @@ def _is_collecting_question_phase(orchestration_status: dict[str, Any]) -> bool:
     return False
 
 
+def _coerce_payload(req: KernelRequest) -> dict[str, Any]:
+    return req.payload if isinstance(req.payload, dict) else {}
+
+
+def _completion_mode_from_payload(payload: dict[str, Any]) -> str:
+    """Read the optional completion-routing contract from request payload.
+
+    Supported payload shapes:
+    - completion_policy: {"mode": "patch_only" | "main_chain"}
+    - completion_mode: "patch_only" | "main_chain"
+    """
+    policy = payload.get("completion_policy")
+    raw_mode = ""
+    if isinstance(policy, dict):
+        raw_mode = str(policy.get("mode") or policy.get("completion_mode") or policy.get("action") or "").strip()
+    elif policy is not None:
+        raw_mode = str(policy or "").strip()
+    if not raw_mode:
+        raw_mode = str(payload.get("completion_mode") or "").strip()
+    return raw_mode.lower().replace("-", "_").replace(" ", "_")
+
+
+def _has_workspace_patch_signal(payload: dict[str, Any]) -> bool:
+    if isinstance(payload.get("workspace_patch"), dict) and payload.get("workspace_patch"):
+        return True
+    patches = payload.get("workspace_patches")
+    return isinstance(patches, list) and any(isinstance(item, dict) and item for item in patches)
+
+
+def _explicit_completion_decision(payload: dict[str, Any]) -> _GuidedCompletionDecision | None:
+    completion_mode = _completion_mode_from_payload(payload)
+    if completion_mode in _PATCH_ONLY_COMPLETION_MODES:
+        return _GuidedCompletionDecision(
+            action="patch_only",
+            main_chain_score=0.0,
+            patch_only_score=1.0,
+            phase_score=1.0,
+            policy_reason="explicit_completion_policy",
+        )
+    if completion_mode in _MAIN_CHAIN_COMPLETION_MODES:
+        return _GuidedCompletionDecision(
+            action="main_chain",
+            main_chain_score=1.0,
+            patch_only_score=0.0,
+            phase_score=0.0,
+            policy_reason="explicit_completion_policy",
+        )
+    return None
+
+
+def _payload_patch_decision(payload: dict[str, Any]) -> _GuidedCompletionDecision | None:
+    if not _has_workspace_patch_signal(payload):
+        return None
+    return _GuidedCompletionDecision(
+        action="patch_only",
+        main_chain_score=0.0,
+        patch_only_score=1.0,
+        phase_score=1.0,
+        policy_reason="workspace_patch_payload",
+    )
+
+
 def _resolve_requirement_intake_guided_decision(
     *,
+    req: KernelRequest,
     command: str,
     orchestration_status: dict[str, Any],
 ) -> _GuidedCompletionDecision:
@@ -67,6 +133,13 @@ def _resolve_requirement_intake_guided_decision(
         through the normal LLM path; `patch_only` means this turn only emits UI/state
         patches and should not be persisted as an assistant memory record.
     """
+    payload = _coerce_payload(req)
+    explicit_decision = _explicit_completion_decision(payload)
+    if explicit_decision is not None:
+        return explicit_decision
+    payload_decision = _payload_patch_decision(payload)
+    if payload_decision is not None:
+        return payload_decision
     command_scores = _REQUIREMENT_INTAKE_COMMAND_SCORES.get(
         command,
         _DEFAULT_REQUIREMENT_INTAKE_COMMAND_SCORE,
@@ -80,6 +153,7 @@ def _resolve_requirement_intake_guided_decision(
         main_chain_score=main_chain_score,
         patch_only_score=patch_only_score,
         phase_score=phase_score,
+        policy_reason="legacy_command_phase_score",
     )
 
 
@@ -98,6 +172,7 @@ def resolve_guided_orchestrated_completion(
     if normalized_mode != "requirement_intake":
         return None
     intake_decision = _resolve_requirement_intake_guided_decision(
+        req=req,
         command=normalized_command,
         orchestration_status=orchestration_status,
     )
@@ -117,6 +192,7 @@ def resolve_guided_orchestrated_completion(
             "main_chain_score": intake_decision.main_chain_score,
             "patch_only_score": intake_decision.patch_only_score,
             "phase_score": intake_decision.phase_score,
+            "policy_reason": intake_decision.policy_reason,
         },
     )
 

flare_kernel-0.2.11/src/flare_kernel/router/completion/intake_summary_events.py

@@ -0,0 +1,200 @@
+"""Completion-time intake summary event helpers."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from flare_kernel.runtime.orchestration.mode.intake_summary_artifact import (
+    build_model_authored_requirement_summary_event,
+)
+
+_CANVAS_ONLY_COMMANDS = frozenset({"", "send_message"})
+_DOCUMENT_OUTPUT_INTENTS = frozenset({"document_template_output", "document_draft_output"})
+_CONFIRM_SEND_PROMPT_ACTION_KEY = "confirm_send_prompt"
+
+
+def _clean_text(value: Any) -> str:
+    return str(value or "").strip()
+
+
+def _coerce_mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _has_document_output_intent(runtime_snapshot: dict[str, Any]) -> bool:
+    payload = _coerce_mapping(runtime_snapshot.get("payload"))
+    response_intent_result = _coerce_mapping(payload.get("response_intent_result"))
+    return _clean_text(response_intent_result.get("response_intent")) in _DOCUMENT_OUTPUT_INTENTS
+
+
+def _has_active_question(orchestration_status: dict[str, Any]) -> bool:
+    status = orchestration_status if isinstance(orchestration_status, dict) else {}
+    current_question = _coerce_mapping(status.get("current_question"))
+    question_status = _clean_text(current_question.get("question_status") or current_question.get("status")).lower()
+    if current_question and question_status not in {"answered", "stale", "dismissed", "completed", "applied"}:
+        return True
+    chooser_state = _coerce_mapping(status.get("chooser_state"))
+    if _clean_text(chooser_state.get("kind")).lower() == "question" and chooser_state.get("visible") is not False:
+        return True
+    return bool(status.get("has_active_question"))
+
+
+def _is_confirm_send_prompt_action(action: dict[str, Any]) -> bool:
+    payload = _coerce_mapping(action.get("payload"))
+    action_key = _clean_text(action.get("action_key") or action.get("id") or action.get("command"))
+    action_type = _clean_text(action.get("action_type") or action.get("type"))
+    payload_action_type = _clean_text(payload.get("action_type") or payload.get("type"))
+    return (
+        action_key == _CONFIRM_SEND_PROMPT_ACTION_KEY
+        or action_type == _CONFIRM_SEND_PROMPT_ACTION_KEY
+        or payload_action_type == _CONFIRM_SEND_PROMPT_ACTION_KEY
+    )
+
+
+def build_requirement_summary_confirm_send_action(
+    *,
+    content_text: str,
+) -> dict[str, Any] | None:
+    """Build the backend-owned action that sends the reviewed prompt text."""
+
+    prompt = _clean_text(content_text)
+    if not prompt:
+        return None
+    return {
+        "action_key": _CONFIRM_SEND_PROMPT_ACTION_KEY,
+        "action_type": _CONFIRM_SEND_PROMPT_ACTION_KEY,
+        "label": "确认发送",
+        "target_mode": "auto",
+        "priority": 0,
+        "status": "available",
+        "command": "send_message",
+        "reason": "确认后会将整理后的完整提示词作为下一条消息发送。",
+        "payload": {
+            "action_key": _CONFIRM_SEND_PROMPT_ACTION_KEY,
+            "action_type": _CONFIRM_SEND_PROMPT_ACTION_KEY,
+            "command": "send_message",
+            "target_mode": "auto",
+            "prompt_text": prompt,
+            "answer_value": prompt,
+            "submit_label": "确认发送",
+            "title": "确认发送整理后的提示词",
+        },
+    }
+
+
+def with_requirement_summary_confirm_send_action(
+    *,
+    next_actions: list[dict[str, Any]],
+    content_text: str,
+) -> list[dict[str, Any]]:
+    """Attach the prompt-confirm action without rewriting other actions."""
+
+    actions = next_actions if isinstance(next_actions, list) else []
+    resolved = [
+        dict(action)
+        for action in actions
+        if isinstance(action, dict) and not _is_confirm_send_prompt_action(action)
+    ]
+    confirm_action = build_requirement_summary_confirm_send_action(content_text=content_text)
+    if not confirm_action:
+        return resolved
+    return [confirm_action, *resolved]
+
+
+def with_requirement_summary_confirm_send_canvas_event(
+    *,
+    summary_event: dict[str, Any] | None,
+    content_text: str,
+) -> dict[str, Any] | None:
+    """Attach the prompt-confirm action to a Canvas state event."""
+
+    if not isinstance(summary_event, dict):
+        return summary_event
+    payload = _coerce_mapping(summary_event.get("payload"))
+    canvas_state = _coerce_mapping(payload.get("canvas_state"))
+    if not canvas_state:
+        return summary_event
+    next_actions = with_requirement_summary_confirm_send_action(
+        next_actions=canvas_state.get("next_actions") if isinstance(canvas_state.get("next_actions"), list) else [],
+        content_text=content_text,
+    )
+    if not next_actions:
+        return summary_event
+    next_canvas_state = {**canvas_state, "next_actions": next_actions}
+    next_payload = {**payload, "canvas_state": next_canvas_state}
+    return {**summary_event, "payload": next_payload}
+
+
+def should_render_requirement_summary_as_canvas_only(
+    *,
+    runtime_snapshot: dict[str, Any],
+    orchestration_status: dict[str, Any],
+    content_text: str,
+    completion_provider: str,
+    completion_model: str,
+    completion_status: str,
+    command: str,
+) -> bool:
+    """Return whether a generated intake summary is a review prompt, not a reply."""
+
+    if _clean_text(command) not in _CANVAS_ONLY_COMMANDS:
+        return False
+    if _has_document_output_intent(runtime_snapshot):
+        return False
+    # PLN-15: a model-authored intake summary is the prompt-ready artifact to
+    # review/send. Existing active questions remain state carriers, but must not
+    # block the summary confirmation loop or revive mechanical field chasing.
+    return build_model_authored_requirement_summary_event(
+        runtime_snapshot=runtime_snapshot,
+        content_text=content_text,
+        completion_provider=completion_provider,
+        completion_model=completion_model,
+        completion_status=completion_status,
+    ) is not None
+
+
+def with_model_authored_requirement_summary_event(
+    *,
+    runtime_snapshot: dict[str, Any],
+    orchestration_status: dict[str, Any],
+    content_text: str,
+    completion_provider: str,
+    completion_model: str,
+    completion_status: str,
+    command: str,
+) -> list[dict[str, Any]]:
+    """Return mode events with a model-authored Canvas summary event appended."""
+
+    mode_events = list(runtime_snapshot.get("mode_events") if isinstance(runtime_snapshot.get("mode_events"), list) else [])
+    if not should_render_requirement_summary_as_canvas_only(
+        runtime_snapshot=runtime_snapshot,
+        orchestration_status=orchestration_status,
+        content_text=content_text,
+        completion_provider=completion_provider,
+        completion_model=completion_model,
+        completion_status=completion_status,
+        command=command,
+    ):
+        return mode_events
+    summary_event = build_model_authored_requirement_summary_event(
+        runtime_snapshot=runtime_snapshot,
+        content_text=content_text,
+        completion_provider=completion_provider,
+        completion_model=completion_model,
+        completion_status=completion_status,
+    )
+    if summary_event:
+        mode_events.append(with_requirement_summary_confirm_send_canvas_event(
+            summary_event=summary_event,
+            content_text=content_text,
+        ))
+    return mode_events
+
+
+__all__ = [
+    "build_requirement_summary_confirm_send_action",
+    "should_render_requirement_summary_as_canvas_only",
+    "with_requirement_summary_confirm_send_action",
+    "with_requirement_summary_confirm_send_canvas_event",
+    "with_model_authored_requirement_summary_event",
+]

{flare_kernel-0.2.10 → flare_kernel-0.2.11}/src/flare_kernel/router/completion/response_builder.py

@@ -10,6 +10,11 @@ from flare_kernel.router.completion.analysis_policy import apply_completion_cont
 from flare_kernel.router.completion.analysis_result_contract import (
     attach_analysis_result_contract,
 )
+from flare_kernel.router.completion.intake_summary_events import (
+    should_render_requirement_summary_as_canvas_only,
+    with_requirement_summary_confirm_send_action,
+    with_model_authored_requirement_summary_event,
+)
 from flare_kernel.router.next_actions_guard import dedupe_next_actions_by_action_key
 from flare_kernel.runtime.llm.contracts import LLMCompletion
 from flare_kernel.runtime.llm.provider_trace import build_completion_provider_trace
@@ -46,7 +51,7 @@ def _append_sourcing_preview_lines(
     if not lines:
         return content_text
 
-    extra = "先给您两条预检索参考（补充字段后我会重排）：\n" + "\n".join(lines)
+    extra = "先给您两条预检索参考（补充字段后再匹配候选供应商）：\n" + "\n".join(lines)
     base = str(content_text or "").rstrip()
     return f"{base}\n\n{extra}".strip()
 
@@ -124,6 +129,7 @@ def _append_context_answer_lines(*, content_text: str, runtime_snapshot: dict[st
 def build_run_result_payload(
     *,
     content_text: str,
+    effective_command: str = "",
     completion_provider: str,
     completion_model: str,
     completion_status: str,
@@ -157,9 +163,40 @@ def build_run_result_payload(
         runtime_snapshot=runtime_snapshot,
     )
     final_message = _append_citation_lines(content_text=final_message, citations=knowledge_citation)
-    next_actions = dedupe_next_actions_by_action_key(
+    canvas_only_summary = should_render_requirement_summary_as_canvas_only(
+        runtime_snapshot=runtime_snapshot,
+        orchestration_status=orchestration_status,
+        content_text=content_text,
+        completion_provider=completion_provider,
+        completion_model=completion_model,
+        completion_status=completion_status,
+        command=effective_command,
+    )
+    raw_next_actions = dedupe_next_actions_by_action_key(
         orchestration_status.get("next_actions", runtime_snapshot["next_actions"])
     )
+    next_actions = (
+        with_requirement_summary_confirm_send_action(
+            next_actions=raw_next_actions,
+            content_text=content_text,
+        )
+        if canvas_only_summary
+        else raw_next_actions
+    )
+    result_orchestration_status = (
+        {**orchestration_status, "next_actions": next_actions}
+        if canvas_only_summary
+        else orchestration_status
+    )
+    mode_events = with_model_authored_requirement_summary_event(
+        runtime_snapshot=runtime_snapshot,
+        orchestration_status=orchestration_status,
+        content_text=content_text,
+        completion_provider=completion_provider,
+        completion_model=completion_model,
+        completion_status=completion_status,
+        command=effective_command,
+    )
     result = {
         "message": final_message,
         "provider": completion_provider,
@@ -187,22 +224,23 @@ def build_run_result_payload(
                 "llm_success_count": 1 if completion_status == "ok" else 0,
             },
         },
-        "mode_events": runtime_snapshot["mode_events"],
+        "mode_events": mode_events,
         "next_actions": next_actions,
         "retrieved_knowledge": structured_retrieved_knowledge,
         "knowledge_citation": knowledge_citation,
         "context_answer": context_answer,
-        "orchestration_status": orchestration_status,
+        "orchestration_status": result_orchestration_status,
     }
     return attach_analysis_result_contract(
         result=result,
-        orchestration_status=orchestration_status,
+        orchestration_status=result_orchestration_status,
     )
 
 
 def build_action_result_payload(
     *,
     content_text: str,
+    action_command: str = "action",
     completion_provider: str,
     completion_model: str,
     completion_status: str,
@@ -227,6 +265,15 @@ def build_action_result_payload(
     next_actions = dedupe_next_actions_by_action_key(
         orchestration_status.get("next_actions", runtime_snapshot["next_actions"])
     )
+    mode_events = with_model_authored_requirement_summary_event(
+        runtime_snapshot=runtime_snapshot,
+        orchestration_status=orchestration_status,
+        content_text=content_text,
+        completion_provider=completion_provider,
+        completion_model=completion_model,
+        completion_status=completion_status,
+        command=action_command,
+    )
     return {
         "message": content_text,
         "provider": completion_provider,
@@ -250,7 +297,7 @@ def build_action_result_payload(
                 "llm_success_count": 1 if completion_status == "ok" else 0,
             },
         },
-        "mode_events": runtime_snapshot["mode_events"],
+        "mode_events": mode_events,
         "next_actions": next_actions,
         "orchestration_status": orchestration_status,
         "selected_action": {

{flare_kernel-0.2.10 → flare_kernel-0.2.11}/src/flare_kernel/router/completion/selection.py

@@ -12,6 +12,47 @@ from flare_kernel.runtime.llm.llm_provider import LLMCompletion
 _DOCUMENT_OUTPUT_INTENTS = frozenset({"document_template_output", "document_draft_output"})
 
 
+def _coerce_mapping(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _resolve_current_question(
+    *,
+    runtime_snapshot: dict[str, Any],
+    orchestration_status: dict[str, Any],
+) -> dict[str, Any]:
+    current_question = _coerce_mapping(orchestration_status.get("current_question"))
+    if current_question:
+        return current_question
+    mode_events = runtime_snapshot.get("mode_events")
+    event_list = mode_events if isinstance(mode_events, list) else []
+    for event in reversed(event_list):
+        if not isinstance(event, dict):
+            continue
+        payload = _coerce_mapping(event.get("payload"))
+        current_question = _coerce_mapping(payload.get("current_question"))
+        if current_question:
+            return current_question
+    return {}
+
+
+def _build_prompt_payload(
+    *,
+    enriched_payload: dict[str, Any],
+    runtime_snapshot: dict[str, Any],
+    orchestration_status: dict[str, Any],
+) -> dict[str, Any]:
+    prompt_payload = dict(enriched_payload)
+    if not isinstance(prompt_payload.get("current_question"), dict):
+        current_question = _resolve_current_question(
+            runtime_snapshot=runtime_snapshot,
+            orchestration_status=orchestration_status,
+        )
+        if current_question:
+            prompt_payload["current_question"] = current_question
+    return prompt_payload
+
+
 def _should_skip_guided_completion_for_output_request(
     *,
     raw_message: str,
@@ -90,7 +131,17 @@ async def resolve_turn_completion(
             details={"reason": "requirement_clarification_required"},
         )
 
-    prompt = build_prompt_fn(req, enriched_payload, instance_profile, resolved_mode, effective_command)
+    prompt = build_prompt_fn(
+        req,
+        _build_prompt_payload(
+            enriched_payload=enriched_payload,
+            runtime_snapshot=runtime_snapshot,
+            orchestration_status=orchestration_status,
+        ),
+        instance_profile,
+        resolved_mode,
+        effective_command,
+    )
     if on_llm_delta_fn is None:
         return await generate_llm_completion_fn(
             prompt,

{flare_kernel-0.2.10 → flare_kernel-0.2.11}/src/flare_kernel/router/context/endpoint.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from typing import Any, Callable
 
 from flare_kernel.contracts import KernelRequest
+from flare_kernel.router.prompting.summary_contract import apply_prompt_summary_contract
 
 
 def _normalize_action_target_mode(value: str) -> str:
@@ -87,6 +88,7 @@ def prepare_action_turn_context(
         payload=action_payload,
         instance_profile=instance_profile,
     )
+    apply_prompt_summary_contract(payload=action_payload, runtime_snapshot=runtime_snapshot)
     orchestration_status = build_orchestration_status_fn(
         trace_id=trace_id,
         command=action_command,