@qingflow-tech/qingflow-cli 1.1.43-beta.2 → 1.1.43-beta.4

package/skills/qingflow-cli/reference/builder/reference/app-delivery-sop.md

@@ -1,10 +1,10 @@
 # Builder 应用交付重流程 SOP：分组 → 应用定位 → 读场 → 改场 → 发布校验
 
-本文是历史低层交付备忘，不是当前表单写入 SOP。稳定 CLI 公开入口仍为 `qingflow builder` / `qingflow build`，但表单字段、分组、布局、设置和删除必须改用 sibling `qingflow-app-form` Skill 的 `app_form_schema/get/validate/apply/app_delete`；本文件中的 `app_schema_apply` / `app_layout_apply` / `builder schema apply` / `builder layout apply` 只用于识别旧载荷和迁移，不得直接调用。
+本文是历史低层交付备忘，不是当前表单写入 SOP。稳定 CLI 公开入口仍为 `qingflow builder` / `qingflow build`，但表单字段、分组、布局和设置必须使用 `qingflow --json builder app-form schema/get/validate/apply`，应用删除使用 `qingflow --json builder app delete --app-key APP_KEY`；本文件中的 `app_schema_apply` / `app_layout_apply` / `builder schema apply` / `builder layout apply` 只用于识别旧载荷和迁移，不得直接调用。
 
 > **权限**：应用基础信息（`app_name` / 图标 / 可见性）、表单、流程、自定义按钮本体、应用级关联资源池走 **应用搭建 / EditAppAuth**；视图更新/删除、按钮的视图位置配置（`view_configs`）和视图内关联资源展示配置走 **视图管理 / ViewManagementAuth**（后端 `beingViewManageStatus`；未开启高级应用权限时等价回落到 DataManageAuth）；**新建视图**额外需要 **DataManageAuth**；报表走 **数据管理 / DataManageAuth**。失败码常见 **40002 / 40161 / 编辑锁** 等，见主技能与 **ADMIN** 速查。
 
-> **契约**：当前表单契约固定通过 `app_form_schema` 获取；其它公开 `app_*_apply` 的 **`allowed_keys` / `allowed_values` / `execution_notes` / 示例** 以在线为准，命令：
+> **契约**：当前表单契约固定通过 `qingflow --json builder app-form schema` 获取；其它公开 `app_*_apply` 仅是 `builder contract --tool-name` 的参数值，**不是可执行 CLI 子命令**。其 **`allowed_keys` / `allowed_values` / `execution_notes` / 示例** 以在线契约为准，命令：
 > `qingflow --json builder contract --tool-name <app_flow_apply|app_views_apply|app_custom_buttons_apply|app_associated_resources_apply|app_publish_verify>`
 >
 > **CLI 文件载荷注意**：契约示例里可能出现 `"profile": "default"`，那是请求上下文示例；使用 CLI 的 `--*-file` 时不要把 `profile` 写进 JSON 文件。需要指定账号上下文时用根级参数：`qingflow --profile default ...`。
@@ -27,7 +27,7 @@
 | D | **`app_get` / `app_get_fields`** | `qingflow --json builder app get --app-key <APP_KEY>` / `qingflow --json builder app get --app-key <APP_KEY> fields` | 默认 `app_get` 是应用地图，含字段摘要、视图、图表、自定义按钮和关联资源池；`fields` 只读表单可搭建字段 |
 | D | **`app_read_layout_summary`** | `qingflow --json builder app get --app-key <APP_KEY> layout` | 读 **布局**（段落、`rows` 字段名矩阵、`unplaced_fields`） |
 | D | **`app_read_flow_summary`** | `qingflow --json builder app get --app-key <APP_KEY> flow` | 读 **流程**是否启用、节点摘要（公开面能力有限） |
-| E | **`app_form_apply`** | `qingflow --json builder app-form validate/apply --file …` | 完整 AppForm：字段、分组、行、设置和应用创建/更新 |
+| E | **AppForm** | `qingflow --json builder app-form validate --schema-version VERSION --file DECLARATION.json` -> `qingflow --json builder app-form apply --file DECLARATION.json` | 完整 AppForm：字段、分组、行、设置和应用创建/更新 |
 | F | — | 由 AppForm 的 `body` 一并维护 | 表单段落 / 行 / 单元格随完整声明提交 |
 | G | **`app_flow_apply`** | `qingflow builder flow apply …` | **线性流程** 节点与转移（见契约限制） |
 | G′（维护） | **`app_custom_buttons_apply`** | `qingflow builder button apply …` | 仅用于用户明确要求维护已有独立按钮：样式/图标、跨视图复用、删除按钮本体或批量重排 |
