Step 4A-6-C-R3.2.7 Long-Call Authority Draft UX Cancel Flow and Anonymous S2 Fix

.gitattributes

@@ -33,4 +33,3 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-core/__pycache__/pipeline_agent.cpython-313.pyc filter=lfs diff=lfs merge=lfs -text

__pycache__/desktop.ini

@@ -1,2 +0,0 @@
-[.ShellClassInfo]
-IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

app.py

@@ -320,6 +320,30 @@ def _task_preview_path(task_id: str) -> str:
         return ""
 
 
+def _cleanup_task_artifacts(task_id: str) -> None:
+    """Delete local stage artifacts only after authoritative cancellation."""
+    task_dir = _task_dir(task_id)
+    token = ""
+    request_path = task_dir / "request.json"
+    if request_path.is_file():
+        try:
+            payload = json.loads(request_path.read_text(encoding="utf-8"))
+            token = str(payload.get("preview_token") or "").strip()
+        except Exception:
+            token = ""
+    if re.fullmatch(r"[A-Za-z0-9_-]{32,128}", token):
+        try:
+            (Path(__file__).resolve().parent / "static" / "previews" / f"{token}.json").unlink(missing_ok=True)
+        except Exception as exc:
+            logging.warning("[SP_UI] cancel_preview_cleanup_error task_id=%s error=%s", task_id, type(exc).__name__)
+    shutil.rmtree(task_dir, ignore_errors=True)
+
+
+def _task_mode(task: dict) -> str:
+    mode = str((task or {}).get("mode") or st.session_state.get("run_mode") or "amj").strip().lower()
+    return "asq" if mode == "asq" else "amj"
+
+
 def _task_output_path(task: dict) -> Path | None:
     task_id = str(task.get("task_id") or "").strip()
     filename = os.path.basename(str(task.get("output_filename") or "").strip())
@@ -498,7 +522,7 @@ def _process_pending_cancel() -> None:
         return
     result = cancel_generation_task(task_id)
     if result.get("cancelled"):
-        shutil.rmtree(_task_dir(task_id), ignore_errors=True)
+        _cleanup_task_artifacts(task_id)
     st.session_state["sp_pending_cancel_task_id"] = ""
     st.session_state["sp_generation_task"] = dict(result.get("task") or {}) or None
     st.rerun()
@@ -659,6 +683,17 @@ def _watch_task_status_live(task: dict) -> dict | None:
                 "preview_path": _task_preview_path(task_id),
                 "expected_execution_epoch": int(task.get("execution_epoch") or 0),
                 "initial_checkpoint_seq": int(task.get("checkpoint_seq") or 0),
+                "best_effort_page_exit_cancel": True,
+                "draft_status_labels": {
+                    "default": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_preparing"),
+                    "inputs_and_evidence": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_inputs"),
+                    "S2 + OpenAlex": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_search"),
+                    "literature_synthesis": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_synthesis"),
+                    "research_logic": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_research_logic"),
+                    "outline_planning": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_outline"),
+                    "citation_planning": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_citation"),
+                    "writing": tr(str(st.session_state.get("sp_lang_code") or "zh"), "draft_stage_writing"),
+                },
             },
             key=f"sp_task_watch_{_safe_key(task_id)}",
         )
@@ -705,12 +740,14 @@ def _render_checkpoint_preview(task: dict, lang_code: str) -> None:
     """Render one stable DOM target; browser preview updates mutate it in place."""
     checkpoint = _load_confirmed_checkpoint(task)
     draft = str((checkpoint or {}).get("full_draft_en") or "").strip()
