@josephyan/qingflow-app-user-mcp 0.2.0-beta.45 → 0.2.0-beta.47

package/README.md

@@ -3,13 +3,13 @@
 Install:
 
 ```bash
-npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.45
+npm install @josephyan/qingflow-app-user-mcp@0.2.0-beta.47
 ```
 
 Run:
 
 ```bash
-npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.45 qingflow-app-user-mcp
+npx -y -p @josephyan/qingflow-app-user-mcp@0.2.0-beta.47 qingflow-app-user-mcp
 ```
 
 Environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@josephyan/qingflow-app-user-mcp",
-  "version": "0.2.0-beta.45",
+  "version": "0.2.0-beta.47",
   "description": "Operational end-user MCP for Qingflow records, tasks, comments, and directory workflows.",
   "license": "MIT",
   "type": "module",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "qingflow-mcp"
-version = "0.2.0b45"
+version = "0.2.0b47"
 description = "User-authenticated MCP server for Qingflow"
 readme = "README.md"
 license = "MIT"

package/skills/qingflow-app-user/SKILL.md

@@ -32,7 +32,7 @@ Route to exactly one of these specialized paths:
 
 - If the user does not know the target `app_key`, discover apps first with `app_list` or `app_search`, then route to the specialized skill
 - If the app is known but the available data range is unclear, call `app_get` first and inspect `accessible_views`
-- If the task is about browsing, reading, creating, updating, deleting, attachments, relations, subtable writes, member/department-field candidate lookup, import templates, import-file verification, authorized local file repair, import execution, or import status, switch to `$qingflow-record-crud`
+- If the task is about browsing, reading, creating, updating, deleting, attachments, relations, subtable writes, member/department-field candidate lookup, import templates, import capability discovery, import-file verification, authorized local file repair, import execution, or import status, switch to `$qingflow-record-crud`
 - If the task is about todo discovery, task context, approval actions, rollback or transfer, associated report review, or workflow log review, switch to `$qingflow-task-ops`
 - If the task is about grouped distributions, ratios, rankings, trends, insights, or any final statistical conclusion, switch to `$qingflow-record-analysis`
 - If the MCP is not connected, authenticated, or bound to the right workspace, switch to `$qingflow-mcp-setup`
@@ -43,6 +43,7 @@ Route to exactly one of these specialized paths:
 - if a field or target is still ambiguous after schema/task lookup, ask the user to confirm from a short candidate list instead of guessing
 - if the task can stay read-only, do not write or act
 - if the task involves a user-uploaded import file, do not modify the file unless the user explicitly authorizes repair or normalization
+- if the task involves record import, call `app_get` first and inspect `data.import_capability` before template download, file repair, or import start
 - if the current MCP capability is unsupported, the workflow is awkward, or the user's need still cannot be satisfied after reasonable use, summarize the gap, ask whether to submit feedback, and call `feedback_submit` only after explicit user confirmation
 
 ## Shared Helper

package/skills/qingflow-record-crud/SKILL.md

@@ -137,19 +137,22 @@ Use the import tools for file-based bulk data loading, not `record_write`.
 
 ### Import workflow
 
-1. Get the official template with `record_import_template_get`
-2. Verify the uploaded file with `record_import_verify`
-3. If verification fails, explain the issues first
-4. Only modify the uploaded file if the user explicitly authorizes repair or normalization
-5. If authorized, preserve the original file and write a repaired copy instead of overwriting the source file by default
-6. Use `record_import_repair_local` for authorized `.xlsx` repair
-7. Re-run `record_import_verify` on the repaired copy
-8. Start import only from a successful verification result
-9. Track the job with `record_import_status_get`
+1. Call `app_get` first and inspect `data.import_capability`
+2. If `import_capability.can_import=false`, stop before template download, file repair, or import start
+3. Get the official template with `record_import_template_get`
+4. Verify the uploaded file with `record_import_verify`
+5. If verification fails, explain the issues first
+6. Only modify the uploaded file if the user explicitly authorizes repair or normalization
+7. If authorized, preserve the original file and write a repaired copy instead of overwriting the source file by default
+8. Use `record_import_repair_local` for authorized `.xlsx` repair
+9. Re-run `record_import_verify` on the repaired copy
+10. Start import only from a successful verification result
+11. Track the job with `record_import_status_get`
 
 ### Import discipline
 
 - Do not modify a user-uploaded Excel or CSV file unless the user explicitly authorizes file repair
