优化流程

backend/app/cad_agent/application/llm_contracts.py

@@ -37,6 +37,28 @@ class SpecRequirementInput(StrictDto):
     acceptance_claims: list[AcceptanceClaimInput] = Field(min_length=1, max_length=16)
 
 
+class MarkdownDocument(StrictDto):
+    """A frozen human-readable design artifact, never an executable payload."""
+    markdown: Annotated[str, Field(min_length=1, max_length=16_000)]
+
+
+class CompiledRequirementInput(StrictDto):
+    """One verifier bundle for one server-parsed checklist item.
+
+    The checklist text, ordering, source bindings, and all identifiers are
+    intentionally absent: the service owns them after Markdown is frozen.
+    """
+    assumptions: list[Annotated[str, Field(min_length=1, max_length=360)]] = Field(default_factory=list, max_length=16)
+    acceptance_claims: list[AcceptanceClaimInput] = Field(min_length=1, max_length=16)
+
+
+class CompiledRequirementsSpec(StrictDto):
+    requirements: list[CompiledRequirementInput] = Field(min_length=1, max_length=64)
+
+
+# Kept only so an interrupted process with an already imported old tool schema
+# fails at the workflow boundary instead of failing module import. New v3.1
+# tasks never expose or accept this aggregate specification.
 class RequirementsSpec(StrictDto):
     outcome: Literal["ready"]
     summary: Annotated[str, Field(min_length=1, max_length=2000)]
@@ -61,7 +83,9 @@ class EmptyCommand(StrictDto):
 class NextAction(StrictDto):
     working_head: Annotated[str, Field(pattern=r"^[a-z0-9_:-]{5,192}$")]
     intent: ShortText
-    requirement_ids: list[Identifier] = Field(min_length=1, max_length=5)
+    # The server binds this list from every frozen checklist target. It is not
+    # author input, so a five-item UI-era limit must not reject a valid task.
+    requirement_ids: list[Identifier] = Field(min_length=1, max_length=64)
     atomic_id: Identifier
     expected_change: ShortText
 
@@ -194,6 +218,66 @@ def requirements_spec_schema(claim_one_of: dict[str, Any]) -> dict[str, Any]:
     return schema
 
 
+def compiled_requirements_schema(claim_one_of: dict[str, Any], target_count: int) -> dict[str, Any]:
+    schema = CompiledRequirementsSpec.model_json_schema()
+    definitions = schema.get("$defs", {})
+    requirement = definitions.get("CompiledRequirementInput") if isinstance(definitions, dict) else None
+    if isinstance(requirement, dict):
+        claims = requirement.get("properties", {}).get("acceptance_claims")
+        if isinstance(claims, dict):
+            claims["items"] = deepcopy(claim_one_of)
+    requirements = schema.get("properties", {}).get("requirements")
+    if isinstance(requirements, dict):
+        requirements["minItems"] = target_count
+        requirements["maxItems"] = target_count
+    return schema
+
+
+def sanitize_compiled_requirements_arguments(raw_arguments_json: str) -> str | WorkflowError:
+    """Drop harmless compiler chatter before strict requirements validation.
+
+    ``compile_requirements_spec`` is a compiler stage: the service only needs
+    the ordered verifier bundles for the frozen checklist items. Real models
+    sometimes add explanatory fields such as a top-level ``assumptions`` or
+    per-item ``statement`` even when the dynamic tool schema forbids them. Those
+    fields are not executable and are not part of the frozen contract, so they
+    should not abort a task before modeling starts.
+
+    The verifier ``expected`` payload is intentionally not sanitized here. It
+    remains governed by the registry's strict per-claim schema because those
+    values drive deterministic validation.
+    """
+    value = canonical_json_object(raw_arguments_json)
+    if isinstance(value, WorkflowError):
+        return value
+    requirements = value.get("requirements")
+    sanitized: dict[str, Any] = {}
+    if isinstance(requirements, list):
+        sanitized_requirements: list[Any] = []
+        for requirement in requirements:
+            if not isinstance(requirement, dict):
+                sanitized_requirements.append(requirement)
+                continue
+            item: dict[str, Any] = {}
+            if "assumptions" in requirement:
+                item["assumptions"] = requirement["assumptions"]
+            if "acceptance_claims" in requirement:
+                claims = requirement["acceptance_claims"]
+                if isinstance(claims, list):
+                    item["acceptance_claims"] = [
+                        {key: claim[key] for key in ("claim_kind", "expected") if isinstance(claim, dict) and key in claim}
+                        if isinstance(claim, dict) else claim
+                        for claim in claims
+                    ]
+                else:
+                    item["acceptance_claims"] = claims
+            sanitized_requirements.append(item)
+        sanitized["requirements"] = sanitized_requirements
+    else:
+        sanitized["requirements"] = requirements
+    return json.dumps(sanitized, ensure_ascii=False, separators=(",", ":"))
+
+
 def stateless_next_action_schema(atomic_ids: list[str]) -> dict[str, Any]:
     schema = StatelessNextAction.model_json_schema()
     properties = schema.get("properties", {})
@@ -228,18 +312,6 @@ def topology_request_schema(working_head: str) -> dict[str, Any]:
     return schema
 
 
-def geometry_conclusion_schema(working_head: str, evidence_refs: list[str]) -> dict[str, Any]:
-    """Bind a diagnostic conclusion to evidence generated for this head."""
-    schema = GeometryConclusion.model_json_schema()
-    properties = schema.get("properties", {})
-    if isinstance(properties, dict):
-        properties["working_head"] = {"const": working_head}
-        evidence = properties.get("evidence_refs")
-        if isinstance(evidence, dict):
-            evidence["items"] = {"enum": evidence_refs}
-    return schema
-
-
 def rollback_checkpoint_schema(working_head: str, checkpoint_tokens: list[str]) -> dict[str, Any]:
     """Bind a rollback request to immutable checkpoints in the active lineage."""
     schema = RollbackCheckpoint.model_json_schema()