-    escaped = html.escape(draft)
+    initial_text = draft if draft else tr(lang_code, "draft_preparing")
+    escaped = html.escape(initial_text)
+    placeholder = "0" if draft else "1"
     st.markdown(tr(lang_code, "english_draft"))
     st.markdown(
         f"""
         <div id='sp-live-manuscript-shell' style='border:1px solid #e5e7eb;border-radius:8px;padding:14px 16px;min-height:180px;max-height:68vh;overflow:auto;background:#ffffff;'>
-          <div id='sp-live-manuscript-preview' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{escaped}</div>
+          <div id='sp-live-manuscript-preview' data-sp-placeholder='{placeholder}' style='white-space:pre-wrap;overflow-wrap:anywhere;margin:0;font-family:inherit;line-height:1.72;color:#111827;'>{escaped}</div>
           <span id='sp-live-manuscript-cursor' aria-hidden='true' style='display:inline-block;width:7px;height:1.05em;background:#111827;margin-left:2px;vertical-align:-0.12em;animation:spBlink 1s steps(1,end) infinite;'></span>
         </div>
         <style>@keyframes spBlink {{ 0%,49% {{opacity:1}} 50%,100% {{opacity:0}} }}</style>
@@ -877,7 +914,11 @@ def render_workspace_controls(user):
             st.code(template, language="csv")
             st.download_button(label=tr(lang_code, "download_amj_template"), data=template, file_name="AMJ_Data_Template.csv", mime="text/csv", use_container_width=True)
         st.markdown("<div id='sp-generation-action-amj'></div>", unsafe_allow_html=True)
-        if st.button(tr(lang_code, "start_amj"), disabled=active, key="btn_amj"):
+        if active and _task_mode(task) == "amj":
+            if st.button(tr(lang_code, "cancel_generation"), key="cancel_amj"):
+                st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "")
+                st.rerun()
+        elif st.button(tr(lang_code, "start_amj"), disabled=active, key="btn_amj"):
             st.session_state["run_mode"] = "amj"
             st.session_state["sp_pending_launch"] = {"mode": "amj", "idempotency_key": _new_generation_idempotency_key()}
             st.session_state["sp_scroll_to_generation_action"] = True
@@ -895,7 +936,11 @@ def render_workspace_controls(user):
             st.code(template, language="text")
             st.download_button(label=tr(lang_code, "download_asq_template"), data=template, file_name="ASQ_Interview_Template.txt", mime="text/plain", use_container_width=True)
         st.markdown("<div id='sp-generation-action-asq'></div>", unsafe_allow_html=True)
-        if st.button(tr(lang_code, "start_asq"), disabled=active, key="btn_asq"):
+        if active and _task_mode(task) == "asq":
+            if st.button(tr(lang_code, "cancel_generation"), key="cancel_asq"):
+                st.session_state["sp_pending_cancel_task_id"] = str(task.get("task_id") or "")
+                st.rerun()
+        elif st.button(tr(lang_code, "start_asq"), disabled=active, key="btn_asq"):
             st.session_state["run_mode"] = "asq"
             st.session_state["sp_pending_launch"] = {"mode": "asq", "idempotency_key": _new_generation_idempotency_key()}
             st.session_state["sp_scroll_to_generation_action"] = True

config.py

@@ -7,6 +7,12 @@ def load_config():
         "lit_target_papers": int(os.environ.get("LIT_TARGET_PAPERS", "80")),
         "lit_per_page": int(os.environ.get("LIT_PER_PAGE", "100")),
         "lit_max_workers": int(os.environ.get("LIT_MAX_WORKERS", "5")),
+        # R3.2.7: low-volume SmartPaper uses the public Semantic Scholar path
+        # by default. OpenAlex remains the primary resilient source.
+        "s2_anonymous_first": os.environ.get("S2_ANONYMOUS_FIRST", "true").strip().lower() in {"1", "true", "yes", "on"},
+        "s2_anonymous_min_interval_seconds": max(0.8, float(os.environ.get("S2_ANONYMOUS_MIN_INTERVAL_SECONDS", "1.10"))),
+        "citation_planner_batch_size": max(8, min(24, int(os.environ.get("CITATION_PLANNER_BATCH_SIZE", "18")))),
+        "citation_planner_max_tokens": max(1200, min(3200, int(os.environ.get("CITATION_PLANNER_MAX_TOKENS", "2200")))),
         "chunk_words_default": int(os.environ.get("CHUNK_WORDS_DEFAULT", "1500")),
         "target_words_min": 5000,
         "target_words_default": 5000,
@@ -24,9 +30,9 @@ def load_config():
         "rag_chunk_size": int(os.environ.get("RAG_CHUNK_SIZE", "3000")),
         "rag_top_k": int(os.environ.get("RAG_TOP_K", "3")),
         "max_extract_chars": int(os.environ.get("MAX_EXTRACT_CHARS", "150000")),
-        # A DeepSeek request must fail before the 90-second Worker generation
-        # lease can expire without real execution progress. Retries renew the
-        # lease through the execution heartbeat hook.
+        # Model requests may legitimately run longer than one Worker lease.
+        # The independent Executor renews authority continuously; model-token
+        # activity is observability only and never the liveness authority.
         "api_timeouts": {
             "standard": (15, 70),
             "stream": (15, 70),

core/__pycache__/desktop.ini

@@ -1,2 +0,0 @@
-[.ShellClassInfo]
-IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

core/__pycache__/pipeline_agent.cpython-313.pyc

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bb26d239e31ae5bca0996c1f27abaa2459fd38da852e452f089e784f3db5d269
-size 169473

core/generation_runner.py

@@ -326,7 +326,7 @@ class GenerationRunner:
 
         adaptive_structure = state.get("adaptive_structure")
         if not isinstance(adaptive_structure, list) or not adaptive_structure:
-            self._progress(14, "research_logic_and_outline")
+            self._progress(14, "research_logic")
             research_logic_response = self._stream_text(
                 agent.stream_generate_research_logic(
                     topic, keywords, synthesis_result, refs_text,
@@ -340,6 +340,7 @@ class GenerationRunner:
                 raise RuntimeError("research_logic_contract_missing")
             agent.global_memory["research_logic_contract"] = research_logic_contract
 
+            self._progress(14, "outline_planning")
             plan = agent.generate_outline(topic, keywords, mode=mode, data_metadata=data_metadata)
             en_topic = str(plan.get("en_topic", topic))
             structure = plan.get("structure", [])
@@ -354,6 +355,7 @@ class GenerationRunner:
             jit_texts = agent.prefetch_jit_literature(topic, keywords, adaptive_structure)
             if jit_texts:
                 rag_engine._initialize_chunks([jit_texts])
+            self._progress(15, "citation_planning")
             citation_plan = agent.build_claim_evidence_plan(
                 adaptive_structure, topic, synthesis_result, mode=mode, target_unique=CITATION_PLAN_TARGET
             )
@@ -398,6 +400,7 @@ class GenerationRunner:
         )
         citation_plan = state.get("citation_plan") if isinstance(state.get("citation_plan"), dict) else {}
         if not citation_plan:
+            self._progress(15, "citation_planning")
             citation_plan = agent.build_claim_evidence_plan(
                 adaptive_structure, topic, synthesis_result, mode=mode, target_unique=CITATION_PLAN_TARGET
             )

core/pipeline_agent.py

@@ -66,6 +66,8 @@ class SSciPipelineAgent:
         # exposed to the process as environment variables; Streamlit is not a
         # dependency of the executor or pipeline.
         self.s2_key = str(os.environ.get("S2_API_KEY", s2_key) or "").strip()
+        self.s2_anonymous_first = bool(APP_CONFIG.get("s2_anonymous_first", True))
+        self.s2_anonymous_min_interval_seconds = float(APP_CONFIG.get("s2_anonymous_min_interval_seconds", 1.10))
         self.openalex_key = str(os.environ.get("OA_API_KEY", "") or "").strip()
         self.openalex_email = str(APP_CONFIG.get("openalex_email") or "").strip()
             
@@ -90,7 +92,7 @@ class SSciPipelineAgent:
                 "key_present": bool(self.s2_key) if source == "s2" else bool(self.openalex_key),
                 "authenticated_status": None,
                 "anonymous_status": None,
-                "access_mode": "key" if source == "s2" and self.s2_key else "anonymous" if source == "s2" else "api",
+                "access_mode": ("anonymous" if self.s2_anonymous_first else "key") if source == "s2" and self.s2_key else "anonymous" if source == "s2" else "api",
             }
             for source in ("s2", "oa")
         }
@@ -100,9 +102,11 @@ class SSciPipelineAgent:
         # "key" means use the configured key, "anonymous" means a 401/403 key
         # rejection was recovered by an anonymous probe, and "blocked" means
         # both authenticated and anonymous access were rejected.
-        self._s2_access_mode = "key" if self.s2_key else "anonymous"
+        self._s2_access_mode = "anonymous" if self.s2_anonymous_first else ("key" if self.s2_key else "anonymous")
         self._s2_probe_lock = threading.Lock()
-        self._s2_probe_complete = not bool(self.s2_key)
+        self._s2_probe_complete = self.s2_anonymous_first or not bool(self.s2_key)
+        self._s2_request_lock = threading.Lock()
+        self._s2_last_request_at = 0.0
         self.s2_fused = False
         self.oa_fused = False
         self.citation_map = {}
@@ -282,9 +286,13 @@ class SSciPipelineAgent:
             self.citation_audit_log = list(state_dict.get("citation_audit_log", []))
             self.global_memory = state_dict.get("global_memory", self.global_memory)
             loaded_mode = str(state_dict.get("s2_access_mode") or "").strip().lower()
-            if loaded_mode in {"key", "anonymous", "blocked"}:
-                self._s2_access_mode = loaded_mode
-            self._s2_probe_complete = bool(state_dict.get("s2_probe_complete", self._s2_probe_complete))
+            if self.s2_anonymous_first:
+                self._s2_access_mode = "anonymous"
+                self._s2_probe_complete = True
+            else:
+                if loaded_mode in {"key", "anonymous", "blocked"}:
+                    self._s2_access_mode = loaded_mode
+                self._s2_probe_complete = bool(state_dict.get("s2_probe_complete", self._s2_probe_complete))
         logging.info(f"🔄 状态恢复成功: DS API={self.ds_calls}, 现有文献={len(self.citation_map)}")
 
     def _requests_get_with_retry(self, url, headers=None, params=None, timeout=None):
@@ -1590,6 +1598,30 @@ Return ONLY a valid JSON array of strings."""
         self.oa_calls = int(self.source_metrics['oa']['eligible_result_count'])
         return merged
 
+    def _s2_get(self, *, params, headers=None):
+        """Issue an S2 request with public-endpoint pacing when anonymous.
+
+        SmartPaper is low-volume, so one anonymous S2 request at a time is
+        preferable to parallel bursts that trigger the shared public 429 pool.
+        OpenAlex remains independently concurrent.
+        """
+        normalized_headers = dict(headers or {})
+        anonymous = not bool(normalized_headers.get('x-api-key'))
+        if not anonymous:
+            return self._requests_get_with_retry(
+                f"{self.s2_api_url}/paper/search", headers=normalized_headers, params=params
+            )
+        with self._s2_request_lock:
+            elapsed = time.monotonic() - float(self._s2_last_request_at or 0.0)
+            wait = max(0.0, self.s2_anonymous_min_interval_seconds - elapsed)
+            if wait > 0:
+                time.sleep(wait)
+            response = self._requests_get_with_retry(
+                f"{self.s2_api_url}/paper/search", headers={}, params=params
+            )
+            self._s2_last_request_at = time.monotonic()
+            return response
+
     def _s2_worker(self, term, offset):
         self._check_cancelled()
         query = self._normalize_search_query(term)
@@ -1614,11 +1646,7 @@ Return ONLY a valid JSON array of strings."""
         try:
             access_mode = self._s2_access_mode
             headers = {'x-api-key': self.s2_key} if access_mode == 'key' and self.s2_key else {}
-            response = self._requests_get_with_retry(
-                f"{self.s2_api_url}/paper/search",
-                headers=headers,
-                params=params,
-            )
+            response = self._s2_get(params=params, headers=headers)
             status = int(response.status_code)
             self._source_metric_set('s2', 'last_status_code', status)
             if access_mode == 'key':
@@ -1633,11 +1661,7 @@ Return ONLY a valid JSON array of strings."""
                     if not self._s2_probe_complete:
                         self._s2_probe_complete = True
                         self._source_metric_add('s2', 'request_count')
-                        anonymous = self._requests_get_with_retry(
-                            f"{self.s2_api_url}/paper/search",
-                            headers={},
-                            params=params,
-                        )
+                        anonymous = self._s2_get(params=params, headers={})
                         anonymous_status = int(anonymous.status_code)
                         self._source_metric_set('s2', 'anonymous_status', anonymous_status)
                         logging.warning(
@@ -1655,9 +1679,7 @@ Return ONLY a valid JSON array of strings."""
                             self._source_metric_set('s2', 'access_mode', 'blocked')
                     elif self._s2_access_mode == 'anonymous':
                         self._source_metric_add('s2', 'request_count')
-                        response = self._requests_get_with_retry(
-                            f"{self.s2_api_url}/paper/search", headers={}, params=params
-                        )
+                        response = self._s2_get(params=params, headers={})
                         status = int(response.status_code)
                         self._source_metric_set('s2', 'anonymous_status', status)
                         self._source_metric_set('s2', 'last_status_code', status)
@@ -1868,8 +1890,9 @@ Return ONLY a valid JSON array of strings."""
                 self.source_metrics[source]['status'] = 'not_started'
                 self.source_metrics[source]['authenticated_status'] = None
                 self.source_metrics[source]['anonymous_status'] = None
-            self._s2_access_mode = 'key' if self.s2_key else 'anonymous'
-            self._s2_probe_complete = not bool(self.s2_key)
+            self._s2_access_mode = 'anonymous' if self.s2_anonymous_first else ('key' if self.s2_key else 'anonymous')
+            self._s2_probe_complete = self.s2_anonymous_first or not bool(self.s2_key)
+            self._s2_last_request_at = 0.0
             self.source_metrics['s2']['key_present'] = bool(self.s2_key)
             self.source_metrics['s2']['access_mode'] = self._s2_access_mode
             self.s2_calls = self.oa_calls = 0
@@ -2000,12 +2023,15 @@ Return ONLY a valid JSON array of strings."""
         return {word for word in words if word not in stopwords}
 
     def build_claim_evidence_plan(self, tasks, topic, synthesis_result, mode='amj', target_unique=60):
-        """Plan citations by claim/evidence relevance before prose is written.
-
-        This replaces position-based tag allocation. A source is assigned to at
-        most one manuscript unit and only together with a claim that its title/
-        abstract evidence can directly support. Results/Findings, conclusion,
-        abstract-like and appendix units are excluded from literature quotas.
+        """Build a bounded citation-first plan without one oversized model call.
+
+        This replaces position-based citation allocation. R3.2.7 plans sources
+        in small independent batches. Each batch sees only
+        a bounded evidence packet and may fail without invalidating the whole
+        task; deterministic evidence-derived recovery then fills only remaining
+        gaps.  This prevents the former 80-source / 8000-token planner request
+        from holding executor authority for minutes or ending at
+        ``finish_reason='length'``.
         """
         mode = 'asq' if str(mode).lower() == 'asq' else 'amj'
         allowed_ids = (
@@ -2058,41 +2084,71 @@ Return ONLY a valid JSON array of strings."""
                 if sum(capacities.values()) >= target:
                     break
 
-        payload = {
-            'topic': str(topic or '')[:700],
-            'mode': mode,
-            'target_unique_sources': target,
-            'sections': [dict(item, citation_capacity=capacities[item['name']]) for item in sections],
-            'sources': candidates,
-        }
-        system_prompt = """You are a rigorous claim-evidence planner for a top management journal manuscript. Build the citation architecture BEFORE prose is written. Use only the supplied title/abstract evidence. Never use a source to support this study's own sample, coefficients, events, quotations, or findings. Each source may be assigned at most once. Each planned claim must be narrow enough that the supplied evidence directly supports it. Do not manufacture a claim merely to hit the target. Return only valid JSON."""
-        user_prompt = f"""Create a claim-evidence plan.
+        allowed_sections = {item['name'] for item in sections}
+        valid_tags = set(self.citation_map)
+        section_loads = {item['name']: 0 for item in sections}
+        best = []
+        used_tags = set()
+        batch_size = int(APP_CONFIG.get('citation_planner_batch_size', 18))
+        planner_max_tokens = int(APP_CONFIG.get('citation_planner_max_tokens', 2200))
+        system_prompt = (
+            "You are a rigorous claim-evidence planner for a top management journal manuscript. "
+            "Use only the supplied title/abstract evidence. Never use a source to support this study's "
+            "own sample, coefficients, events, quotations, or findings. Each source may be assigned at "
+            "most once. Each planned claim must be narrow enough that the supplied evidence directly "
+            "supports it. Do not manufacture a claim merely to hit a quota. Return only valid JSON."
+        )
+
+        for batch_index in range(0, len(candidates), batch_size):
+            if len(best) >= target:
+                break
+            self._check_cancelled()
+            batch = [row for row in candidates[batch_index:batch_index + batch_size] if row['tag'] not in used_tags]
+            if not batch:
+                continue
+            remaining = target - len(best)
+            payload = {
+                'topic': str(topic or '')[:700],
+                'mode': mode,
+                'remaining_unique_sources': remaining,
+                'sections': [
+                    dict(
+                        item,
+                        remaining_capacity=max(0, capacities[item['name']] - section_loads[item['name']]),
+                    )
+                    for item in sections
+                ],
+                'sources': batch,
+            }
+            user_prompt = f"""Create one bounded claim-evidence batch.
 JSON schema:
 {{"assignments":[{{"tag":"[CITE-01]","section":"exact display_name from sections","claim":"one directly supported external/theoretical/methodological claim"}}]}}
-Aim for {target} distinct sources when the evidence permits. Distribute sources across appropriate non-results sections; do not assign literature to Results/Findings or Conclusion.
+Use only tags supplied in this batch. Assign a source only when its evidence directly supports a useful claim for one permitted section. Do not assign literature to Results/Findings or Conclusion.
 INPUT:
 {json.dumps(payload, ensure_ascii=False)}"""
+            rows = []
+            try:
+                raw = self.call_deepseek(
+                    system_prompt,
+                    user_prompt,
+                    max_tokens=planner_max_tokens,
+                    temp=0.1,
+                    model_role='reasoning',
+                    thinking=False,
+                    allow_fallback=False,
+                )
+                parsed = self._extract_json_from_text(raw)
+                parsed_rows = parsed.get('assignments') if isinstance(parsed, dict) else None
+                if isinstance(parsed_rows, list):
+                    rows = parsed_rows
+            except Exception as exc:
+                logging.warning(
+                    'Citation planner batch fallback: batch=%s size=%s error=%s',
+                    batch_index // batch_size + 1, len(batch), type(exc).__name__,
+                )
 
-        best = []
-        for attempt in range(2):
-            raw = self.call_deepseek(
-                system_prompt,
-                user_prompt + ("\nPrevious attempt was incomplete. Return a fuller plan while keeping every claim directly evidence-supported." if attempt else ""),
-                max_tokens=8000,
-                temp=0.1 + attempt * 0.1,
-                model_role='reasoning',
-                thinking=True,
-                allow_fallback=False,
-            )
-            parsed = self._extract_json_from_text(raw)
-            rows = parsed.get('assignments') if isinstance(parsed, dict) else None
-            if not isinstance(rows, list):
-                continue
-            allowed_sections = {item['name'] for item in sections}
-            valid_tags = set(self.citation_map)
-            unique_tags = set()
-            cleaned = []
-            section_loads = {item['name']: 0 for item in sections}
+            batch_tags = {item['tag'] for item in batch}
+            accepted = 0
             for row in rows:
                 if not isinstance(row, dict):
                     continue
@@ -2101,32 +2157,31 @@ INPUT:
                     tag = f'[{tag}]'
                 section = str(row.get('section') or '').strip()
                 claim = re.sub(r'\s+', ' ', str(row.get('claim') or '')).strip()
-                if tag not in valid_tags or tag in unique_tags or section not in allowed_sections or len(claim.split()) < 5:
-                    continue
-                if section_loads.get(section, 0) >= capacities.get(section, target):
+                if (
+                    tag not in valid_tags or tag not in batch_tags or tag in used_tags
+                    or section not in allowed_sections or len(claim.split()) < 5
+                    or section_loads.get(section, 0) >= capacities.get(section, target)
+                ):
                     continue
-                # Lightweight lexical sanity check. The semantic audit remains
-                # authoritative later, but a zero-overlap plan is rejected now.
                 evidence = str((self.citation_map.get(tag) or {}).get('evidence') or '')
-                overlap = self._citation_terms(claim) & self._citation_terms(evidence)
-                if len(overlap) < 2:
+                if len(self._citation_terms(claim) & self._citation_terms(evidence)) < 2:
                     continue
-                unique_tags.add(tag)
-                cleaned.append({'tag': tag, 'section': section, 'claim': claim})
-                section_loads[section] = section_loads.get(section, 0) + 1
-            if len(cleaned) > len(best):
-                best = cleaned
-            if len(best) >= target:
-                break
+                used_tags.add(tag)
+                best.append({'tag': tag, 'section': section, 'claim': claim})
+                section_loads[section] += 1
+                accepted += 1
+                if len(best) >= target:
+                    break
+            logging.info(
+                'Citation planner batch complete: batch=%s candidates=%s accepted=%s total=%s/%s',
+                batch_index // batch_size + 1, len(batch), accepted, len(best), target,
+            )
 
-        # If a model response is truncated or structurally incomplete, recover
-        # only with claims copied from the supplied abstract evidence itself.
-        # This is not the old position-based citation allocation: the fallback
-        # still requires nonempty abstract evidence and chooses the manuscript
-        # unit by lexical relevance, while each source remains unique.
+        # Evidence-derived recovery is deliberately local and conservative. It
+        # never invents a new empirical fact: the claim is copied from abstract
+        # evidence, and the section is selected by lexical relevance + capacity.
         if len(best) < target:
-            used_tags = {row['tag'] for row in best}
-            loads = {item['name']: sum(1 for row in best if row['section'] == item['name']) for item in sections}
+            loads = dict(section_loads)
             for candidate in candidates:
                 if candidate['tag'] in used_tags:
                     continue
@@ -2147,15 +2202,10 @@ INPUT:
                     name = section['name']
                     if loads[name] >= capacities.get(name, target):
                         continue
-                    section_terms = self._citation_terms(
-                        name + ' ' + section['role']
-                    )
+                    section_terms = self._citation_terms(name + ' ' + section['role'])
                     overlap = len(evidence_terms & section_terms)
                     if overlap <= 0:
                         continue
-                    # Relevance is primary; normalized load prevents one unit
-                    # from absorbing the full citation plan when several units
-                    # are genuinely relevant.
                     load_ratio = loads[name] / max(1, capacities.get(name, 1))
                     ranked.append((overlap, -load_ratio, section['target_words'], name))
                 if not ranked:
@@ -2177,8 +2227,8 @@ INPUT:
                 'evidence': re.sub(r'\s+', ' ', str(meta.get('evidence') or '')).strip()[:900],
             })
         logging.info(
-            'Citation-first plan built: target=%s planned=%s sections=%s',
-            target, len(best), sum(1 for items in plan.values() if items),
+            'Citation-first plan built: target=%s planned=%s sections=%s batch_size=%s',
+            target, len(best), sum(1 for items in plan.values() if items), batch_size,
         )
         return plan
 

i18n.py

@@ -214,9 +214,18 @@ TEXTS: dict[str, dict[str, str]] = {
         "system_busy_title": "⏳ 系统忙碌",
         "system_busy_warning": "🚨 有用户正在生成论文",
         "system_busy_info": "💡 预计25–35分钟后可正常使用",
-        "checkpoint_warning": "⚠️ 系统检测到上次因网络或意外中断的未完成论文任务。",
-        "resume": "🔄 恢复断点续传",
-        "clear": "🗑️ 清除临时数据",
+        "checkpoint_warning": "⚠️ 检测到暂停的未完成论文任务。您可以继续原任务，或删除后重新开始。",
+        "resume": "🔄 继续原任务",
+        "clear": "🗑️ 删除并重新开始",
+        "cancel_generation": "⛔ 取消生成",
+        "draft_preparing": "正在准备英文草稿…",
+        "draft_stage_inputs": "正在整理研究输入与证据…",
+        "draft_stage_search": "正在检索相关文献…",
+        "draft_stage_synthesis": "正在综合文献证据…",
+        "draft_stage_research_logic": "正在构建研究逻辑…",
+        "draft_stage_outline": "正在规划论文结构…",
+        "draft_stage_citation": "正在建立论点与引用关系…",
+        "draft_stage_writing": "正在准备正文写作…",
         "busy_short": "⏳ 有用户正在生成论文，预计25–35分钟后可用。",
         "tab_amj": "✨ 定量研究（AMJ 引擎）",
         "tab_asq": "📝 定性研究（ASQ 引擎）",
@@ -265,7 +274,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "outline_progress": "📝 大纲设计与路由分发……",
         "jit_status": "🔄 正在为方法与结果章节预加载专属文献……",
         "jit_done": "✅ 方法论预加载完成，已注入向量库。",
-        "english_draft": "#### 🇬🇧 英文证据母稿",
+        "english_draft": "#### 🇬🇧 英文草稿",
         "target_draft": "#### {flag} 中文论文",
         "restored": "✅ 已从快照安全恢复",
         "waiting": "⏳ 等待执行……",
@@ -367,9 +376,18 @@ TEXTS: dict[str, dict[str, str]] = {
         "system_busy_title": "⏳ System Busy",
         "system_busy_warning": "🚨 Another user is generating a paper",
         "system_busy_info": "💡 The system is expected to be available in 25–35 minutes",
-        "checkpoint_warning": "⚠️ An unfinished paper task from a network or unexpected interruption was detected.",
-        "resume": "🔄 Resume from Checkpoint",
-        "clear": "🗑️ Clear Temporary Data",
+        "checkpoint_warning": "⚠️ A paused unfinished paper task was detected. You can continue it or delete it and start again.",
+        "resume": "🔄 Continue Previous Task",
+        "clear": "🗑️ Delete and Start Again",
+        "cancel_generation": "⛔ Cancel Generation",
+        "draft_preparing": "Preparing the English draft…",
+        "draft_stage_inputs": "Organizing research inputs and evidence…",
+        "draft_stage_search": "Searching the academic literature…",
+        "draft_stage_synthesis": "Synthesizing literature evidence…",
+        "draft_stage_research_logic": "Building the research logic…",
+        "draft_stage_outline": "Planning the manuscript structure…",
+        "draft_stage_citation": "Mapping claims to supporting sources…",
+        "draft_stage_writing": "Preparing to draft the manuscript…",
         "busy_short": "⏳ Another user is generating a paper. Please try again in about 25–35 minutes.",
         "tab_amj": "✨ Quantitative Research (AMJ Engine)",
         "tab_asq": "📝 Qualitative Research (ASQ Engine)",
@@ -418,7 +436,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "outline_progress": "📝 Designing the outline and routing sections…",
         "jit_status": "🔄 Preloading literature for the Method and Results sections…",
         "jit_done": "✅ Method literature preloaded and added to the vector store.",
-        "english_draft": "#### 🇬🇧 English Evidence Draft",
+        "english_draft": "#### 🇬🇧 English Draft",
         "target_draft": "#### {flag} Chinese Paper",
         "restored": "✅ Restored from checkpoint",
         "waiting": "⏳ Waiting…",
@@ -520,9 +538,18 @@ TEXTS: dict[str, dict[str, str]] = {
         "system_busy_title": "⏳ Система занята",
         "system_busy_warning": "🚨 Другой пользователь формирует статью",
         "system_busy_info": "💡 Ожидаемое время доступности — через 25–35 минут",
-        "checkpoint_warning": "⚠️ Обнаружена незавершённая задача, прерванная из-за сети или другой ошибки.",
-        "resume": "🔄 Продолжить с контрольной точки",
-        "clear": "🗑️ Удалить временные данные",
+        "checkpoint_warning": "⚠️ Обнаружена приостановленная незавершённая задача. Вы можете продолжить её или удалить �� начать заново.",
+        "resume": "🔄 Продолжить предыдущую задачу",
+        "clear": "🗑️ Удалить и начать заново",
+        "cancel_generation": "⛔ Отменить генерацию",
+        "draft_preparing": "Подготовка черновика на английском языке…",
+        "draft_stage_inputs": "Систематизация исследовательских данных и доказательств…",
+        "draft_stage_search": "Поиск научной литературы…",
+        "draft_stage_synthesis": "Синтез литературных доказательств…",
+        "draft_stage_research_logic": "Формирование исследовательской логики…",
+        "draft_stage_outline": "Планирование структуры статьи…",
+        "draft_stage_citation": "Связывание тезисов с источниками…",
+        "draft_stage_writing": "Подготовка к написанию текста…",
         "busy_short": "⏳ Другой пользователь формирует статью. Повторите попытку примерно через 25–35 минут.",
         "tab_amj": "✨ Количественное исследование (движок AMJ)",
         "tab_asq": "📝 Качественное исследование (движок ASQ)",
@@ -571,7 +598,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "outline_progress": "📝 Проектирование структуры и распределение разделов…",
         "jit_status": "🔄 Предварительная загрузка литературы для разделов методов и результатов…",
         "jit_done": "✅ Методическая литература загружена в векторное хранилище.",
-        "english_draft": "#### 🇬🇧 Английский доказательный черновик",
+        "english_draft": "#### 🇬🇧 Черновик на английском языке",
         "target_draft": "#### {flag} Русская версия статьи",
         "restored": "✅ Восстановлено из контрольной точки",
         "waiting": "⏳ Ожидание выполнения…",
@@ -673,9 +700,18 @@ TEXTS: dict[str, dict[str, str]] = {
         "system_busy_title": "⏳ Жүйе бос емес",
         "system_busy_warning": "🚨 Басқа пайдаланушы мақала дайындап жатыр",
         "system_busy_info": "💡 Жүйе шамамен 25–35 минуттан кейін қолжетімді болады",
-        "checkpoint_warning": "⚠️ Желі немесе күтпеген үзіліс салдарынан аяқталмаған тапсырма анықталды.",
-        "resume": "🔄 Бақылау нүктесінен жалғастыру",
-        "clear": "🗑️ Уақытша деректерді тазалау",
+        "checkpoint_warning": "⚠️ Аяқталмаған, уақытша тоқтатылған тапсырма анықталды. Оны жалғастыруға немесе өшіріп, қайта бастауға болады.",
+        "resume": "🔄 Алдыңғы тапсырманы жалғастыру",
+        "clear": "🗑️ Өшіріп, қайта бастау",
+        "cancel_generation": "⛔ Генерацияны тоқтату",
+        "draft_preparing": "Ағылшын тіліндегі бастапқы нұсқа дайындалуда…",
+        "draft_stage_inputs": "Зерттеу кірістері мен дәлелдер реттелуде…",
+        "draft_stage_search": "Ғылыми әдебиеттер ізделуде…",
+        "draft_stage_synthesis": "Әдебиет дәлелдері синтезделуде…",
+        "draft_stage_research_logic": "Зерттеу логикасы құрылуда…",
+        "draft_stage_outline": "Мақала құрылымы жоспарлануда…",
+        "draft_stage_citation": "Тұжырымдар дереккөздермен сәйкестендірілуде…",
+        "draft_stage_writing": "Негізгі мәтінді жазуға дайындалуда…",
         "busy_short": "⏳ Басқа пайдаланушы мақала дайындап жатыр. Шамамен 25–35 минуттан кейін қайталап көріңіз.",
         "tab_amj": "✨ Сандық зерттеу (AMJ қозғалтқышы)",
         "tab_asq": "📝 Сапалық зерттеу (ASQ қозғалтқышы)",
@@ -724,7 +760,7 @@ TEXTS: dict[str, dict[str, str]] = {
         "outline_progress": "📝 Құрылым жобаланып, бөлімдер бөлінуде…",
         "jit_status": "🔄 Әдіс пен нәтижелер бөлімдеріне арналған әдебиеттер алдын ала жүктелуде…",
         "jit_done": "✅ Әдістемелік әдебиеттер векторлық қорға қосылды.",
-        "english_draft": "#### 🇬🇧 Ағылшын тіліндегі дәлелдік нұсқа",
+        "english_draft": "#### 🇬🇧 Ағылшын тіліндегі бастапқы нұсқа",
         "target_draft": "#### {flag} Қазақ тіліндегі мақала",
         "restored": "✅ Бақылау нүктесінен қалпына келтірілді",
         "waiting": "⏳ Орындалуын күтуде…",

smartpaper_restore_bridge/__pycache__/desktop.ini

@@ -1,2 +0,0 @@
-[.ShellClassInfo]
-IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27

smartpaper_restore_bridge/frontend/index.html

@@ -26,6 +26,7 @@
   let lastMonitorCheckpointSeq = 0;
   let lastPreviewText = "";
   let lastPreviewDisplayText = "";
+  let pageExitCancelCleanup = null;
 
   const ACTION_PATHS = Object.freeze({
     task_start: "/edge/task/start",
@@ -220,8 +221,19 @@
     }
   }
 
+  function updateDraftPreparation(parentDocument, node, labels) {
+    const target = parentDocument.getElementById("sp-live-manuscript-preview");
+    if (!target || lastPreviewText || target.querySelector("[data-sp-live-stream='1']")) return;
+    const map = labels && typeof labels === "object" ? labels : {};
+    const value = String(map[node] || map.writing || map.default || "").trim();
+    if (!value) return;
+    target.dataset.spPlaceholder = "1";
+    target.textContent = value;
+  }
+
   function renderPreviewContent(parentDocument, target, text) {
     // Keep one stable text node and append only the newly generated suffix.
+    target.dataset.spPlaceholder = "0";
     // Rebuilding the whole manuscript DOM on every preview poll caused visible
     // repaint/flicker and did not feel like ChatGPT-style streaming.
     const displayText = String(text || "")
@@ -295,7 +307,7 @@
     } catch (_) {}
   }
 
-  function updateTaskMonitor(task) {
+  function updateTaskMonitor(task, watch=null) {
     let parentDocument;
     try { parentDocument = window.parent.document; }
     catch (_) { return; }
@@ -314,6 +326,7 @@
     updateText(parentDocument, "sp-live-progress-text", `${progress}% — ${node}`);
     const fill = parentDocument.getElementById("sp-live-progress-fill");
     if (fill) fill.style.width = `${progress}%`;
+    updateDraftPreparation(parentDocument, node, watch && watch.draftStatusLabels);
 
     if (node && node !== lastMonitorNode) {
       appendTaskActivity(parentDocument, node, false);
@@ -325,9 +338,73 @@
     }
   }
 
+  function removePageExitCancel() {
+    if (typeof pageExitCancelCleanup === "function") {
+      try { pageExitCancelCleanup(); } catch (_) {}
+    }
+    pageExitCancelCleanup = null;
+  }
+
+  function installPageExitCancel(watch) {
+    removePageExitCancel();
+    if (!watch || !watch.bestEffortPageExitCancel) return;
+    let parentWindow;
+    try { parentWindow = window.parent; } catch (_) { return; }
+    let sent = false;
+    let suppressForReload = false;
+    const navigationHandler = (event) => {
+      if (event && String(event.navigationType || "") === "reload") suppressForReload = true;
+    };
+    const keyHandler = (event) => {
+      const key = String(event && event.key || "").toLowerCase();
+      if (key === "f5" || ((event.ctrlKey || event.metaKey) && key === "r")) suppressForReload = true;
+    };
+    try {
+      if (parentWindow.navigation && typeof parentWindow.navigation.addEventListener === "function") {
+        parentWindow.navigation.addEventListener("navigate", navigationHandler);
+      }
+      parentWindow.addEventListener("keydown", keyHandler, true);
+    } catch (_) {}
+    const handler = (event) => {
+      if (event && event.persisted) return;
+      if (suppressForReload) return;
+      if (sent || activeTaskWatch !== watch || watch.stopped) return;
+      sent = true;
+      const url = new URL(ACTION_PATHS.task_cancel, watch.apiOrigin).toString();
+      const body = JSON.stringify({ task_id:watch.taskId });
+      let beaconSent = false;
+      try {
+        if (parentWindow.navigator && typeof parentWindow.navigator.sendBeacon === "function") {
+          const blob = new Blob([body], { type:"application/json" });
+          beaconSent = parentWindow.navigator.sendBeacon(url, blob);
+        }
+      } catch (_) {}
+      if (!beaconSent) {
+        try {
+          parentWindow.fetch(url, {
+            method:"POST", credentials:"include", cache:"no-store", keepalive:true,
+            headers:{ "Accept":"application/json", "Content-Type":"application/json", "X-SmartPaper-Client":"browser-exit-v1" },
+            body
+          }).catch(() => {});
+        } catch (_) {}
+      }
+    };
+    parentWindow.addEventListener("pagehide", handler, { capture:true });
+    pageExitCancelCleanup = () => {
+      parentWindow.removeEventListener("pagehide", handler, { capture:true });
+      parentWindow.removeEventListener("keydown", keyHandler, true);
+      try {
+        if (parentWindow.navigation && typeof parentWindow.navigation.removeEventListener === "function") {
+          parentWindow.navigation.removeEventListener("navigate", navigationHandler);
+        }
+      } catch (_) {}
+    };
+  }
+
   function stopTaskWatch() {
     const watch = activeTaskWatch;
     activeTaskWatch = null;
+    removePageExitCancel();
     if (watch && watch.timer) window.clearTimeout(watch.timer);
     if (watch && watch.previewTimer) window.clearTimeout(watch.previewTimer);
     if (watch && watch.controller) {
@@ -352,8 +429,11 @@
       return;
     }
 
-    const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
+    const draftStatusLabels = payload.draft_status_labels && typeof payload.draft_status_labels === "object" ? payload.draft_status_labels : {};
+    const bestEffortPageExitCancel = payload.best_effort_page_exit_cancel === true;
+    const watch = { commandId, taskId, apiOrigin, intervalMs, previewIntervalMs, previewUrl:resolvedPreviewUrl, expectedEpoch, draftStatusLabels, bestEffortPageExitCancel, timer:null, previewTimer:null, controller:null, stopped:false, lastCheckpointSeq:initialCheckpointSeq };
     activeTaskWatch = watch;
+    installPageExitCancel(watch);
     lastPreviewText = "";
     lastPreviewDisplayText = "";
     lastMonitorCheckpointSeq = Math.max(lastMonitorCheckpointSeq, initialCheckpointSeq);
@@ -377,12 +457,13 @@
       if (activeTaskWatch !== watch || watch.stopped) return;
       const task = result && result.task && typeof result.task === "object" ? result.task : null;
       if (result.ok && task) {
-        updateTaskMonitor(task);
+        updateTaskMonitor(task, watch);
         const status = String(task.status || "");
         const checkpointSeq = asCount(task.checkpoint_seq);
         if (TERMINAL_TASK_STATUSES.has(status) || status === "resumable") {
           watch.stopped = true;
           activeTaskWatch = null;
+          removePageExitCancel();
           sendValue(Object.assign({}, result, {
             action:"task_watch",
             command_id:commandId,

task_executor.py

@@ -16,6 +16,7 @@ import logging
 import os
 import re
 import secrets
+import shutil
 import sys
 import threading
 import time
@@ -270,6 +271,7 @@ class ExecutionState:
         self._s2_calls = 0
         self._oa_calls = 0
         self._cancel = False
+        self._cancel_reason = ""
         self._stop = threading.Event()
         self._thread = None
 
@@ -298,6 +300,16 @@ class ExecutionState:
         with self._lock:
             return bool(self._cancel)
 
+    def cancel_reason(self) -> str:
+        with self._lock:
+            return str(self._cancel_reason or "")
+
+    def _mark_cancelled(self, reason: str) -> None:
+        with self._lock:
+            self._cancel = True
+            if reason:
+                self._cancel_reason = str(reason)[:80]
+
     def start_heartbeat(self):
         self._thread = threading.Thread(target=self._heartbeat_loop, name="smartpaper-executor-heartbeat", daemon=True)
         self._thread.start()
@@ -327,8 +339,7 @@ class ExecutionState:
         payload, _ = self._payload()
         result = self.api.heartbeat(payload)
         if result.get("cancel_requested"):
-            with self._lock:
-                self._cancel = True
+            self._mark_cancelled("user_cancel")
         return result
 
     def _heartbeat_loop(self):
@@ -336,25 +347,33 @@ class ExecutionState:
         grace = int(APP_CONFIG.get("executor_activity_grace_seconds", 45))
         while not self._stop.wait(interval):
             payload, idle_seconds = self._payload()
+            # Long synchronous model calls can legitimately produce no Python
+            # callbacks for more than one Worker lease window.  Model activity
+            # is diagnostic only; process/epoch ownership is the liveness
+            # authority.  Therefore heartbeat must continue while this executor
+            # is alive and authoritative.
             if idle_seconds > grace:
-                logging.warning(
-                    "[SP_EXECUTOR] heartbeat_paused task_id=%s idle_s=%.1f node=%s",
+                logging.info(
+                    "[SP_EXECUTOR] heartbeat_during_long_call task_id=%s idle_s=%.1f node=%s",
                     self.task_id, idle_seconds, payload.get("current_node"),
                 )
-                continue
             try:
                 result = self.api.heartbeat(payload)
                 if result.get("cancel_requested"):
-                    with self._lock:
-                        self._cancel = True
+                    self._mark_cancelled("user_cancel")
                     return
             except ExecutorApiError as exc:
+                if exc.error == "task_cancel_requested":
+                    self._mark_cancelled("user_cancel")
+                    logging.warning(
+                        "[SP_EXECUTOR] task_cancel_requested task_id=%s", self.task_id
+                    )
+                    return
                 if exc.error in {
                     "executor_superseded", "generation_lock_lost",
-                    "task_already_finalized", "task_cancel_requested",
+                    "task_already_finalized",
                 } or exc.status_code in {404, 409, 410}:
-                    with self._lock:
-                        self._cancel = True
+                    self._mark_cancelled("authority_lost")
                     logging.warning(
                         "[SP_EXECUTOR] executor_no_longer_authoritative task_id=%s error=%s",
                         self.task_id, _safe(exc.error, 180),
@@ -365,6 +384,21 @@ class ExecutionState:
                 logging.warning("[SP_EXECUTOR] heartbeat_error task_id=%s error=%s", self.task_id, _safe(exc, 180))
 
 
+def _cleanup_user_cancelled_task_artifacts(task_dir: Path, request_data: dict) -> None:
+    """Delete only local, user-cancelled stage artifacts. D1 audit state remains authoritative."""
+    try:
+        token = str((request_data or {}).get("preview_token") or "").strip()
+        if re.fullmatch(r"[A-Za-z0-9_-]{32,128}", token):
+            preview = Path(__file__).resolve().parent / "static" / "previews" / f"{token}.json"
+            preview.unlink(missing_ok=True)
+    except Exception as exc:
+        logging.warning("[SP_EXECUTOR] cancel_preview_cleanup_error task_id=%s error=%s", task_dir.name, _safe(exc, 160))
+    try:
+        shutil.rmtree(task_dir, ignore_errors=True)
+    except Exception as exc:
+        logging.warning("[SP_EXECUTOR] cancel_task_cleanup_error task_id=%s error=%s", task_dir.name, _safe(exc, 160))
+
+
 def _load_request(task_dir: Path) -> dict:
     path = task_dir / "request.json"
     if not path.is_file():
@@ -529,7 +563,12 @@ def main() -> int:
         return 0
     except Exception as exc:
         if state.cancelled():
-            logging.warning("[SP_EXECUTOR] stopped_non_authoritative task_id=%s epoch=%s", args.task_id, epoch)
+            reason = state.cancel_reason()
+            if reason == "user_cancel":
+                _cleanup_user_cancelled_task_artifacts(task_dir, request_data)
+                logging.info("[SP_EXECUTOR] cancelled_and_cleaned task_id=%s epoch=%s", args.task_id, epoch)
+            else:
+                logging.warning("[SP_EXECUTOR] stopped_non_authoritative task_id=%s epoch=%s reason=%s", args.task_id, epoch, reason or "unknown")
             return 3
         if isinstance(exc, (ImportError, ModuleNotFoundError)):
             logging.exception("[SP_EXECUTOR] bootstrap_import_failed task_id=%s epoch=%s error=%s", args.task_id, epoch, _safe(exc, 240))

utils/__pycache__/desktop.ini

@@ -1,2 +0,0 @@
-[.ShellClassInfo]
-IconResource=C:\Program Files\Google\Drive File Stream\129.0.1.0\GoogleDriveFS.exe,27