+- Do not treat file verification as proof of import permission; permission is prechecked from `app_get.import_capability` and still rechecked at `record_import_start`
 - Do not silently normalize, rename, reorder, or delete columns
 - Do not fabricate business values to satisfy validation
 - Only fix format-level issues that keep the user’s intended data semantics intact, such as header alignment, date/number formatting, enum spelling aligned to the template, blank trailing rows, workbook sheet shape, or attachment/url cell normalization

package/src/qingflow_mcp/__init__.py

@@ -2,4 +2,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.2.0b45"
+__version__ = "0.2.0b47"

package/src/qingflow_mcp/server.py

@@ -113,8 +113,10 @@ Analysis answers must include concrete numbers. When applicable, include percent
 
 ## Import Path
 
-`record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
+`app_get -> record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
 
+- Check `app_get.data.import_capability` before doing import work.
+- If `import_capability.can_import=false`, stop before template download, file repair, or import start.
 - Import must go through `verify -> start`; do not start directly from a raw file path.
 - `record_import_start` requires an explicit `being_enter_auditing` choice. Do not assume a default.
 - Do not modify user-uploaded files unless the user explicitly authorizes repair.

package/src/qingflow_mcp/server_app_user.py

@@ -101,8 +101,10 @@ Analysis answers must include concrete numbers. When applicable, include percent
 
 ## Import Path
 
