A5-R3-R1 dormant product UI projection

app.py

@@ -22,6 +22,7 @@ from config import APP_CONFIG
 from managed_auth import (
     cancel_generation_task,
     generation_task_status,
+    get_product_ui_projection,
     recover_generation_task,
     require_alipay_login,
     render_logged_in_account,
@@ -645,12 +646,19 @@ def _process_pending_launch(lang_code: str) -> None:
         return
     mode = str(pending.get("mode") or "").strip().lower()
     idempotency_key = str(pending.get("idempotency_key") or "").strip()
+    projection = get_product_ui_projection()
+    selected_product_tier = (
+        str(st.session_state.get("sp_product_tier") or "").strip().upper()
+        if projection.get("mode") == "a5_product"
+        else None
+    )
     try:
         response = start_generation_task(
             idempotency_key=idempotency_key,
             mode=mode,
             interface_language=lang_code,
             target_words=int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"]),
+            product_tier=selected_product_tier,
         )
     except Exception as exc:
         st.session_state["sp_pending_launch"] = None
@@ -659,6 +667,8 @@ def _process_pending_launch(lang_code: str) -> None:
             st.session_state["sp_payment_required"] = True
             st.error(tr(lang_code, "quota_exhausted"))
             render_payment_purchase(lang_code)
+        elif "a5_product_task_path_not_authorized" in raw:
+            st.error(tr(lang_code, "product_generation_not_active"))
         else:
             st.error(raw)
         return
@@ -1317,11 +1327,56 @@ def render_workspace_controls(user):
 
     st.text_input(tr(lang_code, "topic_label"), value=DEFAULT_TOPIC, disabled=active, key="sp_topic")
     st.text_input(tr(lang_code, "keywords_label"), value=DEFAULT_KEYWORDS, disabled=active, key="sp_keywords")
+
+    product_ui = get_product_ui_projection()
+    if product_ui.get("mode") == "a5_product":
+        products = product_ui.get("products") or {}
+        tier_options = [tier for tier in ("STANDARD", "FLAGSHIP") if tier in products]
+        if len(tier_options) != 2:
+            st.error(tr(lang_code, "product_generation_not_active"))
+            st.stop()
+        selected_tier = str(st.session_state.get("sp_product_tier") or "STANDARD").strip().upper()
+        if selected_tier not in tier_options:
+            selected_tier = "STANDARD"
+            st.session_state["sp_product_tier"] = selected_tier
+        selected_tier = st.radio(
+            tr(lang_code, "product_tier_label"),
+            tier_options,
+            index=tier_options.index(selected_tier),
+            format_func=lambda tier: tr(lang_code, f"product_tier_{tier.lower()}"),
+            horizontal=True,
+            disabled=active,
+            key="sp_product_tier",
+        )
+        selected_product = products[selected_tier]
+        word_min = int(selected_product["min_body_words"])
+        word_max = int(selected_product["max_body_words"])
+        word_label = tr(
+            lang_code,
+            "words_label_product",
+            min_words=word_min,
+            max_words=word_max,
+        )
+    else:
+        st.session_state.pop("sp_product_tier", None)
+        word_min = int(APP_CONFIG["target_words_min"])
+        word_max = int(APP_CONFIG["target_words_max"])
+        word_label = tr(
+            lang_code,
+            "words_label",
+            min_words=word_min,
+            max_words=word_max,
+        )
+
+    current_words = int(st.session_state.get("sp_words") or APP_CONFIG["target_words_default"])
+    bounded_words = min(word_max, max(word_min, current_words))
+    if st.session_state.get("sp_words") != bounded_words:
+        st.session_state["sp_words"] = bounded_words
     st.number_input(
-        tr(lang_code, "words_label"),
-        min_value=int(APP_CONFIG["target_words_min"]),
-        max_value=int(APP_CONFIG["target_words_max"]),
-        value=int(APP_CONFIG["target_words_default"]),
+        word_label,
+        min_value=word_min,
+        max_value=word_max,
+        value=bounded_words,
         step=1000,
         disabled=active,
         key="sp_words",

i18n.py

@@ -208,7 +208,12 @@ TEXTS: dict[str, dict[str, str]] = {
         "title": "📊 工商管理论文智能体",
         "topic_label": "📝 论文名称",
         "keywords_label": "🔍 关键字",
-        "words_label": "📏 目标总单词数（5000–20000单词）",
+        "words_label": "📏 目标总单词数（{min_words}–{max_words}单词）",
+        "words_label_product": "📏 目标正文单词数（{min_words}–{max_words}单词）",
+        "product_tier_label": "版本",
+        "product_tier_standard": "标准版",
+        "product_tier_flagship": "旗舰版",
+        "product_generation_not_active": "产品版任务生命周期尚未启用，请勿继续生成。",
         "success": "🎉 流水线推演完毕！双语文档已就绪。",
         "download": "📥 下载文件",
         "system_busy_title": "⏳ 系统忙碌",
@@ -385,6 +390,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "account_chip_user": "用户 {value}",
         "account_chip_free": "免费 {value}篇",
         "account_chip_bonus": "长期 {value}篇",
+        "account_chip_standard": "标准版 {value}篇",
+        "account_chip_flagship": "旗舰版 {value}篇",
         "logout_short": "退出",
         "payment_dialog_title": "支付宝付款",
         "payment_notice": "今日免费额度和长期额度均已用完。支付9.9元可增加3篇长期有效额度。",
@@ -408,7 +415,12 @@ TEXTS: dict[str, dict[str, str]] = {
         "title": "📊 Business Administration Article Agent",
         "topic_label": "📝 Article Title",
         "keywords_label": "🔍 Keywords",
-        "words_label": "📏 Target Word Count (5,000–20,000 words)",
+        "words_label": "📏 Target Word Count ({min_words}–{max_words} words)",
+        "words_label_product": "📏 Target Body Word Count ({min_words}–{max_words} words)",
+        "product_tier_label": "Version",
+        "product_tier_standard": "Standard",
+        "product_tier_flagship": "Flagship",
+        "product_generation_not_active": "The product-tier task lifecycle is not active yet. Generation has been blocked to protect your balance.",
         "success": "🎉 The pipeline is complete. The bilingual documents are ready.",
         "download": "📥 Download Files",
         "system_busy_title": "⏳ System Busy",
@@ -585,6 +597,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "account_chip_user": "User {value}",
         "account_chip_free": "Free {value}",
         "account_chip_bonus": "Bonus {value}",
+        "account_chip_standard": "Standard {value}",
+        "account_chip_flagship": "Flagship {value}",
         "logout_short": "Sign out",
         "payment_dialog_title": "Alipay Payment",
         "payment_notice": "Your daily free quota and long-term quota are exhausted. Pay CNY 9.9 to add three long-term papers.",
@@ -608,7 +622,12 @@ TEXTS: dict[str, dict[str, str]] = {
         "title": "📊 Интеллектуальный агент для научных статей по управлению бизнесом",
         "topic_label": "📝 Название статьи",
         "keywords_label": "🔍 Ключевые слова",
-        "words_label": "📏 Целевой объём (5 000–20 000 слов)",
+        "words_label": "📏 Целевой объём ({min_words}–{max_words} слов)",
+        "words_label_product": "📏 Целевой объём основного текста ({min_words}–{max_words} слов)",
+        "product_tier_label": "Версия",
+        "product_tier_standard": "Стандарт",
+        "product_tier_flagship": "Флагман",
+        "product_generation_not_active": "Жизненный цикл задач продуктовых версий ещё не активирован. Генерация заблокирована для защиты баланса.",
         "success": "🎉 Работа конвейера завершена. Двуязычные документы готовы.",
         "download": "📥 Скачать файлы",
         "system_busy_title": "⏳ Система занята",
@@ -785,6 +804,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "account_chip_user": "Пользователь {value}",
         "account_chip_free": "Бесплатно {value}",
         "account_chip_bonus": "Запас {value}",
+        "account_chip_standard": "Стандарт {value}",
+        "account_chip_flagship": "Флагман {value}",
         "logout_short": "Выйти",
         "payment_dialog_title": "Оплата через Alipay",
         "payment_notice": "Ежедневная бесплатная и долгосрочная квоты исчерпаны. Оплата 9,9 юаня добавляет квоту на три статьи без срока действия.",
@@ -808,7 +829,12 @@ TEXTS: dict[str, dict[str, str]] = {
         "title": "📊 Бизнес-басқару жөніндегі ғылыми мақала интеллектуалды агенті",
         "topic_label": "📝 Мақала атау��",
         "keywords_label": "🔍 Түйін сөздер",
-        "words_label": "📏 Мақсатты көлем (5 000–20 000 сөз)",
+        "words_label": "📏 Мақсатты көлем ({min_words}–{max_words} сөз)",
+        "words_label_product": "📏 Негізгі мәтіннің мақсатты көлемі ({min_words}–{max_words} сөз)",
+        "product_tier_label": "Нұсқа",
+        "product_tier_standard": "Стандарт",
+        "product_tier_flagship": "Флагман",
+        "product_generation_not_active": "Өнімдік нұсқалардың тапсырма өмірлік циклі әлі іске қосылған жоқ. Балансты қорғау үшін генерация бұғатталды.",
         "success": "🎉 Жұмыс үдерісі аяқталды. Екі тілдегі құжаттар дайын.",
         "download": "📥 Файлдарды жүктеу",
         "system_busy_title": "⏳ Жүйе бос емес",
@@ -985,6 +1011,8 @@ TEXTS: dict[str, dict[str, str]] = {
         "account_chip_user": "Пайдаланушы {value}",
         "account_chip_free": "Тегін {value}",
         "account_chip_bonus": "Қор {value}",
+        "account_chip_standard": "Стандарт {value}",
+        "account_chip_flagship": "Флагман {value}",
         "logout_short": "Шығу",
         "payment_dialog_title": "Alipay арқылы төлеу",
         "payment_notice": "Күнделікті тегін және ұзақ мерзімді квота таусылды. 9,9 юань төлегенде мерзімі шектелмеген үш мақала квотасы қосылады.",

managed_auth.py

@@ -144,6 +144,7 @@ def _clear_session() -> None:
     for key in (
         "sp_session_expires_at", "sp_user",
         "sp_last_verified_at", "sp_edge_assertion", "sp_auth_api_origin",
+        "sp_product_ui_projection", "sp_product_tier",
     ):
         st.session_state.pop(key, None)
 
@@ -224,6 +225,84 @@ def _merge_quota_into_session(result: dict[str, Any]) -> None:
         ) + 1
 
 
+def _legacy_product_ui_projection() -> dict[str, Any]:
+    return {
+        "schema_version": "a5-product-ui-v1",
+        "mode": "legacy",
+        "product_tier_selection_required": False,
+        "products": {},
+    }
+
+
+def _normalize_product_ui_projection(value: Any) -> dict[str, Any]:
+    """Accept only the Worker-owned A5 UI projection; never reinterpret legacy quota fields."""
+    if not isinstance(value, dict):
+        return _legacy_product_ui_projection()
+    mode = str(value.get("mode") or "legacy").strip().lower()
+    if mode == "legacy":
+        return _legacy_product_ui_projection()
+    if mode != "a5_product":
+        raise RuntimeError("product_ui_projection_invalid_mode")
+
+    raw_products = value.get("products")
+    raw_entitlement = value.get("entitlement")
+    if not isinstance(raw_products, dict) or not isinstance(raw_entitlement, dict):
+        raise RuntimeError("product_ui_projection_incomplete")
+
+    products: dict[str, dict[str, Any]] = {}
+    for tier in ("STANDARD", "FLAGSHIP"):
+        raw = raw_products.get(tier)
+        if not isinstance(raw, dict):
+            raise RuntimeError("product_ui_projection_missing_tier")
+        try:
+            minimum = int(raw.get("min_body_words"))
+            maximum = int(raw.get("max_body_words"))
+        except (TypeError, ValueError) as exc:
+            raise RuntimeError("product_ui_projection_invalid_word_policy") from exc
+        if minimum <= 0 or maximum < minimum:
+            raise RuntimeError("product_ui_projection_invalid_word_policy")
+        products[tier] = {
+            "product_tier": tier,
+            "product_policy_version": str(raw.get("product_policy_version") or ""),
+            "word_count_policy_version": str(raw.get("word_count_policy_version") or ""),
+            "body_metric": str(raw.get("body_metric") or ""),
+            "min_body_words": minimum,
+            "max_body_words": maximum,
+            "counting_contract_version": str(raw.get("counting_contract_version") or ""),
+        }
+        if not all((
+            products[tier]["product_policy_version"],
+            products[tier]["word_count_policy_version"],
+            products[tier]["body_metric"],
+            products[tier]["counting_contract_version"],
+        )):
+            raise RuntimeError("product_ui_projection_incomplete")
+
+    try:
+        standard_remaining = int(raw_entitlement.get("standard_remaining"))
+        flagship_remaining = int(raw_entitlement.get("flagship_remaining"))
+    except (TypeError, ValueError) as exc:
+        raise RuntimeError("product_ui_projection_invalid_entitlement") from exc
+    if standard_remaining < 0 or flagship_remaining < 0:
+        raise RuntimeError("product_ui_projection_invalid_entitlement")
+
+    return {
+        "schema_version": str(value.get("schema_version") or "a5-product-ui-v1"),
+        "mode": "a5_product",
+        "product_tier_selection_required": True,
+        "products": products,
+        "entitlement": {
+            "standard_remaining": standard_remaining,
+            "flagship_remaining": flagship_remaining,
+        },
+    }
+
+
+def get_product_ui_projection() -> dict[str, Any]:
+    value = st.session_state.get("sp_product_ui_projection")
+    return _normalize_product_ui_projection(value)
+
+
 def get_account_snapshot(*, block: bool = False) -> dict[str, Any] | None:
     bucket = int(time.time() // 30)
     revision = int(st.session_state.get("sp_account_revision") or 0)
@@ -240,16 +319,38 @@ def get_account_snapshot(*, block: bool = False) -> dict[str, Any] | None:
     user = result.get("user")
     if isinstance(user, dict):
         st.session_state["sp_user"] = dict(user)
+    projection = _normalize_product_ui_projection(result.get("product_ui"))
+    st.session_state["sp_product_ui_projection"] = projection
+    if projection["mode"] != "a5_product":
+        st.session_state.pop("sp_product_tier", None)
     # R3.1 single-writer rule: account refresh owns identity/quota only.
     # Task UI state is initialized by recover_generation_task() and thereafter
     # updated only by generation_task_status()/explicit task actions.
     return result
 
 
-def start_generation_task(*, idempotency_key: str, mode: str, interface_language: str, target_words: int) -> dict[str, Any]:
+def start_generation_task(
+    *,
+    idempotency_key: str,
+    mode: str,
+    interface_language: str,
+    target_words: int,
+    product_tier: str | None = None,
+) -> dict[str, Any]:
     normalized = str(idempotency_key or "").strip()
     if not normalized:
         raise RuntimeError("idempotency_key_required")
+    projection = get_product_ui_projection()
+    normalized_tier = str(product_tier or "").strip().upper()
+    if projection.get("mode") == "a5_product":
+        if normalized_tier not in projection.get("products", {}):
+            raise RuntimeError("product_tier_required")
+        # A5-R3-R1 is projection-only. Until entitlement reservation/task policy
+        # snapshot ownership is separately authorized, never fall through to the
+        # legacy quota task path.
+        raise RuntimeError("a5_product_task_path_not_authorized")
+    if normalized_tier:
+        raise RuntimeError("product_tier_not_available_in_legacy_mode")
     result = _edge_call(
         "task_start",
         normalized,
@@ -458,8 +559,15 @@ def render_logged_in_account(
     else:
         user = user or st.session_state.get("sp_user", {})
     user_id = user.get("id", "—")
-    free_remaining = user.get("daily_free_remaining", user.get("daily_free_limit", 3))
-    bonus_papers = user.get("bonus_papers", 0)
+    projection = get_product_ui_projection()
+    product_mode = projection.get("mode") == "a5_product"
+    if product_mode:
+        entitlement = projection["entitlement"]
+        standard_remaining = entitlement["standard_remaining"]
+        flagship_remaining = entitlement["flagship_remaining"]
+    else:
+        free_remaining = user.get("daily_free_remaining", user.get("daily_free_limit", 3))
+        bonus_papers = user.get("bonus_papers", 0)
 
     st.markdown(
         """
@@ -581,14 +689,24 @@ def render_logged_in_account(
 
     info_col, logout_col = st.columns([5.9, 1.65])
     with info_col:
+        if product_mode:
+            balance_markup = (
+                f"<span>{html.escape(tr(language, 'account_chip_standard', value=standard_remaining))}</span>"
+                f'<span class="sp-account-separator">•</span>'
+                f"<span>{html.escape(tr(language, 'account_chip_flagship', value=flagship_remaining))}</span>"
+            )
+        else:
+            balance_markup = (
+                f"<span>{html.escape(tr(language, 'account_chip_free', value=free_remaining))}</span>"
+                f'<span class="sp-account-separator">•</span>'
+                f"<span>{html.escape(tr(language, 'account_chip_bonus', value=bonus_papers))}</span>"
+            )
         st.markdown(
             f"""
             <div class="sp-account-card">
               <span>{html.escape(tr(language, 'account_chip_user', value=user_id))}</span>
               <span class="sp-account-separator">•</span>
-              <span>{html.escape(tr(language, 'account_chip_free', value=free_remaining))}</span>
-              <span class="sp-account-separator">•</span>
-              <span>{html.escape(tr(language, 'account_chip_bonus', value=bonus_papers))}</span>
+              {balance_markup}
             </div>
             """,
             unsafe_allow_html=True,