@@ -120,9 +120,9 @@ qingflow --json builder app resolve \
 
 ### 3.2 单应用新建（历史 `app_schema_apply` 迁移说明）
 
-当前新建和更新请使用 sibling `qingflow-app-form` Skill；下方旧命令仅用于迁移脚本识别，不能执行。
+当前新建和更新请使用 `qingflow --json builder app-form schema/get/validate/apply`；下方旧命令仅用于迁移脚本识别，不能执行。
 
-历史脚本可能先读取图标候选；当前 AppForm 新建同样先按 sibling Skill 读取并固定合法图标和颜色：
+历史脚本可能先读取图标候选；当前 AppForm 新建同样先读取并固定合法图标和颜色：
 
 ```bash
 qingflow --json builder icon catalog
@@ -259,7 +259,7 @@ qingflow --json builder app get --app-key "<APP_KEY>" flow
 
 ## 5. 改场三口（历史 schema/layout 迁移说明 + 当前 flow）
 
-`app_schema_apply` / `app_layout_apply` 已从公开 MCP/CLI surface 移除。下方 schema/layout 命令只用于迁移旧脚本；当前表单和布局必须走 `qingflow-app-form` Skill。
+`app_schema_apply` / `app_layout_apply` 已从公开 MCP/CLI surface 移除。下方 schema/layout 命令只用于迁移旧脚本；当前表单和布局必须使用 `qingflow --json builder app-form schema/get/validate/apply`。
 
 ### 5.1 历史字段载荷：`builder schema apply`（仅迁移识别）
 
@@ -324,7 +324,7 @@ qingflow builder flow apply \
 
 ## 6. 字段类型迁移对照（旧 `app_schema_apply` 载荷）
 
-以下内容只帮助迁移旧载荷；当前字段类型、camelCase 配置和必填项以 pinned `app_form_schema` 为准。
+以下内容只帮助迁移旧载荷；当前字段类型、camelCase 配置和必填项以固定版本的 `qingflow --json builder app-form schema` 返回结果为准。
 
 智能体可优先写更自然的字段类型，工具会在写入前归一化；读回仍显示 canonical 类型：
 

package/skills/qingflow-cli/reference/core/QINGFLOW_CLI_FIELD_DATA_TYPES.md

@@ -2,7 +2,7 @@
 
 > **用途**：说明 **`record schema …`** 的 **`fields[]`**、**`record list` / `record get` / `record access`** 行内值、以及 **insert/update 写入 payload** 的常见对应关系；并单独说明 **选项联动、关联记录、引用填充、公式/系统题、AI 与受限类型** 等在 CLI 下的表现与处置。
 > **依据**：当前 CLI 在 **`--json`** 下会对 **schema** 响应做 **裁剪**：通常只保留本节列出的键；**`kind`** 由内部写入类别归并而来（见下表）。**`que_type` 等若未出现在输出中**，以 **`kind` + 实跑预检** 为准。
-> **关联**：写入值细节与成员/部门见 **[QINGFLOW_CLI_RECORD_CREATE_WORKFLOW.md](../record/QINGFLOW_CLI_RECORD_CREATE_WORKFLOW.md)**；更新流程见 **[QINGFLOW_CLI_RECORD_UPDATE_WORKFLOW.md](../record/QINGFLOW_CLI_RECORD_UPDATE_WORKFLOW.md)**；只读见 **[QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md](./QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md)**；**搭建侧** AppForm 的 `type`（与本文 `kind` 命名体系不同）见 **[30-schema-fields.md](../builder/30-schema-fields.md)** 和 sibling **[qingflow-app-form Skill](../../../qingflow-app-form/SKILL.md)**；主技能 **[../SKILL.md](../../SKILL.md)**。
+> **关联**：写入值细节与成员/部门见 **[QINGFLOW_CLI_RECORD_CREATE_WORKFLOW.md](../record/QINGFLOW_CLI_RECORD_CREATE_WORKFLOW.md)**；更新流程见 **[QINGFLOW_CLI_RECORD_UPDATE_WORKFLOW.md](../record/QINGFLOW_CLI_RECORD_UPDATE_WORKFLOW.md)**；只读见 **[QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md](./QINGFLOW_CLI_DATA_RETRIEVAL_WORKFLOW.md)**；**搭建侧** AppForm 的 `type`（与本文 `kind` 命名体系不同）及其 CLI 命令见 **[30-schema-fields.md](../builder/30-schema-fields.md)**；主技能 **[../SKILL.md](../../SKILL.md)**。
 
 ---
 

package/skills/qingflow-cli/reference/examples/README.md

@@ -4,7 +4,7 @@ Use these files as copyable bases after reading the matching resource document.
 
 | Resource | Main example | Notes |
 |----------|--------------|-------|
-| Historical single-app schema probe | [schema/schema_single_app_form_standard.example.json](./schema/schema_single_app_form_standard.example.json) | Retired `--form-file` shape; use the `qingflow-app-form` Skill for current declarations. |
+| Historical single-app schema probe | [schema/schema_single_app_form_standard.example.json](./schema/schema_single_app_form_standard.example.json) | Retired `--form-file` shape; use `builder app-form schema/get/validate/apply` for current declarations. |
 | Historical multi-app schema probe | [schema/schema_multi_app_form_relation_layout.example.json](./schema/schema_multi_app_form_relation_layout.example.json) | Retired `--apps-file` shape; current systems create independent AppForms and then bind confirmed app keys. |
 | Existing-app layout probe | [layout/layout_sections_full.example.json](./layout/layout_sections_full.example.json) | Historical layout-patch shape; current new and existing forms use the complete AppForm `spec.body`. |
 | Views | [views/views_upsert_table_minimal.example.json](./views/views_upsert_table_minimal.example.json), [views/views_batch_full.example.json](./views/views_batch_full.example.json) | `views[]` shape with filters, query panel, view-bound buttons, batch upsert/patch/remove. |

package/skills/qingflow-common/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: qingflow-common
+description: Route Qingflow work through the shared public concepts and choose the matching CLI or MCP package. Use when comparing Qingflow CLI and MCP capabilities, selecting an execution surface, or handing work between record, task, form, workflow, and builder skills.
+---
+
+# Qingflow Common Concepts
+
+Treat CLI and MCP as two invocation surfaces for the same Qingflow public contract. Choose the surface that is installed in the current runtime, then keep the same business workflow and declaration shape unless that operation is explicitly surface-specific.
+
+## Choose A Surface
+
+| Available runtime | Use | Best fit |
+| --- | --- | --- |
+| Terminal, script, CI, or a local file workflow | Qingflow CLI | Repeatable commands and JSON files |
+| Agent has `qingflow-mcp` tools | Qingflow MCP | Records, tasks, packages, forms, views, workflows, portals, and builder configuration |
+
+Do not require both surfaces. If only one is installed, complete the workflow on that surface. Do not expose a CLI-only command as an MCP tool, or vice versa.
+
+## Shared Concepts
+
+- **AppForm** is the versioned declarative definition for an application form: app metadata, fields, sections, layout, settings, and field configuration. The same JSON declaration is used by CLI and Qingflow MCP.
+- **Record** is runtime data written to an existing app. Use the record schema before an insert, update, import, or analysis workflow.
+- **Task** is a workflow work item. Prefer task operations for approval, transfer, rollback, and assignee actions.
+- **Builder resource** is package, app, view, chart, portal, navigation, or workflow configuration. It is separate from record data.
+- **Schema version** is part of the public contract. Pin it for one AppForm or workflow operation and do not combine values from different versions.
+
+## Invocation Mapping
+
+| Business operation | CLI | MCP |
+| --- | --- | --- |
+| Form schema/read/apply/delete | `qingflow --json builder app-form ...` / `builder app delete` | `app_form_schema`, `app_form_get`, `app_form_apply`, `app_delete` |
+| AppForm static validation | `qingflow --json builder app-form validate --file ...` | Performed inside `app_form_apply`; no separate tool |
+| Record and task work | `qingflow --json record ...` / `task ...` | Qingflow MCP record and task tools |
+| Package, view, portal, chart, workflow | `qingflow --json builder ...` | Qingflow MCP configuration tools |
+
+The operation names and payload schemas are defined by the public surface. Use the current Schema or tool input schema as the source of truth, not a legacy command name or backend payload.
+
+## Package Boundaries
+
+- `@qingflow-tech/qingflow-cli` packages CLI execution guidance and CLI-supported workflows.
+- `@qingflow-tech/qingflow-mcp` packages every MCP Skill and exposes one unified MCP service. Record operations and system configuration are task routes in this service, not package or server choices.
+
+Each package includes this common Skill. The CLI package installs its CLI guidance; the MCP package installs every MCP domain Skill. The source of every packaged Skill is `qingflow-support/mcp-server/skills/`.
+
+## Route Next
+
+Use the installed package's relevant domain Skill. In the unified MCP package, select the Skill by the requested work, not by an assumed user or builder server role. Do not link to or invoke a domain Skill that the current package did not install.

package/skills/qingflow-common/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Qingflow Common Concepts"
+  short_description: "Route Qingflow work across CLI and MCP"
+  default_prompt: "Use $qingflow-common to choose the correct Qingflow CLI or MCP workflow."

package/src/qingflow_mcp/__main__.py

@@ -1,9 +1,8 @@
 """Entry point for running qingflow_mcp as a module.
 
-Default to the curated user-facing MCP surface. Split package and console
-entrypoints can still start the builder server explicitly.
+Start the unified Qingflow MCP surface.
 """
-from qingflow_mcp.server_app_user import main
+from qingflow_mcp.server import main
 
 if __name__ == "__main__":
     main()

package/src/qingflow_mcp/app_form_compat.py

@@ -5,7 +5,6 @@ from typing import Any
 
 from .builder_facade.app_form_schema import AppFormContractError
 from .json_types import JSONObject
-from .solution.compiler.icon_utils import validate_workspace_icon_choice
 
 
 TYPE_ALIASES = {
@@ -40,18 +39,25 @@ def normalize_app_form_declaration(payload: JSONObject) -> tuple[JSONObject, lis
     warnings: list[JSONObject] = []
 
     def visit(field: JSONObject, path: str) -> None:
-        raw_type = str(field.get("type") or "").strip()
+        raw_type = str(field.get("questionType") or field.get("type") or "").strip()
         canonical_type = TYPE_ALIASES.get(raw_type, raw_type)
         if canonical_type:
-            field["type"] = canonical_type
+            field["questionType"] = canonical_type
+        if "type" in field:
+            if "questionType" in field and str(field.get("type") or "").strip() != raw_type:
+                raise AppFormContractError("INVALID_SPEC", "conflicting aliases: type and questionType", path=path)
+            field.pop("type", None)
         if canonical_type != raw_type and raw_type == "boolean":
             warnings.append({"code": "LEGACY_BOOLEAN_NORMALIZED", "path": f"{path}/type"})
 
         for old, new in (
-            ("as_data_title", "dataTitle"),
-            ("as_data_cover", "dataCover"),
+            ("required", "beingRequired"),
+            ("description", "questionDescription"),
             ("default_type", "defaultType"),
             ("default_value", "defaultValue"),
+            ("question_description", "questionDescription"),
+            ("question_type", "questionType"),
+            ("being_required", "beingRequired"),
         ):
             if old not in field:
                 continue
@@ -96,25 +102,3 @@ def normalize_app_form_declaration(payload: JSONObject) -> tuple[JSONObject, lis
                 if isinstance(field, dict):
                     visit(field, f"/spec/body/{block_index}/rows/{row_index}/fields/{field_index}")
     return result, warnings
-
-
-def validate_app_form_create_icon(payload: JSONObject) -> None:
-    if "appKey" in payload:
-        return
-    spec = payload.get("spec")
-    if not isinstance(spec, dict):
-        return
-    ok, error_code, message, details = validate_workspace_icon_choice(
-        icon=str(spec.get("icon") or "") or None,
-        color=str(spec.get("color") or "") or None,
-        require_explicit=True,
-        disallow_generic=True,
-    )
-    if not ok:
-        color_errors = {"WORKSPACE_ICON_COLOR_REQUIRED", "WORKSPACE_ICON_COLOR_NOT_FOUND"}
-        raise AppFormContractError(
-            error_code or "WORKSPACE_ICON_INVALID",
-            message or "invalid workspace icon configuration",
-            path="/spec/color" if error_code in color_errors else "/spec/icon",
-            details=details,
-        )

package/src/qingflow_mcp/app_form_validator.py

@@ -2,12 +2,27 @@ from __future__ import annotations
 
 from copy import deepcopy
 import json
+import re
 from typing import Any, Iterable
 
 from jsonschema import Draft202012Validator, FormatChecker
 
-from .app_form_compat import normalize_app_form_declaration, validate_app_form_create_icon
-from .builder_facade.app_form_schema import AppFormContractError
+from .app_form_compat import normalize_app_form_declaration
+from .builder_facade.app_form_schema import AppFormContractError, compact_schema_errors, schema_error_message
+
+
+_INTEGRATION_OUTPUT_TARGET_FIELD_TYPES = {
+    "text",
+    "long_text",
+    "number",
+    "amount",
+    "date",
+    "datetime",
+    "single_choice",
+    "single_select",
+    "multi_select",
+}
+_Q_LINKER_TEMPLATE_RE = re.compile(r"\{\{(?P<key>[^{}\s]+)\}\}")
 
 
 class AppFormValidationError(ValueError):
@@ -20,13 +35,17 @@ class AppFormValidationError(ValueError):
         self.api_version = api_version
 
 
+def _field_type(field: dict[str, Any]) -> str:
+    return str(field.get("questionType") or field.get("type") or "").strip()
+
+
 def _field_types(payload: dict[str, Any]) -> tuple[str, ...]:
     found: set[str] = set()
 
     def visit(field: Any) -> None:
         if not isinstance(field, dict):
             return
-        field_type = str(field.get("type") or "").strip()
+        field_type = _field_type(field)
         if field_type:
             found.add(field_type)
         for child in field.get("subfields") or []:
@@ -77,14 +96,6 @@ def _compose(summary: dict[str, Any], details: list[dict[str, Any]]) -> dict[str
     return schema
 
 
-def _leaf_errors(error: Any) -> Iterable[Any]:
-    if not error.context:
-        yield error
-        return
-    for child in error.context:
-        yield from _leaf_errors(child)
-
-
 def _pointer(parts: Iterable[Any]) -> str:
     encoded = [str(item).replace("~", "~0").replace("/", "~1") for item in parts]
     return "/" + "/".join(encoded) if encoded else "/"
@@ -116,38 +127,198 @@ def _static_errors(payload: dict[str, Any]) -> list[tuple[str, str]]:
             for field_index, field in enumerate(fields):
                 if isinstance(field, dict):
                     top_fields.append((f"{row_path}/{field_index}", field))
-    if top_fields and sum(field.get("dataTitle") is True for _, field in top_fields) != 1:
-        errors.append(("/spec/body", "a non-empty body must contain exactly one dataTitle field"))
-    covers = [(path, field) for path, field in top_fields if field.get("dataCover") is True]
-    if len(covers) > 1:
-        errors.append(("/spec/body", "body may contain at most one dataCover field"))
-    for path, field in covers:
-        if field.get("type") != "attachment":
-            errors.append((f"{path}/dataCover", "dataCover is only valid on attachment fields"))
+    def resolve_local_selector(selector: Any) -> tuple[str, tuple[str, dict[str, Any]] | None]:
+        """Resolve against the declared body, preserving backend-dependent ID-only cases."""
+        if not isinstance(selector, dict):
+            return "schema", None
+        raw_que_id = selector.get("queId")
+        que_id = raw_que_id if isinstance(raw_que_id, int) and not isinstance(raw_que_id, bool) else None
+        raw_name = selector.get("name")
+        name = raw_name if isinstance(raw_name, str) and raw_name else ""
+        if raw_que_id is not None and que_id is None:
+            return "schema", None
+        if raw_name is not None and not name:
+            return "schema", None
+        if que_id is not None:
+            matches = [(path, field) for path, field in top_fields if field.get("queId") == que_id]
+            if len(matches) != 1:
+                return "invalid", None
+            declared_name = str(matches[0][1].get("name") or "")
+            if name and declared_name and name != declared_name:
+                return "invalid", None
+            return "resolved", matches[0]
+        if name:
+            matches = [(path, field) for path, field in top_fields if str(field.get("name") or "") == name]
+            if len(matches) == 1:
+                return "resolved", matches[0]
+            if len(matches) > 1:
+                return "invalid", None
+            if any(not str(field.get("name") or "") for _, field in top_fields):
+                return "unknown", None
+            return "invalid", None
+        return "schema", None
+
+    title_selector = spec.get("dataTitleField")
+    if top_fields:
+        if "dataTitleField" not in spec and "appKey" in payload:
+            pass
+        elif title_selector is None or resolve_local_selector(title_selector)[0] == "invalid":
+            errors.append(("/spec/dataTitleField", "dataTitleField must resolve to exactly one top-level field"))
+    elif title_selector is not None:
+        errors.append(("/spec/dataTitleField", "dataTitleField must be null when body is empty"))
+
+    cover_selector = spec.get("dataCoverField")
+    if cover_selector is not None:
+        cover_resolution, cover = resolve_local_selector(cover_selector)
+        if cover_resolution == "invalid":
+            errors.append(("/spec/dataCoverField", "dataCoverField must resolve to exactly one top-level field"))
+        elif cover_resolution == "resolved" and cover is not None and _field_type(cover[1]) != "attachment":
+            errors.append(("/spec/dataCoverField", "dataCoverField must select a top-level attachment field"))
     names: dict[str, str] = {}
     fields_by_id = {
         field.get("queId"): field
         for _, field in top_fields
         if isinstance(field.get("queId"), int) and not isinstance(field.get("queId"), bool)
     }
+    output_targets: dict[str, tuple[str, str]] = {}
     for path, field in top_fields:
         name = str(field.get("name") or "")
-        if name in names:
-            errors.append((f"{path}/name", f"duplicate top-level field name; first declared at {names[name]}"))
+        if name:
+            if name in names:
+                errors.append((f"{path}/name", f"duplicate top-level field name; first declared at {names[name]}"))
+            else:
+                names[name] = f"{path}/name"
+        field_type = _field_type(field)
+        if field_type == "data_relation":
+            config = field.get("config") if isinstance(field.get("config"), dict) else {}
+            filters = config.get("filters") if isinstance(config.get("filters"), dict) else {}
+            if filters.get("mode") == "simple":
+                for group_index, group in enumerate(filters.get("groups") or []):
+                    for condition_index, condition in enumerate(group if isinstance(group, list) else []):
+                        if not isinstance(condition, dict):
+                            continue
+                        operator = condition.get("operator")
+                        operand = condition.get("operand") if isinstance(condition.get("operand"), dict) else {}
+                        values = operand.get("values") if isinstance(operand.get("values"), list) else None
+                        operand_path = (
+                            f"{path}/config/filters/groups/{group_index}/{condition_index}/operand"
+                        )
+                        if operator in {"is_empty", "is_not_empty"}:
+                            if operand.get("kind") != "literal" or values != []:
+                                errors.append(
+                                    (
+                                        operand_path,
+                                        "is_empty and is_not_empty require a literal operand with values: []",
+                                    )
+                                )
+                        elif operand.get("kind") == "literal" and not values:
+                            errors.append(
+                                (
+                                    f"{operand_path}/values",
+                                    "literal operands for non-empty operators must contain at least one value",
+                                )
+                            )
+        if field_type == "q_linker":
+            binding_name = "qLinkerBinding"
+        elif field_type == "code_block":
+            binding_name = "codeBlockBinding"
         else:
-            names[name] = f"{path}/name"
-        if field.get("type") != "q_linker":
             continue
-        binding = (field.get("config") or {}).get("qLinkerBinding") if isinstance(field.get("config"), dict) else None
-        for index, item in enumerate((binding or {}).get("inputs") or [] if isinstance(binding, dict) else []):
-            if not isinstance(item, dict) or item.get("source") != "json_path":
+        binding = (field.get("config") or {}).get(binding_name) if isinstance(field.get("config"), dict) else None
+        if not isinstance(binding, dict):
+            continue
+        for index, item in enumerate(binding.get("inputs") or []):
+            if not isinstance(item, dict):
                 continue
             selector = item.get("field") if isinstance(item.get("field"), dict) else {}
-            selected_name = selector.get("name")
+            input_path = f"{path}/config/{binding_name}/inputs/{index}"
+            resolution, selected = resolve_local_selector(selector)
+            if resolution == "invalid":
+                errors.append((f"{input_path}/field", "input field must resolve to exactly one top-level field"))
+                continue
+            if field_type != "q_linker" or item.get("source") != "json_path":
+                continue
+            selected_name = selected[1].get("name") if selected is not None else selector.get("name")
             if not selected_name and selector.get("queId") in fields_by_id:
                 selected_name = fields_by_id[selector["queId"]].get("name")
             if selected_name and item.get("key") != selected_name:
-                errors.append((f"{path}/config/qLinkerBinding/inputs/{index}/key", "json_path key must equal the selected field name"))
+                errors.append((f"{input_path}/key", "json_path key must equal the selected field name"))
+
+        if field_type == "q_linker":
+            request = binding.get("request") if isinstance(binding.get("request"), dict) else {}
+            template_paths: dict[str, list[str]] = {}
+            for property_name in ("url", "jsonValue", "xmlValue"):
+                raw_template = request.get(property_name)
+                if not isinstance(raw_template, str):
+                    continue
+                for match in _Q_LINKER_TEMPLATE_RE.finditer(raw_template):
+                    template_paths.setdefault(match.group("key"), []).append(
+                        f"{path}/config/{binding_name}/request/{property_name}"
+                    )
+            input_items = [item for item in binding.get("inputs") or [] if isinstance(item, dict)]
+            json_path_inputs: dict[str, list[int]] = {}
+            for index, item in enumerate(input_items):
+                key = str(item.get("key") or "")
+                if key and item.get("source") == "json_path":
+                    json_path_inputs.setdefault(key, []).append(index)
+            for key, request_paths in template_paths.items():
+                providers = json_path_inputs.get(key) or []
+                if len(providers) == 1:
+                    continue
+                if not providers:
+                    message = (
+                        f"placeholder '{{{{{key}}}}}' requires an input with source 'json_path' and the same key; "
+                        "query_param, header, and url_encoded inputs do not replace request templates"
+                    )
+                else:
+                    message = f"placeholder '{{{{{key}}}}}' must have exactly one json_path input"
+                errors.append((request_paths[0], message))
+            for key, indexes in json_path_inputs.items():
+                if key in template_paths:
+                    continue
+                for index in indexes:
+                    errors.append(
+                        (
+                            f"{path}/config/{binding_name}/inputs/{index}/source",
+                            f"json_path input key '{key}' must appear as '{{{{{key}}}}}' in request.url, request.jsonValue, or request.xmlValue",
+                        )
+                    )
+
+        producer = name or str(field.get("queId") or field_type)
+        for index, item in enumerate(binding.get("outputs") or []):
+            if not isinstance(item, dict):
+                continue
+            selector = item.get("targetField")
+            target_path = f"{path}/config/{binding_name}/outputs/{index}/targetField"
+            resolution, selected = resolve_local_selector(selector)
+            if resolution == "invalid":
+                errors.append((target_path, "targetField must resolve to exactly one top-level field"))
+                continue
+            if resolution != "resolved" or selected is None:
+                continue
+            selected_path, target_field = selected
+            target_name = str(target_field.get("name") or target_field.get("queId") or "")
+            target_type = _field_type(target_field)
+            if target_type and target_type not in _INTEGRATION_OUTPUT_TARGET_FIELD_TYPES:
+                allowed = ", ".join(sorted(_INTEGRATION_OUTPUT_TARGET_FIELD_TYPES))
+                errors.append(
+                    (
+                        target_path,
+                        f"output target field '{target_name}' uses unsupported questionType '{target_type}'; allowed types: {allowed}",
+                    )
+                )
+            previous = output_targets.get(selected_path)
+            if previous is None:
+                output_targets[selected_path] = (producer, target_path)
+                continue
+            previous_producer, previous_path = previous
+            errors.append(
+                (
+                    target_path,
+                    f"field '{target_name}' is already targeted by output from '{previous_producer}' at {previous_path}; "
+                    "each field can receive output from only one Q-Linker or code block relation",
+                )
+            )
     return errors
 
 
@@ -184,15 +355,10 @@ def validate_declaration(
     Draft202012Validator.check_schema(schema)
     validator = Draft202012Validator(schema, format_checker=FormatChecker())
     found: dict[tuple[str, str], None] = {}
-    for error in validator.iter_errors(declaration):
-        for leaf in _leaf_errors(error):
-            found[(_pointer(leaf.absolute_path), f"{leaf.validator}: {leaf.message}")] = None
+    for error in compact_schema_errors(validator.iter_errors(declaration), schema):
+        found[(_pointer(error.absolute_path), f"{error.validator}: {schema_error_message(error)}")] = None
     for pointer, message in _static_errors(declaration):
         found[(pointer, message)] = None
-    try:
-        validate_app_form_create_icon(declaration)
-    except AppFormContractError as error:
-        found[(error.path or "/", error.message)] = None
     if found:
         issues = [{"pointer": pointer, "message": message} for pointer, message in sorted(found)]
         raise AppFormValidationError(issues, schema_version=pinned, api_version=api_version)