-`record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
+`app_get -> record_import_template_get -> record_import_verify -> (optional authorized record_import_repair_local) -> record_import_start -> record_import_status_get`
 
+- Check `app_get.data.import_capability` before doing import work.
+- If `import_capability.can_import=false`, stop before template download, file repair, or import start.
 - Import must go through `verify -> start`; do not start directly from a raw file path.
 - `record_import_start` requires an explicit `being_enter_auditing` choice. Do not assume a default.
 - Do not modify user-uploaded files unless the user explicitly authorizes repair.

package/src/qingflow_mcp/tools/app_tools.py

@@ -142,6 +142,7 @@ class AppTools(ToolBase):
         def runner(session_profile, context):
             warnings: list[JSONObject] = []
             app_name = app_key
+            base_info: JSONObject | None = None
 
             try:
                 base_info = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
@@ -163,6 +164,8 @@ class AppTools(ToolBase):
             can_create = self._probe_create_access(context, app_key)
             accessible_views = self._resolve_accessible_system_views(context, app_key)
             accessible_views.extend(self._resolve_accessible_custom_views(context, app_key))
+            import_capability, import_warnings = _derive_import_capability(base_info)
+            warnings.extend(import_warnings)
 
             return {
                 "profile": profile,
@@ -174,6 +177,7 @@ class AppTools(ToolBase):
                     "app_key": app_key,
                     "app_name": app_name,
                     "can_create": can_create,
+                    "import_capability": import_capability,
                     "accessible_views": accessible_views,
                 },
             }
@@ -694,9 +698,88 @@ def _analysis_supported_for_view_type(view_type: str | None) -> bool:
     return normalized not in {"boardview", "ganttview"}
 
 
+def _derive_import_capability(base_info: Any) -> tuple[JSONObject, list[JSONObject]]:
+    warnings: list[JSONObject] = []
+    if not isinstance(base_info, dict):
+        warnings.append(
+            {
+                "code": "IMPORT_CAPABILITY_UNAVAILABLE",
+                "message": "app_get could not determine import capability because baseInfo was unavailable.",
+            }
+        )
+        return _unknown_import_capability(), warnings
+
+    has_data_import_status = "dataImportStatus" in base_info
+    has_data_manage_status = "dataManageStatus" in base_info
+    applicant_import_enabled = _coerce_optional_bool(base_info.get("dataImportStatus")) if has_data_import_status else None
+    data_manage_status = _coerce_optional_bool(base_info.get("dataManageStatus")) if has_data_manage_status else None
+
+    if applicant_import_enabled is True:
+        return {
+            "can_import": True,
+            "auth_source": "apply_auth",
+            "applicant_import_enabled": True,
+            "data_manage_status": data_manage_status,
+            "runtime_checks_required": ["user_disabled", "function_demoted"],
+            "confidence": "preflight",
+        }, warnings
+
+    if data_manage_status is True:
+        return {
+            "can_import": True,
+            "auth_source": "data_manage_auth",
+            "applicant_import_enabled": applicant_import_enabled,
+            "data_manage_status": True,
+            "runtime_checks_required": ["user_disabled", "function_demoted"],
+            "confidence": "preflight",
+        }, warnings
+
+    if applicant_import_enabled is False and data_manage_status is False:
+        return {
+            "can_import": False,
+            "auth_source": "none",
+            "applicant_import_enabled": False,
+            "data_manage_status": False,
+            "runtime_checks_required": [],
+            "confidence": "preflight",
+        }, warnings
+
+    warnings.append(
+        {
+            "code": "IMPORT_CAPABILITY_UNAVAILABLE",
+            "message": "app_get could not fully determine import capability because baseInfo did not include a complete import permission summary.",
+        }
+    )
+    return _unknown_import_capability(
+        applicant_import_enabled=applicant_import_enabled,
+        data_manage_status=data_manage_status,
+    ), warnings
+
+
+def _unknown_import_capability(
+    *,
+    applicant_import_enabled: bool | None = None,
+    data_manage_status: bool | None = None,
+) -> JSONObject:
+    return {
+        "can_import": None,
+        "auth_source": "unknown",
+        "applicant_import_enabled": applicant_import_enabled,
+        "data_manage_status": data_manage_status,
+        "runtime_checks_required": [],
+        "confidence": "unknown",
+    }
+
+
 def _coerce_positive_int(value: Any) -> int | None:
     try:
         number = int(value)
     except (TypeError, ValueError):
         return None
     return number if number > 0 else None
+
+
+def _coerce_optional_bool(value: Any) -> bool | None:
+    if isinstance(value, bool):
+        return value
+    return None

package/src/qingflow_mcp/tools/import_tools.py

@@ -4,6 +4,7 @@ import hashlib
 import json
 import mimetypes
 import shutil
+import tempfile
 from io import BytesIO
 from copy import deepcopy
 from datetime import datetime, timedelta, timezone
@@ -12,15 +13,16 @@ from typing import Any
 from uuid import uuid4
 
 from mcp.server.fastmcp import FastMCP
-from openpyxl import load_workbook
+from openpyxl import Workbook, load_workbook
 
 from ..config import DEFAULT_PROFILE
 from ..errors import QingflowApiError
 from ..import_store import ImportJobStore, ImportVerificationStore
 from ..json_types import JSONObject
+from .app_tools import _derive_import_capability
 from .base import ToolBase
 from .file_tools import FileTools
-from .record_tools import RecordTools
+from .record_tools import RecordTools, _build_field_index, _normalize_form_schema
 
 
 SUPPORTED_IMPORT_EXTENSIONS = {".xlsx", ".xls"}
@@ -132,10 +134,46 @@ class ImportTools(ToolBase):
             return self._failed_template_result(app_key=app_key, error_code="IMPORT_TEMPLATE_UNAUTHORIZED", message="app_key is required")
 
         def runner(session_profile, context):
-            expected_columns, schema_fingerprint = self._expected_import_columns(profile, context, app_key)
+            import_capability, import_warnings = self._fetch_import_capability(context, app_key)
+            expected_columns, schema_fingerprint = self._expected_import_columns(
+                profile,
+                context,
+                app_key,
+                import_capability=import_capability,
+            )
             try:
                 payload = self.backend.request("GET", context, f"/app/{app_key}/apply/excelTemplate")
             except QingflowApiError as exc:
+                if import_capability.get("auth_source") == "apply_auth":
+                    downloaded_to_path = self._write_local_template(
+                        expected_columns=expected_columns,
+                        destination_hint=download_to_path,
+                        app_key=app_key,
+                    )
+                    return {
+                        "ok": True,
+                        "status": "partial_success",
+                        "app_key": app_key,
+                        "ws_id": session_profile.selected_ws_id,
+                        "request_route": self.backend.describe_route(context),
+                        "template_url": None,
+                        "downloaded_to_path": downloaded_to_path,
+                        "expected_columns": expected_columns,
+                        "schema_fingerprint": schema_fingerprint,
+                        "warnings": import_warnings
+                        + [
+                            {
+                                "code": "IMPORT_TEMPLATE_LOCAL_FALLBACK",
+                                "message": "Official template download requires data management permission; MCP generated a local applicant-import template instead.",
+                            }
+                        ],
+                        "verification": {
+                            "schema_fingerprint": schema_fingerprint,
+                            "template_url_resolved": False,
+                            "template_downloaded": True,
+                            "template_source": "local_generated",
+                        },
+                    }
                 return self._failed_template_result(
                     app_key=app_key,
                     error_code="IMPORT_TEMPLATE_UNAUTHORIZED",
@@ -151,11 +189,12 @@ class ImportTools(ToolBase):
                     request_route=self.backend.describe_route(context),
                 )
             downloaded_to_path = None
-            warnings: list[JSONObject] = []
+            warnings: list[JSONObject] = list(import_warnings)
             verification = {
                 "schema_fingerprint": schema_fingerprint,
                 "template_url_resolved": True,
                 "template_downloaded": False,
+                "template_source": "official",
             }
             if download_to_path:
                 destination = _resolve_template_download_path(download_to_path, app_key=app_key)
@@ -197,8 +236,43 @@ class ImportTools(ToolBase):
             return self._failed_verify_result(app_key=app_key, file_path=file_path, error_code="IMPORT_VERIFICATION_FAILED", message="file_path must point to an existing file")
 
         def runner(session_profile, context):
-            expected_columns, schema_fingerprint = self._expected_import_columns(profile, context, app_key)
-            template_header_titles, header_warnings = self._load_template_header_titles(context, app_key)
+            import_capability, import_warnings = self._fetch_import_capability(context, app_key)
+            precheck_known = import_capability.get("auth_source") != "unknown"
+            if not bool(import_capability.get("can_import")):
+                if import_capability.get("auth_source") != "unknown":
+                    return self._failed_verify_result(
+                        app_key=app_key,
+                        file_path=file_path,
+                        error_code="IMPORT_AUTH_PRECHECK_FAILED",
+                        message="the current user does not have import permission for this app",
+                        extra={
+                            "warnings": import_warnings,
+                            "verification": {
+                                "import_auth_prechecked": True,
+                                "import_auth_precheck_passed": False,
+                                "backend_verification_passed": False,
+                            },
+                            "import_capability": import_capability,
+                        },
+                    )
+                import_warnings = list(import_warnings) + [
+                    {
+                        "code": "IMPORT_AUTH_PRECHECK_SKIPPED",
+                        "message": "record_import_verify could not determine import permission from app metadata; continuing with file verification only.",
+                    }
+                ]
+            expected_columns, schema_fingerprint = self._expected_import_columns(
+                profile,
+                context,
+                app_key,
+                import_capability=import_capability,
+            )
+            template_header_titles, header_warnings = self._load_template_header_titles(
+                context,
+                app_key,
+                import_capability=import_capability,
+                expected_columns=expected_columns,
+            )
             local_check = self._local_verify(
                 path=path,
                 app_key=app_key,
@@ -206,7 +280,7 @@ class ImportTools(ToolBase):
                 allowed_header_titles=template_header_titles,
                 schema_fingerprint=schema_fingerprint,
             )
-            warnings = deepcopy(local_check["warnings"]) + header_warnings
+            warnings = import_warnings + deepcopy(local_check["warnings"]) + header_warnings
             issues = deepcopy(local_check["issues"])
             can_import = bool(local_check["can_import"])
             backend_verification = None
@@ -267,6 +341,7 @@ class ImportTools(ToolBase):
                 "can_import": can_import,
                 "issues": issues,
                 "warnings": warnings,
+                "import_capability": import_capability,
                 "apply_rows": backend_verification.get("applyRows") if isinstance(backend_verification, dict) else None,
                 "backend_verification": backend_verification,
                 "local_precheck": local_check,
@@ -287,7 +362,11 @@ class ImportTools(ToolBase):
                 "issues": issues,
                 "repair_suggestions": local_check["repair_suggestions"],
                 "warnings": warnings,
+                "import_capability": import_capability,
                 "verification": {
+                    "import_auth_prechecked": precheck_known,
+                    "import_auth_precheck_passed": True if precheck_known else None,
+                    "import_auth_source": import_capability.get("auth_source"),
                     "local_precheck_passed": bool(local_check["local_precheck_passed"]),
                     "backend_verification_passed": isinstance(backend_verification, dict)
                     and backend_verification.get("beingValidated", True) is not False,
@@ -593,8 +672,20 @@ class ImportTools(ToolBase):
         except RuntimeError as exc:
             return self._runtime_error_as_result(exc, error_code="IMPORT_STATUS_AMBIGUOUS")
 
-    def _expected_import_columns(self, profile: str, context, app_key: str) -> tuple[list[JSONObject], str]:  # type: ignore[no-untyped-def]
-        index = self._record_tools._get_field_index(profile, context, app_key, force_refresh=False)
+    def _expected_import_columns(
+        self,
+        profile: str,
+        context,
+        app_key: str,
+        *,
+        import_capability: JSONObject | None = None,
+    ) -> tuple[list[JSONObject], str]:  # type: ignore[no-untyped-def]
+        auth_source = _normalize_optional_text((import_capability or {}).get("auth_source")) or "unknown"
+        if auth_source == "data_manage_auth":
+            schema = self.backend.request("GET", context, f"/app/{app_key}/form", params={"type": 1})
+            index = _build_field_index(_normalize_form_schema(schema))
+        else:
+            index = self._record_tools._get_field_index(profile, context, app_key, force_refresh=False)
         ws_id = self.sessions.get_profile(profile).selected_ws_id
         expected_columns: list[JSONObject] = []
         for field in index.by_id.values():
@@ -719,7 +810,14 @@ class ImportTools(ToolBase):
             base_result["error_code"] = "IMPORT_VERIFICATION_FAILED"
         return base_result
 
-    def _load_template_header_titles(self, context, app_key: str) -> tuple[list[str] | None, list[JSONObject]]:  # type: ignore[no-untyped-def]
+    def _load_template_header_titles(
+        self,
+        context,
+        app_key: str,
+        *,
+        import_capability: JSONObject | None = None,
+        expected_columns: list[JSONObject] | None = None,
+    ) -> tuple[list[str] | None, list[JSONObject]]:  # type: ignore[no-untyped-def]
         warnings: list[JSONObject] = []
         try:
             payload = self.backend.request("GET", context, f"/app/{app_key}/apply/excelTemplate")
@@ -736,6 +834,17 @@ class ImportTools(ToolBase):
             normalized_titles = [title for title in titles if title]
             return normalized_titles or None, warnings
         except Exception:
+            if (
+                _normalize_optional_text((import_capability or {}).get("auth_source")) == "apply_auth"
+                and expected_columns
+            ):
+                warnings.append(
+                    {
+                        "code": "IMPORT_TEMPLATE_HEADER_LOCAL_FALLBACK",
+                        "message": "Official template headers require data management permission; local precheck fell back to applicant import columns.",
+                    }
+                )
+                return [str(item["title"]) for item in expected_columns], warnings
             warnings.append(
                 {
                     "code": "IMPORT_TEMPLATE_HEADER_UNAVAILABLE",
@@ -744,6 +853,32 @@ class ImportTools(ToolBase):
             )
             return None, warnings
 
+    def _fetch_import_capability(self, context, app_key: str) -> tuple[JSONObject, list[JSONObject]]:  # type: ignore[no-untyped-def]
+        try:
+            payload = self.backend.request("GET", context, f"/app/{app_key}/baseInfo")
+        except QingflowApiError:
+            payload = None
+        return _derive_import_capability(payload)
+
+    def _write_local_template(
+        self,
+        *,
+        expected_columns: list[JSONObject],
+        destination_hint: str | None,
+        app_key: str,
+    ) -> str:
+        if destination_hint:
+            destination = _resolve_template_download_path(destination_hint, app_key=app_key)
+        else:
+            destination = Path(tempfile.gettempdir()) / f"qingflow-import-template-{app_key}-{uuid4().hex[:8]}.xlsx"
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        workbook = Workbook()
+        sheet = workbook.active
+        sheet.title = "导入模板"
+        sheet.append([str(item["title"]) for item in expected_columns])
+        workbook.save(destination)
+        return str(destination)
+
     def _failed_template_result(
         self,
         *,
@@ -767,8 +902,16 @@ class ImportTools(ToolBase):
             "message": message,
         }
 
-    def _failed_verify_result(self, *, app_key: str, file_path: str, error_code: str, message: str) -> dict[str, Any]:
-        return {
+    def _failed_verify_result(
+        self,
+        *,
+        app_key: str,
+        file_path: str,
+        error_code: str,
+        message: str,
+        extra: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        payload = {
             "ok": True,
             "status": "failed",
             "error_code": error_code,
@@ -785,11 +928,17 @@ class ImportTools(ToolBase):
             "repair_suggestions": [],
             "warnings": [],
             "verification": {
+                "import_auth_prechecked": False,
+                "import_auth_precheck_passed": False,
                 "local_precheck_passed": False,
                 "backend_verification_passed": False,
             },
+            "import_capability": None,
             "message": message,
         }
+        if extra:
+            payload.update(extra)
+        return payload
 
     def _failed_repair_result(self, *, error_code: str, message: str, extra: dict[str, Any] | None = None) -> dict[str, Any]:
         payload = {
@@ -983,11 +1132,35 @@ def _analyze_headers(
     issues: list[JSONObject] = []
     repair_suggestions: list[str] = []
     if missing:
-        issues.append(_issue("MISSING_COLUMNS", f"Missing expected columns: {', '.join(missing)}", severity="error"))
+        issues.append(
+            _issue(
+                "MISSING_COLUMNS",
+                f"Missing expected columns: {', '.join(missing)}",
+                severity="error",
+                repairable=True,
+                repair_code="normalize_headers",
+            )
+        )
     if extra:
-        issues.append(_issue("EXTRA_COLUMNS", f"Unexpected columns: {', '.join(extra)}", severity="error"))
+        issues.append(
+            _issue(
+                "EXTRA_COLUMNS",
+                f"Unexpected columns: {', '.join(extra)}",
+                severity="error",
+                repairable=True,
+                repair_code="normalize_headers",
+            )
+        )
     if duplicates:
-        issues.append(_issue("DUPLICATE_COLUMNS", f"Duplicate columns: {', '.join(sorted(set(duplicates)))}", severity="error"))
+        issues.append(
+            _issue(
+                "DUPLICATE_COLUMNS",
+                f"Duplicate columns: {', '.join(sorted(set(duplicates)))}",
+                severity="error",
+                repairable=True,
+                repair_code="normalize_headers",
+            )
+        )
     normalized_changes = []
     for text in actual_headers:
         if not text:
@@ -995,7 +1168,7 @@ def _analyze_headers(
         canonical = allowed_by_key.get(_normalize_header_key(text))
         if canonical and canonical != text:
             normalized_changes.append((text, canonical))
-    if normalized_changes:
+    if missing or extra or duplicates or normalized_changes:
         repair_suggestions.append("normalize_headers")
     return {"issues": issues, "repair_suggestions": repair_suggestions}
 
@@ -1045,7 +1218,8 @@ def _sheet_header_map(sheet) -> dict[str, int]:  # type: ignore[no-untyped-def]
 def _repair_headers(sheet, expected_columns: list[JSONObject]) -> bool:  # type: ignore[no-untyped-def]
     changed = False
     expected_by_key = {_normalize_header_key(item["title"]): item["title"] for item in expected_columns}
-    for cell in next(sheet.iter_rows(min_row=1, max_row=1), []):
+    header_cells = list(next(sheet.iter_rows(min_row=1, max_row=1), []))
+    for cell in header_cells:
         text = _normalize_optional_text(cell.value)
         if text is None:
             continue
@@ -1053,6 +1227,19 @@ def _repair_headers(sheet, expected_columns: list[JSONObject]) -> bool:  # type:
         if canonical and canonical != text:
             cell.value = canonical
             changed = True
+    if changed:
+        return True
+
+    # Fallback for template-based files where headers were edited into non-canonical
+    # values but column order is still intact. Keep any extra trailing system columns.
+    for index, column in enumerate(expected_columns, start=1):
+        if index > len(header_cells):
+            break
+        expected_title = str(column["title"]).strip()
+        current_title = _normalize_optional_text(header_cells[index - 1].value)
+        if current_title != expected_title:
+            header_cells[index - 1].value = expected_title
+            changed = True
     return changed
 
 

package/src/qingflow_mcp/tools/task_context_tools.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from typing import Any
 from uuid import uuid4
 
@@ -264,6 +265,13 @@ class TaskContextTools(ToolBase):
                     )
                 )
             before_apply_status = ((task_context.get("record") or {}).get("apply_status"))
+            runtime_baseline = self._capture_task_runtime_baseline(
+                profile=profile,
+                context=context,
+                app_key=app_key,
+                record_id=record_id,
+                workflow_node_id=workflow_node_id,
+            )
             try:
                 raw = self._execute_task_action(
                     profile=profile,
@@ -296,6 +304,7 @@ class TaskContextTools(ToolBase):
                 workflow_node_id=workflow_node_id,
                 action=normalized_action,
                 before_apply_status=before_apply_status,
+                runtime_baseline=runtime_baseline,
             )
             runtime_verified = bool(verification.get("runtime_continuation_verified"))
             status = "success" if runtime_verified else "partial_success"
@@ -400,6 +409,7 @@ class TaskContextTools(ToolBase):
         workflow_node_id: int,
         action: str,
         before_apply_status: Any,
+        runtime_baseline: dict[str, Any] | None = None,
     ) -> tuple[dict[str, Any], list[dict[str, Any]]]:
         verification: dict[str, Any] = {
             "action_executed": True,
@@ -473,11 +483,34 @@ class TaskContextTools(ToolBase):
         )
         verification["downstream_todo_detected"] = downstream_todo_detected
         verification["initiated_task_visible"] = initiated_visible
-
+        baseline_downstream_nodes = set()
+        baseline_log_count = None
+        baseline_log_digest = None
+        if isinstance(runtime_baseline, dict):
+            baseline_downstream_nodes = set(runtime_baseline.get("downstream_todo_nodes") or [])
+            baseline_log_count = runtime_baseline.get("workflow_log_count")
+            baseline_log_digest = runtime_baseline.get("workflow_log_digest")
+        current_downstream_nodes = {
+            int(item.get("workflow_node_id") or 0)
+            for item in todo_items
+            if isinstance(item, dict)
+            and int(item.get("record_id") or 0) == record_id
+            and int(item.get("workflow_node_id") or 0) != workflow_node_id
+        }
+        workflow_log_digest = self._workflow_log_digest(log_items)
+        verification["downstream_todo_nodes"] = sorted(node_id for node_id in current_downstream_nodes if node_id > 0)
+        verification["downstream_todo_changed"] = current_downstream_nodes != baseline_downstream_nodes
+        verification["workflow_log_advanced"] = bool(
+            verification.get("workflow_log_visible")
+            and (
+                (isinstance(baseline_log_count, int) and len(log_items) > baseline_log_count)
+                or (baseline_log_digest is not None and workflow_log_digest is not None and workflow_log_digest != baseline_log_digest)
+            )
+        )
         runtime_verified = bool(
             verification.get("record_state_changed")
-            or downstream_todo_detected
-            or (verification.get("workflow_log_visible") and len(log_items) > 0)
+            or verification.get("downstream_todo_changed")
+            or verification.get("workflow_log_advanced")
         )
         verification["runtime_continuation_verified"] = runtime_verified
         if not runtime_verified:
@@ -489,6 +522,53 @@ class TaskContextTools(ToolBase):
             )
         return verification, warnings
 
+    def _capture_task_runtime_baseline(
+        self,
+        *,
+        profile: str,
+        context: BackendRequestContext,
+        app_key: str,
+        record_id: int,
+        workflow_node_id: int,
+    ) -> dict[str, Any]:
+        baseline: dict[str, Any] = {
+            "workflow_log_visible": False,
+            "workflow_log_count": None,
+            "workflow_log_digest": None,
+            "downstream_todo_nodes": [],
+        }
+        try:
+            log_page = self.backend.request(
+                "POST",
+                context,
+                "/application/workflow/node/record",
+                json_body={
+                    "key": app_key,
+                    "rowRecordId": record_id,
+                    "nodeId": workflow_node_id,
+                    "role": 3,
+                    "pageNum": 1,
+                    "pageSize": 50,
+                },
+            )
+            log_items = self._normalize_workflow_logs(log_page)
+            baseline["workflow_log_visible"] = True
+            baseline["workflow_log_count"] = len(log_items)
+            baseline["workflow_log_digest"] = self._workflow_log_digest(log_items)
+        except QingflowApiError:
+            pass
+        todo_items = self._safe_task_list_items(profile=profile, task_box="todo", app_key=app_key)
+        baseline["downstream_todo_nodes"] = sorted(
+            {
+                int(item.get("workflow_node_id") or 0)
+                for item in todo_items
+                if isinstance(item, dict)
+                and int(item.get("record_id") or 0) == record_id
+                and int(item.get("workflow_node_id") or 0) != workflow_node_id
+            }
+        )
+        return baseline
+
     def _task_action_visibility_unverified_response(
         self,
         *,
@@ -1252,6 +1332,14 @@ class TaskContextTools(ToolBase):
                 )
         return items
 
+    def _workflow_log_digest(self, items: list[dict[str, Any]]) -> str | None:
+        if not items:
+            return None
+        try:
+            return json.dumps(items, ensure_ascii=False, sort_keys=True, default=str)
+        except TypeError:
+            return str(items)
+
     def _first_nested_operation_detail(self, operation: dict[str, Any]) -> Any:
         for key in ("approval", "filling", "cc", "applicant", "qRobotAdd", "qRobotUpdate", "webhook", "qRobotSMS", "qRobotMail"):
             value = operation.get(key)